// SPDX-License-Identifier: LGPL-3.0-only
//
// WARNING: This file was auto-generated by cmd_descs_generate.py script. Do not
// modify it manually. Look at cmd_descs.yaml if you want to update commands.
//

#include "cmd_descs.h"

static const RzCmdDescDetail hash_bang_details[2];
static const RzCmdDescDetail pointer_details[2];
static const RzCmdDescDetail eval_getset_details[2];
static const RzCmdDescDetail env_details[3];
static const RzCmdDescDetail wB_details[2];
static const RzCmdDescDetail wv_details[2];
static const RzCmdDescDetail w1_details[2];
static const RzCmdDescDetail w2_details[2];
static const RzCmdDescDetail w4_details[2];
static const RzCmdDescDetail w8_details[2];
static const RzCmdDescDetail w6_details[2];
static const RzCmdDescDetail zign_add_details[5];
static const RzCmdDescDetail tmp_modifiers_details[2];
static const RzCmdDescDetail iterators_details[2];
static const RzCmdDescDetail redirection_details[2];
static const RzCmdDescDetail pipe_details[2];
static const RzCmdDescDetail grep_details[5];
static const RzCmdDescArg hash_bang_args[3];
static const RzCmdDescArg tasks_args[2];
static const RzCmdDescArg tasks_transient_args[2];
static const RzCmdDescArg tasks_output_args[2];
static const RzCmdDescArg tasks_break_args[2];
static const RzCmdDescArg tasks_delete_args[2];
static const RzCmdDescArg tasks_wait_args[2];
static const RzCmdDescArg pointer_args[3];
static const RzCmdDescArg interpret_args[2];
static const RzCmdDescArg interpret_script_args[2];
static const RzCmdDescArg interpret_output_args[2];
static const RzCmdDescArg interpret_pipe_args[2];
static const RzCmdDescArg interpret_system_args[3];
static const RzCmdDescArg interpret_macro_args[4];
static const RzCmdDescArg remote_args[3];
static const RzCmdDescArg remote_send_args[3];
static const RzCmdDescArg io_system_run_args[2];
static const RzCmdDescArg remote_add_args[2];
static const RzCmdDescArg remote_del_args[2];
static const RzCmdDescArg remote_open_args[2];
static const RzCmdDescArg remote_rap_args[3];
static const RzCmdDescArg remote_tcp_args[3];
static const RzCmdDescArg remote_rap_bg_args[2];
static const RzCmdDescArg push_escaped_args[2];
static const RzCmdDescArg eval_getset_args[2];
static const RzCmdDescArg eval_list_args[2];
static const RzCmdDescArg eval_bool_invert_args[2];
static const RzCmdDescArg eval_editor_args[2];
static const RzCmdDescArg eval_readonly_args[2];
static const RzCmdDescArg eval_spaces_args[2];
static const RzCmdDescArg eval_type_args[2];
static const RzCmdDescArg env_args[3];
static const RzCmdDescArg ls_args[2];
static const RzCmdDescArg project_save_args[2];
static const RzCmdDescArg project_open_args[2];
static const RzCmdDescArg project_open_no_bin_io_args[2];
static const RzCmdDescArg seek_args[2];
static const RzCmdDescArg seek_padded_args[2];
static const RzCmdDescArg seek_base_args[2];
static const RzCmdDescArg seek_delta_args[2];
static const RzCmdDescArg seek_blocksize_backward_args[2];
static const RzCmdDescArg seek_blocksize_forward_args[2];
static const RzCmdDescArg seek_asz_args[3];
static const RzCmdDescArg seek_function_args[2];
static const RzCmdDescArg seek_next_args[2];
static const RzCmdDescArg seek_prev_args[2];
static const RzCmdDescArg seek_opcode_args[2];
static const RzCmdDescArg seek_register_args[2];
static const RzCmdDescArg sleep_args[2];
static const RzCmdDescArg uniq_args[2];
static const RzCmdDescArg uname_args[2];
static const RzCmdDescArg write_args[2];
static const RzCmdDescArg write_bits_args[2];
static const RzCmdDescArg write_unset_bits_args[2];
static const RzCmdDescArg write_value_args[2];
static const RzCmdDescArg write_value1_args[2];
static const RzCmdDescArg write_value2_args[2];
static const RzCmdDescArg write_value4_args[2];
static const RzCmdDescArg write_value8_args[2];
static const RzCmdDescArg write_zero_args[2];
static const RzCmdDescArg write_1_inc_args[2];
static const RzCmdDescArg write_1_dec_args[2];
static const RzCmdDescArg write_2_inc_args[2];
static const RzCmdDescArg write_2_dec_args[2];
static const RzCmdDescArg write_4_inc_args[2];
static const RzCmdDescArg write_4_dec_args[2];
static const RzCmdDescArg write_8_inc_args[2];
static const RzCmdDescArg write_8_dec_args[2];
static const RzCmdDescArg write_base64_decode_args[2];
static const RzCmdDescArg write_base64_encode_args[2];
static const RzCmdDescArg zign_best_args[2];
static const RzCmdDescArg zign_best_name_args[3];
static const RzCmdDescArg zign_delete_args[2];
static const RzCmdDescArg zign_add_args[4];
static const RzCmdDescArg zign_add_fcn_args[3];
static const RzCmdDescArg zign_load_sdb_args[2];
static const RzCmdDescArg zign_save_sdb_args[2];
static const RzCmdDescArg zign_load_gzip_sdb_args[2];
static const RzCmdDescArg zign_flirt_dump_args[2];
static const RzCmdDescArg zign_flirt_scan_args[2];
static const RzCmdDescArg zign_cmp_args[2];
static const RzCmdDescArg zign_cmp_name_args[2];
static const RzCmdDescArg zign_cmp_diff_name_args[2];
static const RzCmdDescArg zign_space_select_args[2];
static const RzCmdDescArg zign_space_delete_args[2];
static const RzCmdDescArg zign_space_add_args[2];
static const RzCmdDescArg zign_space_rename_args[2];
static const RzCmdDescArg zign_info_args[2];
static const RzCmdDescArg zign_info_range_args[3];

static const RzCmdDescHelp cmd_system_help = {
	.summary = "Run given commands as in system(3)",
};

static const RzCmdDescArg last_output_args[] = {
	{ 0 },
};
static const RzCmdDescHelp last_output_help = {
	.summary = "Print last output",
	.args = last_output_args,
};

static const RzCmdDescDetailEntry hash_bang_Examples_detail_entries[] = {
	{ .text = "#!", .arg_str = "python", .comment = "Run python commandline" },
	{ .text = "#!", .arg_str = "python foo.py", .comment = "Run foo.py python script" },
	{ .text = "#!", .arg_str = "python foo.py arg1", .comment = "Run foo.py python script and pass it arg1 as argument" },
	{ 0 },
};
static const RzCmdDescDetail hash_bang_details[] = {
	{ .name = "Examples", .entries = hash_bang_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescArg hash_bang_args[] = {
	{
		.name = "interpreter-name",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,
		.no_space = true,

	},
	{
		.name = "arg",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp hash_bang_help = {
	.summary = "List all available interpreters / Run interpreter",
	.details = hash_bang_details,
	.args = hash_bang_args,
};

static const RzCmdDescHelp cmd_alias_help = {
	.summary = "Alias commands and strings",
};

static const RzCmdDescHelp env_percentage_help = {
	.summary = "Get/set environment variables",
	.args_str = "[<varname>[=<varvalue>]]",
	.details = env_details,
	.args = env_args,
};

static const RzCmdDescHelp and__help = {
	.summary = "Manage tasks",
};
static const RzCmdDescArg tasks_args[] = {
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_help = {
	.summary = "List all tasks / Run <cmd> in a new background task",
	.args = tasks_args,
};

static const RzCmdDescArg tasks_transient_args[] = {
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_transient_help = {
	.summary = "Run <cmd> in a new transient background task (auto-delete when it is finished)",
	.args = tasks_transient_args,
};

static const RzCmdDescArg tasks_output_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_output_help = {
	.summary = "Show output of task <n>",
	.args = tasks_output_args,
};

static const RzCmdDescArg tasks_break_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_break_help = {
	.summary = "Break task <n>",
	.args = tasks_break_args,
};

static const RzCmdDescArg tasks_delete_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_delete_help = {
	.summary = "Delete task <n> or schedule for deletion when it is finished",
	.args = tasks_delete_args,
};

static const RzCmdDescArg tasks_delete_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp tasks_delete_all_help = {
	.summary = "Delete all done tasks",
	.args = tasks_delete_all_args,
};

static const RzCmdDescArg tasks_wait_args[] = {
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp tasks_wait_help = {
	.summary = "Wait until task <n> is finished / all tasks are finished",
	.args = tasks_wait_args,
};

static const RzCmdDescHelp cmd_macro_help = {
	.summary = "Manage scripting macros",
};

static const RzCmdDescDetailEntry pointer_Examples_detail_entries[] = {
	{ .text = "*", .arg_str = "entry0=cc", .comment = "write trap in entrypoint" },
	{ .text = "*", .arg_str = "entry0+10=0x804800", .comment = "write 0x804800 as a 4-byte value at 10 bytes from the entrypoint" },
	{ .text = "*", .arg_str = "entry0", .comment = "read the value contained at the entrypoint" },
	{ 0 },
};
static const RzCmdDescDetail pointer_details[] = {
	{ .name = "Examples", .entries = pointer_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescArg pointer_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp pointer_help = {
	.summary = "Pointer read/write data/values",
	.description = "Read or write values at a given address. When the value starts with `0x`, a 4-bytes value or 8-bytes value is written in the memory at address, depending on the size of the value. When value does not start with `0x` an hexstring with arbitrary length is expected and it is written starting from the specified address.",
	.args_str = "<addr>[=<0xvalue>|<hexstring>]",
	.details = pointer_details,
	.args = pointer_args,
};

static const RzCmdDescHelp cmd_stdin_help = {
	.summary = "Open cfg.editor and run script",
};

static const RzCmdDescHelp dot__help = {
	.summary = "Interpret commands",
};
static const RzCmdDescArg interpret_args[] = {
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,
		.no_space = true,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_help = {
	.summary = "Repeat last executed command backward / Interpret the output of the command as rizin commands",
	.args = interpret_args,
};

static const RzCmdDescArg interpret_script_args[] = {
	{
		.name = "file.rz",
		.type = RZ_CMD_ARG_TYPE_FILE,
		.no_space = true,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_script_help = {
	.summary = "Interpret script",
	.args = interpret_script_args,
};

static const RzCmdDescArg repeat_forward_args[] = {
	{ 0 },
};
static const RzCmdDescHelp repeat_forward_help = {
	.summary = "Repeat last executed command forward (same as \\\\n)",
	.args = repeat_forward_args,
};

static const RzCmdDescArg interpret_output_args[] = {
	{
		.name = "file",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_output_help = {
	.summary = "Run the output of the execution of a script as rizin commands",
	.args = interpret_output_args,
};

static const RzCmdDescArg interpret_editor_2_args[] = {
	{ 0 },
};
static const RzCmdDescHelp interpret_editor_2_help = {
	.summary = "Open cfg.editor and interpret tmp file",
	.args = interpret_editor_2_args,
};

static const RzCmdDescArg interpret_pipe_args[] = {
	{
		.name = "file",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_pipe_help = {
	.summary = "Same as #!pipe open cfg.editor and interpret tmp file",
	.args = interpret_pipe_args,
};

static const RzCmdDescArg interpret_system_args[] = {
	{
		.name = "bin",
		.type = RZ_CMD_ARG_TYPE_FILE,
		.no_space = true,

	},
	{
		.name = "arg",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_system_help = {
	.summary = "Interpret output of command",
	.args = interpret_system_args,
};

static const RzCmdDescArg interpret_macro_args[] = {
	{
		.name = "macro-name",
		.type = RZ_CMD_ARG_TYPE_MACRO,
		.no_space = true,

	},
	{
		.name = "macro-arg",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,
		.optional = true,

	},
	{
		.name = ")",
		.type = RZ_CMD_ARG_TYPE_FAKE,

	},
	{ 0 },
};
static const RzCmdDescHelp interpret_macro_help = {
	.summary = "Interpret output of macro",
	.args = interpret_macro_args,
};

static const RzCmdDescHelp cmd_search_help = {
	.summary = "Search for bytes, regexps, patterns, ..",
};

static const RzCmdDescHelp equal__help = {
	.summary = "Connect with other instances of rizin",
};
static const RzCmdDescArg remote_args[] = {
	{
		.name = "fd",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_help = {
	.summary = "List all open connections / Exec <cmd> at remote <fd>",
	.args_str = " [[<fd>] <cmd>]",
	.args = remote_args,
};

static const RzCmdDescArg remote_send_args[] = {
	{
		.name = "fd",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_send_help = {
	.summary = "Send output of local <cmd> to remote <fd>",
	.args = remote_send_args,
};

static const RzCmdDescArg io_system_run_args[] = {
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp io_system_run_help = {
	.summary = "Run <cmd> via rz_io_system",
	.args = io_system_run_args,
};

static const RzCmdDescArg remote_add_args[] = {
	{
		.name = "[proto://]host:port",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_add_help = {
	.summary = "Connect to remote host:port",
	.args = remote_add_args,
};

static const RzCmdDescArg remote_del_args[] = {
	{
		.name = "fd",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_del_help = {
	.summary = "remove all hosts or host 'fd'",
	.args = remote_del_args,
};

static const RzCmdDescArg remote_open_args[] = {
	{
		.name = "fd",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_open_help = {
	.summary = "Open remote session with host 'fd', 'q' to quit",
	.args = remote_open_args,
};

static const RzCmdDescArg remote_mode_enable_args[] = {
	{ 0 },
};
static const RzCmdDescHelp remote_mode_enable_help = {
	.summary = "Enable remote cmd mode",
	.args = remote_mode_enable_args,
};

static const RzCmdDescArg remote_mode_disable_args[] = {
	{ 0 },
};
static const RzCmdDescHelp remote_mode_disable_help = {
	.summary = "Disable remote cmd mode",
	.args = remote_mode_disable_args,
};

static const RzCmdDescArg remote_rap_args[] = {
	{
		.name = "[host:]port",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_rap_help = {
	.summary = "Start the rap server (o rap://9999) / Execute <cmd> on rap server",
	.args = remote_rap_args,
};

static const RzCmdDescHelp equal_g_handler_old_help = {
	.summary = "Start the gdbserver",
};

static const RzCmdDescHelp equal_h_handler_old_help = {
	.summary = "Start the http webserver",
};

static const RzCmdDescHelp equal_H_handler_old_help = {
	.summary = "Start the http webserver (and launch the web browser)",
};

static const RzCmdDescArg remote_tcp_args[] = {
	{
		.name = "[host:]port",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{
		.name = "cmd",
		.type = RZ_CMD_ARG_TYPE_CMD,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_tcp_help = {
	.summary = "Start the tcp server",
	.args = remote_tcp_args,
};

static const RzCmdDescArg remote_rap_bg_args[] = {
	{
		.name = "port",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp remote_rap_bg_help = {
	.summary = "Start rap server in background (same as '&_=h')",
	.args = remote_rap_bg_args,
};

static const RzCmdDescHelp cmd_help_help = {
	.summary = "Help or evaluate math expression",
	.options = "[??]",
};

static const RzCmdDescArg push_escaped_args[] = {
	{
		.name = "characters",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp push_escaped_help = {
	.summary = "Push escaped string into the RzCons.readChar buffer",
	.args = push_escaped_args,
};

static const RzCmdDescHelp cmd_ox_help = {
	.summary = "Alias for `s 0x...`",
};

static const RzCmdDescHelp cmd_analysis_help = {
	.summary = "Analysis commands",
};

static const RzCmdDescHelp cmd_bsize_help = {
	.summary = "Display or change the block size",
};

static const RzCmdDescHelp cmd_cmp_help = {
	.summary = "Compare block with given data",
};

static const RzCmdDescHelp cmd_meta_help = {
	.summary = "Code metadata (comments, format, hints, ..)",
};

static const RzCmdDescHelp cmd_debug_help = {
	.summary = "Debugger commands",
};

static const RzCmdDescHelp e_help = {
	.summary = "List/get/set config evaluable vars",
};
static const RzCmdDescDetailEntry eval_getset_Examples_detail_entries[] = {
	{ .text = "e", .arg_str = " asm.bytes", .comment = "Show current value of config variable `asm.bytes`" },
	{ .text = "e", .arg_str = " asm.bytes=true", .comment = "Set config variable `asm.bytes` to `true`" },
	{ .text = "e", .arg_str = " search.in=?", .comment = "Show all possible values for config variable `search.in`" },
	{ .text = "e", .arg_str = " search.in=??", .comment = "Show all possible values for config variable `search.in` together with description" },
	{ .text = "e", .arg_str = " asm.bytes=true asm.offset=false", .comment = "Set asm.bytes to true and asm.offset to false" },
	{ 0 },
};
static const RzCmdDescDetail eval_getset_details[] = {
	{ .name = "Examples", .entries = eval_getset_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescArg eval_getset_args[] = {
	{
		.name = "key=value",
		.type = RZ_CMD_ARG_TYPE_EVAL_FULL,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_getset_help = {
	.summary = "Get/Set value of config variable <key>",
	.args_str = " <key>[=<val|?>] [<key>[=<val|?>] ...]]",
	.details = eval_getset_details,
	.args = eval_getset_args,
};

static const RzCmdDescArg eval_list_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_list_help = {
	.summary = "List config variables with their descriptions",
	.args = eval_list_args,
};

static const RzCmdDescArg eval_reset_args[] = {
	{ 0 },
};
static const RzCmdDescHelp eval_reset_help = {
	.summary = "Reset config variables",
	.args = eval_reset_args,
};

static const RzCmdDescArg eval_bool_invert_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_bool_invert_help = {
	.summary = "Invert the boolean value of config variable <key>",
	.args = eval_bool_invert_args,
};

static const RzCmdDescArg eval_color_args[] = {
	{ 0 },
};
static const RzCmdDescHelp eval_color_help = {
	.summary = "Set color for given key (prompt, offset, ...)",
	.args = eval_color_args,
};

static const RzCmdDescArg eval_editor_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_editor_help = {
	.summary = "Open editor to change the value of config variable <key>",
	.args = eval_editor_args,
};

static const RzCmdDescArg eval_readonly_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_readonly_help = {
	.summary = "Set config variable <key> as read-only",
	.args = eval_readonly_args,
};

static const RzCmdDescArg eval_spaces_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_spaces_help = {
	.summary = "List all config variable spaces or sub-keys/sub-spaces if a <key> is provided",
	.args = eval_spaces_args,
};

static const RzCmdDescArg eval_type_args[] = {
	{
		.name = "key",
		.type = RZ_CMD_ARG_TYPE_EVAL_KEY,

	},
	{ 0 },
};
static const RzCmdDescHelp eval_type_help = {
	.summary = "Show type of given config variable <key>",
	.args = eval_type_args,
};

static const RzCmdDescDetailEntry env_Examples_detail_entries[] = {
	{ .text = "%", .arg_str = NULL, .comment = "List all environment variables" },
	{ .text = "%", .arg_str = "SHELL", .comment = "Print value of SHELL variable" },
	{ .text = "%", .arg_str = "TMPDIR=/tmp", .comment = "Set TMPDIR to \"/tmp\"" },
	{ .text = "env", .arg_str = " SHELL", .comment = "Same as `%SHELL`" },
	{ 0 },
};

static const RzCmdDescDetailEntry env_Environment_detail_entries[] = {
	{ .text = "RZ_FILE", .arg_str = NULL, .comment = "currently opened file name" },
	{ .text = "RZ_OFFSET", .arg_str = NULL, .comment = "10base offset 64bit value" },
	{ .text = "RZ_BYTES", .arg_str = NULL, .comment = "TODO: variable with bytes in curblock" },
	{ .text = "RZ_XOFFSET", .arg_str = NULL, .comment = "same as above, but in 16 base" },
	{ .text = "RZ_BSIZE", .arg_str = NULL, .comment = "block size" },
	{ .text = "RZ_ENDIAN", .arg_str = NULL, .comment = "'big' or 'little'" },
	{ .text = "RZ_IOVA", .arg_str = NULL, .comment = "is io.va true? virtual addressing (1,0)" },
	{ .text = "RZ_DEBUG", .arg_str = NULL, .comment = "debug mode enabled? (1,0)" },
	{ .text = "RZ_BLOCK", .arg_str = NULL, .comment = "TODO: dump current block to tmp file" },
	{ .text = "RZ_SIZE", .arg_str = NULL, .comment = "file size" },
	{ .text = "RZ_ARCH", .arg_str = NULL, .comment = "value of asm.arch" },
	{ .text = "RZ_BITS", .arg_str = NULL, .comment = "arch reg size (8, 16, 32, 64)" },
	{ .text = "RZ_BIN_LANG", .arg_str = NULL, .comment = "assume this lang to demangle" },
	{ .text = "RZ_BIN_DEMANGLE", .arg_str = NULL, .comment = "demangle or not" },
	{ .text = "RZ_BIN_PDBSERVER", .arg_str = NULL, .comment = "e pdb.server" },
	{ 0 },
};
static const RzCmdDescDetail env_details[] = {
	{ .name = "Examples", .entries = env_Examples_detail_entries },
	{ .name = "Environment", .entries = env_Environment_detail_entries },
	{ 0 },
};
static const RzCmdDescArg env_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_ENV,
		.optional = true,

	},
	{
		.name = "varvalue",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp env_help = {
	.summary = "Get/set environment variables",
	.args_str = " [<varname>[=<varvalue>]]",
	.details = env_details,
	.args = env_args,
};

static const RzCmdDescHelp cmd_flag_help = {
	.summary = "Manage flags",
};

static const RzCmdDescHelp cmd_egg_help = {
	.summary = "Generate shellcodes with rz_egg",
};

static const RzCmdDescHelp cmd_info_help = {
	.summary = "Get info about opened binary file",
};

static const RzCmdDescHelp cmd_kuery_help = {
	.summary = "Run sdb-query",
};

static const RzCmdDescArg ls_args[] = {
	{
		.name = "arg",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp ls_help = {
	.summary = "List files and directories",
	.args = ls_args,
};

static const RzCmdDescHelp cmd_m_help = {
	.summary = "Make directories and move files",
};

static const RzCmdDescHelp cmd_plugins_help = {
	.summary = "List, unload, load rizin plugins",
};

static const RzCmdDescHelp cmd_open_help = {
	.summary = "Open file at optional address",
};

static const RzCmdDescHelp cmd_print_help = {
	.summary = "Print commands",
};

static const RzCmdDescHelp P_help = {
	.summary = "Project management",
};
static const RzCmdDescArg project_save_args[] = {
	{
		.name = "project.rzdb",
		.type = RZ_CMD_ARG_TYPE_FILE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp project_save_help = {
	.summary = "Save a project",
	.args = project_save_args,
};

static const RzCmdDescArg project_open_args[] = {
	{
		.name = "project.rzdb",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp project_open_help = {
	.summary = "Open a project",
	.args = project_open_args,
};

static const RzCmdDescArg project_open_no_bin_io_args[] = {
	{
		.name = "project.rzdb",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp project_open_no_bin_io_help = {
	.summary = "Open a project on top of currently loaded binaries",
	.args = project_open_no_bin_io_args,
};

static const RzCmdDescHelp cmd_quit_help = {
	.summary = "Quit program with a return value",
};

static const RzCmdDescHelp cmd_resize_help = {
	.summary = "Resize file",
};

static const RzCmdDescHelp s_help = {
	.summary = "Seek commands",
};
static const RzCmdDescArg seek_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_help = {
	.summary = "Print current address / Seek to address",
	.args = seek_args,
};

static const RzCmdDescArg seek_padded_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_padded_help = {
	.summary = "Print current address with <n> padded zeros (defaults to 8)",
	.args = seek_padded_args,
};

static const RzCmdDescArg seek_base_args[] = {
	{
		.name = "hex_offset",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_base_help = {
	.summary = "Seek honoring a base from core->offset",
	.args = seek_base_args,
};

static const RzCmdDescArg seek_delta_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_delta_help = {
	.summary = "Seek to a delta relative to current offset",
	.args = seek_delta_args,
};

static const RzCmdDescArg seek_blocksize_backward_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_blocksize_backward_help = {
	.summary = "Seek blocksize bytes backward (/=n)",
	.args = seek_blocksize_backward_args,
};

static const RzCmdDescArg seek_blocksize_forward_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_blocksize_forward_help = {
	.summary = "Seek blocksize bytes forward (/=n)",
	.args = seek_blocksize_forward_args,
};

static const RzCmdDescHelp sH_help = {
	.summary = "Seek history commands",
};
static const RzCmdDescArg seek_history_list_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_history_list_help = {
	.summary = "List undo seek history",
	.args = seek_history_list_args,
};

static const RzCmdDescArg seek_redo_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_redo_help = {
	.summary = "Go to position before the last undo (forward in history)",
	.args = seek_redo_args,
};

static const RzCmdDescArg seek_undo_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_undo_help = {
	.summary = "Go to last seek in seek history (back in history)",
	.args = seek_undo_args,
};

static const RzCmdDescArg seek_undo_reset_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_undo_reset_help = {
	.summary = "Clear seek history",
	.args = seek_undo_reset_args,
};

static const RzCmdDescHelp seek_search_help = {
	.summary = "Seek to the first hit of a search",
};

static const RzCmdDescArg seek_asz_args[] = {
	{
		.name = "align",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_asz_help = {
	.summary = "Seek to current offset (or <addr>) aligned to <align>",
	.args = seek_asz_args,
};

static const RzCmdDescArg seek_basicblock_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_basicblock_help = {
	.summary = "Seek aligned to bb start",
	.args = seek_basicblock_args,
};

static const RzCmdDescArg seek_function_args[] = {
	{
		.name = "fcn",
		.type = RZ_CMD_ARG_TYPE_FCN,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_function_help = {
	.summary = "Seek to next function / Seek to specific function",
	.args = seek_function_args,
};

static const RzCmdDescArg seek_function_current_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_function_current_help = {
	.summary = "Seek to the beginning of current function",
	.args = seek_function_current_args,
};

static const RzCmdDescArg seek_begin_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_begin_help = {
	.summary = "Seek to begin of section/file",
	.args = seek_begin_args,
};

static const RzCmdDescArg seek_end_args[] = {
	{ 0 },
};
static const RzCmdDescHelp seek_end_help = {
	.summary = "Seek to end of section/file",
	.args = seek_end_args,
};

static const char *seek_next_type_choices[] = { "opcodes", "function", "hit", "flags", NULL };
static const RzCmdDescArg seek_next_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_CHOICES,
		.optional = true,
		.choices = seek_next_type_choices,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_next_help = {
	.summary = "Seek to next location of the given <type> or scr.nkey otherwise",
	.description = "<type> and scr.nkey can be one of \"opcodes\", \"function\", \"hit\", \"flags\".",
	.args = seek_next_args,
};

static const char *seek_prev_type_choices[] = { "opcodes", "function", "hit", "flags", NULL };
static const RzCmdDescArg seek_prev_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_CHOICES,
		.optional = true,
		.choices = seek_prev_type_choices,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_prev_help = {
	.summary = "Seek to prev location",
	.description = "<type> and scr.nkey can be one of \"opcodes\", \"function\", \"hit\", \"flags\".",
	.args = seek_prev_args,
};

static const RzCmdDescArg seek_opcode_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_opcode_help = {
	.summary = "Seek to <n> next opcodes",
	.args = seek_opcode_args,
};

static const RzCmdDescArg seek_register_args[] = {
	{
		.name = "reg",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp seek_register_help = {
	.summary = "Seek to register",
	.args = seek_register_args,
};

static const RzCmdDescArg sleep_args[] = {
	{
		.name = "seconds",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp sleep_help = {
	.summary = "Sleep for the specified amount of seconds",
	.args = sleep_args,
};

static const RzCmdDescHelp cmd_type_help = {
	.summary = "Types, noreturn, signatures, C parser and more",
};

static const RzCmdDescArg uniq_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp uniq_help = {
	.summary = "List uniq strings in file",
	.args = uniq_args,
};

static const RzCmdDescArg uname_args[] = {
	{
		.name = "r",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_OPTION,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp uname_help = {
	.summary = "Provide system info",
	.args = uname_args,
};

static const RzCmdDescHelp cmd_visual_help = {
	.summary = "Enter visual mode",
};

static const RzCmdDescHelp cmd_panels_help = {
	.summary = "Enter visual panel mode",
};

static const RzCmdDescHelp w_help = {
	.summary = "Write commands",
};
static const RzCmdDescArg write_args[] = {
	{
		.name = "string",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp write_help = {
	.summary = "Write string",
	.args = write_args,
};

static const RzCmdDescDetailEntry wB_Examples_detail_entries[] = {
	{ .text = "wB", .arg_str = " 0x20", .comment = "Sets the 5th bit at current offset, leaving all other bits intact." },
	{ 0 },
};
static const RzCmdDescDetail wB_details[] = {
	{ .name = "Examples", .entries = wB_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp wB_help = {
	.summary = "Set or unset bits with given value",
	.details = wB_details,
};
static const RzCmdDescArg write_bits_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_bits_help = {
	.summary = "Set bits with given value",
	.description = "Set the bits that are set in the value passed as arguments. 0 bits in the value argument are ignored, while the others are set at the current offset.",
	.args = write_bits_args,
};

static const RzCmdDescArg write_unset_bits_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_unset_bits_help = {
	.summary = "Unset bits with given value",
	.description = "Unset the bits that are set in the value passed as arguments. 0 bits in the value argument are ignored, while the others are unset at the current offset",
	.args = write_unset_bits_args,
};

static const RzCmdDescDetailEntry wv_Examples_detail_entries[] = {
	{ .text = "wv", .arg_str = " 0xdeadbeef", .comment = "Write the value 0xdeadbeef at current offset" },
	{ .text = "wv2", .arg_str = " 0xdead", .comment = "Write the word 0xdead at current offset" },
	{ .text = "wv1", .arg_str = " 0xde", .comment = "Write the byte 0xde at current offset" },
	{ 0 },
};
static const RzCmdDescDetail wv_details[] = {
	{ .name = "Examples", .entries = wv_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp wv_help = {
	.summary = "Write value of given size",
	.details = wv_details,
};
static const RzCmdDescArg write_value_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_value_help = {
	.summary = "Write value as 4-bytes/8-bytes based on value",
	.description = "Write the number passed as argument at the current offset as a 4 - bytes value or 8 - bytes value if the input is bigger than UT32_MAX, respecting the cfg.bigendian variable",
	.args = write_value_args,
};

static const RzCmdDescArg write_value1_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_value1_help = {
	.summary = "Write value of 1 byte",
	.description = "Write the number passed as argument at the current offset as 1 - byte, respecting the cfg.bigendian variable",
	.args = write_value1_args,
};

static const RzCmdDescArg write_value2_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_value2_help = {
	.summary = "Write value of 2 byte",
	.description = "Write the number passed as argument at the current offset as 2 - bytes, respecting the cfg.bigendian variable",
	.args = write_value2_args,
};

static const RzCmdDescArg write_value4_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_value4_help = {
	.summary = "Write value of 4 byte",
	.description = "Write the number passed as argument at the current offset as 4 - bytes, respecting the cfg.bigendian variable",
	.args = write_value4_args,
};

static const RzCmdDescArg write_value8_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_value8_help = {
	.summary = "Write value of 8 byte",
	.description = "Write the number passed as argument at the current offset as 8 - bytes, respecting the cfg.bigendian variable",
	.args = write_value8_args,
};

static const RzCmdDescArg write_zero_args[] = {
	{
		.name = "len",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp write_zero_help = {
	.summary = "Write <len> bytes with value 0x00",
	.description = "Fill len bytes starting from the current offset with the value 0.",
	.args = write_zero_args,
};

static const RzCmdDescHelp write_incdec_help = {
	.summary = "increment/decrement byte, word, ..",
	.args_str = " [<n>]",
	.options = "<1248><+->",
};
static const RzCmdDescDetailEntry w1_Examples_detail_entries[] = {
	{ .text = "w1+", .arg_str = NULL, .comment = "Add 1 to the byte at the current offset." },
	{ .text = "w1-", .arg_str = NULL, .comment = "Subtract 1 to the byte at the current offset." },
	{ .text = "w1-", .arg_str = " 9", .comment = "Subtract 9 to the byte at the current offset." },
	{ 0 },
};
static const RzCmdDescDetail w1_details[] = {
	{ .name = "Examples", .entries = w1_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp w1_help = {
	.summary = "Increment/decrement a byte",
	.details = w1_details,
};
static const RzCmdDescArg write_1_inc_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_1_inc_help = {
	.summary = "Increment a byte",
	.description = "Increment a byte at the current offset by 1 or n, if specified",
	.args = write_1_inc_args,
};

static const RzCmdDescArg write_1_dec_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_1_dec_help = {
	.summary = "Decrement a byte",
	.description = "Decrement a byte at the current offset by 1 or n, if specified",
	.args = write_1_dec_args,
};

static const RzCmdDescDetailEntry w2_Examples_detail_entries[] = {
	{ .text = "w2+", .arg_str = NULL, .comment = "Add 1 to the word at the current offset." },
	{ .text = "w2-", .arg_str = NULL, .comment = "Subtract 1 to the word at the current offset." },
	{ .text = "w2-", .arg_str = " 9", .comment = "Subtract 9 to the word at the current offset." },
	{ 0 },
};
static const RzCmdDescDetail w2_details[] = {
	{ .name = "Examples", .entries = w2_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp w2_help = {
	.summary = "Increment/decrement a word",
	.details = w2_details,
};
static const RzCmdDescArg write_2_inc_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_2_inc_help = {
	.summary = "Increment a word",
	.description = "Increment a word at the current offset by 1 or n, if specified",
	.args = write_2_inc_args,
};

static const RzCmdDescArg write_2_dec_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_2_dec_help = {
	.summary = "Decrement a word",
	.description = "Decrement a word at the current offset by 1 or n, if specified",
	.args = write_2_dec_args,
};

static const RzCmdDescDetailEntry w4_Examples_detail_entries[] = {
	{ .text = "w4+", .arg_str = NULL, .comment = "Add 1 to the dword at the current offset." },
	{ .text = "w4-", .arg_str = NULL, .comment = "Subtract 1 to the dword at the current offset." },
	{ .text = "w4-", .arg_str = " 9", .comment = "Subtract 9 to the dword at the current offset." },
	{ 0 },
};
static const RzCmdDescDetail w4_details[] = {
	{ .name = "Examples", .entries = w4_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp w4_help = {
	.summary = "Increment/decrement a dword",
	.details = w4_details,
};
static const RzCmdDescArg write_4_inc_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_4_inc_help = {
	.summary = "Increment a dword",
	.description = "Increment a dword at the current offset by 1 or n, if specified",
	.args = write_4_inc_args,
};

static const RzCmdDescArg write_4_dec_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_4_dec_help = {
	.summary = "Decrement a dword",
	.description = "Decrement a dword at the current offset by 1 or n, if specified",
	.args = write_4_dec_args,
};

static const RzCmdDescDetailEntry w8_Examples_detail_entries[] = {
	{ .text = "w8+", .arg_str = NULL, .comment = "Add 1 to the qword at the current offset." },
	{ .text = "w8-", .arg_str = NULL, .comment = "Subtract 1 to the qword at the current offset." },
	{ .text = "w8-", .arg_str = " 9", .comment = "Subtract 9 to the qword at the current offset." },
	{ 0 },
};
static const RzCmdDescDetail w8_details[] = {
	{ .name = "Examples", .entries = w8_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp w8_help = {
	.summary = "Increment/decrement a qword",
	.details = w8_details,
};
static const RzCmdDescArg write_8_inc_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_8_inc_help = {
	.summary = "Increment a qword",
	.description = "Increment a qword at the current offset by 1 or n, if specified",
	.args = write_8_inc_args,
};

static const RzCmdDescArg write_8_dec_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp write_8_dec_help = {
	.summary = "Decrement a qword",
	.description = "Decrement a qword at the current offset by 1 or n, if specified",
	.args = write_8_dec_args,
};

static const RzCmdDescDetailEntry w6_Examples_detail_entries[] = {
	{ .text = "w6d", .arg_str = " SGVsbG9Xb3JsZAo=", .comment = "Write the string \"HelloWorld\" (without quotes) at current offset." },
	{ .text = "w6e", .arg_str = " 48656c6c6f576f726c64", .comment = "Write the string \"SGVsbG9Xb3JsZAo=\" (without quotes) at current offset." },
	{ 0 },
};
static const RzCmdDescDetail w6_details[] = {
	{ .name = "Examples", .entries = w6_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp w6_help = {
	.summary = "Write base64 [d]ecoded or [e]ncoded string",
	.details = w6_details,
};
static const RzCmdDescArg write_base64_decode_args[] = {
	{
		.name = "base64",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp write_base64_decode_help = {
	.summary = "Write the base64-decoded bytes",
	.description = "Base64-Decode the string passed as argument and write it at the current offset.",
	.args = write_base64_decode_args,
};

static const RzCmdDescArg write_base64_encode_args[] = {
	{
		.name = "hexstring",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp write_base64_encode_help = {
	.summary = "Write the base64-encoded bytes",
	.description = "Base64-Encode the hex string passed as argument and write it at the current offset",
	.args = write_base64_encode_args,
};

static const RzCmdDescHelp wh_handler_old_help = {
	.summary = "whereis/which shell command",
};

static const RzCmdDescHelp we_handler_old_help = {
	.summary = "Extend write operations (insert bytes instead of replacing)",
};

static const RzCmdDescHelp wu_handler_old_help = {
	.summary = "Apply unified hex patch (see output of cu)",
};

static const RzCmdDescHelp wr_handler_old_help = {
	.summary = "Write <num> random bytes",
};

static const RzCmdDescHelp wA_handler_old_help = {
	.summary = "Alter/modify opcode at current seek (see wA?)",
};

static const RzCmdDescHelp wc_handler_old_help = {
	.summary = "Write cache commands",
};

static const RzCmdDescHelp wz_handler_old_help = {
	.summary = "Write zero-terminated string",
};

static const RzCmdDescHelp wt_handler_old_help = {
	.summary = "Write to file",
};

static const RzCmdDescHelp wf_handler_old_help = {
	.summary = "Write data from file, socket, offset",
};

static const RzCmdDescHelp ww_handler_old_help = {
	.summary = "Write wide string",
};

static const RzCmdDescHelp wx_handler_old_help = {
	.summary = "Write hexadecimal",
};

static const RzCmdDescHelp wa_handler_old_help = {
	.summary = "Write opcode, separated by ';'",
};

static const RzCmdDescHelp wb_handler_old_help = {
	.summary = "Write in current block with cyclic hexstring",
};

static const RzCmdDescHelp wm_handler_old_help = {
	.summary = "Set binary mask hexpair to be used as cyclic write mask",
};

static const RzCmdDescHelp wo_handler_old_help = {
	.summary = "Write in block with operation",
};

static const RzCmdDescHelp wd_handler_old_help = {
	.summary = "Duplicate N bytes from offset at current seek",
};

static const RzCmdDescHelp ws_handler_old_help = {
	.summary = "Write 1 byte for length and then the string",
};

static const RzCmdDescHelp cmd_hexdump_help = {
	.summary = "Alias for 'px' (print hexadecimal)",
};

static const RzCmdDescHelp cmd_yank_help = {
	.summary = "Yank/paste bytes from/to memory",
};

static const RzCmdDescHelp z_help = {
	.summary = "Zignatures management",
};
static const RzCmdDescArg zign_show_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_show_help = {
	.summary = "Show zignatures",
	.args = zign_show_args,
};

static const RzCmdDescArg zign_find_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_find_help = {
	.summary = "Find matching zignatures",
	.args = zign_find_args,
};

static const RzCmdDescHelp zb_help = {
	.summary = "Search for best match",
};
static const RzCmdDescArg zign_best_args[] = {
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_best_help = {
	.summary = "Find <n> closest matching zignatures to function at current offset",
	.args = zign_best_args,
};

static const RzCmdDescArg zign_best_name_args[] = {
	{
		.name = "zigname",
		.type = RZ_CMD_ARG_TYPE_ZIGN,

	},
	{
		.name = "n",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_best_name_help = {
	.summary = "Search for <n> most similar functions to zigname",
	.args = zign_best_name_args,
};

static const RzCmdDescArg zign_delete_args[] = {
	{
		.name = "zigname|*",
		.type = RZ_CMD_ARG_TYPE_ZIGN,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_delete_help = {
	.summary = "Delete zignature",
	.args = zign_delete_args,
};

static const RzCmdDescHelp za_help = {
	.summary = "Add zignature",
};
static const RzCmdDescDetailEntry zign_add_Zignature_space_types_detail_entries[] = {
	{ .text = "a", .arg_str = NULL, .comment = "bytes pattern (analysis mask)" },
	{ .text = "b", .arg_str = NULL, .comment = "bytes pattern" },
	{ .text = "c", .arg_str = NULL, .comment = "base64 comment" },
	{ .text = "n", .arg_str = NULL, .comment = "real function name" },
	{ .text = "g", .arg_str = NULL, .comment = "graph metrics" },
	{ .text = "o", .arg_str = NULL, .comment = "original offset" },
	{ .text = "r", .arg_str = NULL, .comment = "references" },
	{ .text = "x", .arg_str = NULL, .comment = "cross references" },
	{ .text = "h", .arg_str = NULL, .comment = "bbhash (hashing of function basic blocks)" },
	{ .text = "v", .arg_str = NULL, .comment = "vars (and args)" },
	{ 0 },
};

static const RzCmdDescDetailEntry zign_add_Bytes_space_patterns_detail_entries[] = {
	{ .text = "", .arg_str = NULL, .comment = "bytes can contain '..' (dots) to specify a binary mask" },
	{ 0 },
};

static const RzCmdDescDetailEntry zign_add_Graph_space_metrics_detail_entries[] = {
	{ .text = "cc", .arg_str = NULL, .comment = "cyclomatic complexity" },
	{ .text = "edges", .arg_str = NULL, .comment = "number of edges" },
	{ .text = "nbbs", .arg_str = NULL, .comment = "number of basic blocks" },
	{ .text = "ebbs", .arg_str = NULL, .comment = "number of end basic blocks" },
	{ 0 },
};

static const RzCmdDescDetailEntry zign_add_Examples_detail_entries[] = {
	{ .text = "za", .arg_str = " foo b 558bec..e8........", .comment = "" },
	{ .text = "za", .arg_str = " foo a e811223344", .comment = "" },
	{ .text = "za", .arg_str = " foo g cc=2 nbbs=3 edges=3 ebbs=1", .comment = "" },
	{ .text = "za", .arg_str = " foo g nbbs=3 edges=3", .comment = "" },
	{ .text = "za", .arg_str = " foo v b-32 b-48 b-64", .comment = "" },
	{ .text = "za", .arg_str = " foo o 0x08048123", .comment = "" },
	{ .text = "za", .arg_str = " foo c this is a comment (base64?)", .comment = "" },
	{ .text = "za", .arg_str = " foo r sym.imp.strcpy sym.imp.sprintf sym.imp.strlen", .comment = "" },
	{ .text = "za", .arg_str = " foo h 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", .comment = "" },
	{ 0 },
};
static const RzCmdDescDetail zign_add_details[] = {
	{ .name = "Zignature types", .entries = zign_add_Zignature_space_types_detail_entries },
	{ .name = "Bytes patterns", .entries = zign_add_Bytes_space_patterns_detail_entries },
	{ .name = "Graph metrics", .entries = zign_add_Graph_space_metrics_detail_entries },
	{ .name = "Examples", .entries = zign_add_Examples_detail_entries },
	{ 0 },
};
static const char *zign_add_type_choices[] = { "a", "b", "c", "n", "g", "o", "r", "x", "h", "v", NULL };
static const RzCmdDescArg zign_add_args[] = {
	{
		.name = "zigname",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_CHOICES,
		.choices = zign_add_type_choices,

	},
	{
		.name = "param",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_add_help = {
	.summary = "Add zignature",
	.details = zign_add_details,
	.args = zign_add_args,
};

static const RzCmdDescArg zign_add_fcn_args[] = {
	{
		.name = "fcnname",
		.type = RZ_CMD_ARG_TYPE_FCN,
		.optional = true,

	},
	{
		.name = "zigname",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_add_fcn_help = {
	.summary = "Create zignature for function",
	.args = zign_add_fcn_args,
};

static const RzCmdDescArg zign_add_all_fcns_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_add_all_fcns_help = {
	.summary = "Generate zignatures for all functions",
	.args = zign_add_all_fcns_args,
};

static const RzCmdDescArg zign_generate_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_generate_help = {
	.summary = "Generate zignatures (alias for zaF)",
	.args = zign_generate_args,
};

static const RzCmdDescHelp zo_help = {
	.summary = "Manage zignature files",
};
static const RzCmdDescArg zign_load_sdb_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_load_sdb_help = {
	.summary = "Load zinatures from sdb file",
	.args = zign_load_sdb_args,
};

static const RzCmdDescArg zign_save_sdb_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_save_sdb_help = {
	.summary = "Save zinatures to sdb file",
	.args = zign_save_sdb_args,
};

static const RzCmdDescArg zign_load_gzip_sdb_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_load_gzip_sdb_help = {
	.summary = "Load zinatures from gzipped sdb file",
	.args = zign_load_gzip_sdb_args,
};

static const RzCmdDescHelp zf_help = {
	.summary = "Manage FLIRT signatures",
};
static const RzCmdDescArg zign_flirt_dump_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_flirt_dump_help = {
	.summary = "Open FLIRT file and dump",
	.args = zign_flirt_dump_args,
};

static const RzCmdDescArg zign_flirt_scan_args[] = {
	{
		.name = "filename",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_flirt_scan_help = {
	.summary = "Open FLIRT file and scan",
	.args = zign_flirt_scan_args,
};

static const RzCmdDescHelp z_slash__help = {
	.summary = "Search zignatures",
};
static const RzCmdDescArg zign_search_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_search_help = {
	.summary = "Search zignatures on range and flag matches",
	.args = zign_search_args,
};

static const RzCmdDescArg zign_search_fcn_args[] = {
	{ 0 },
};
static const RzCmdDescHelp zign_search_fcn_help = {
	.summary = "Search only function zignatures",
	.args = zign_search_fcn_args,
};

static const RzCmdDescHelp zc_help = {
	.summary = "Compare zignatures in current zignspace with another one",
};
static const RzCmdDescArg zign_cmp_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_cmp_help = {
	.summary = "Compare all zignatures in current space with <zignspace>",
	.args = zign_cmp_args,
};

static const RzCmdDescHelp zcn_help = {
	.summary = "Compare current zignspace with zigns on other <zignspace>",
};
static const RzCmdDescArg zign_cmp_name_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_cmp_name_help = {
	.summary = "Compare current zignspace with zigns with same name on other <zignspace>",
	.args = zign_cmp_name_args,
};

static const RzCmdDescArg zign_cmp_diff_name_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_cmp_diff_name_help = {
	.summary = "Compare current zignspace with zigns with different name on other <zignspace>",
	.args = zign_cmp_diff_name_args,
};

static const RzCmdDescHelp zs_help = {
	.summary = "Manage zignspaces",
};
static const RzCmdDescArg zign_space_select_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_space_select_help = {
	.summary = "Display/select zignspaces",
	.args = zign_space_select_args,
};

static const RzCmdDescArg zign_space_delete_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_space_delete_help = {
	.summary = "Pop last zignspace or delete <zignspace>",
	.args = zign_space_delete_args,
};

static const RzCmdDescArg zign_space_add_args[] = {
	{
		.name = "zignspace",
		.type = RZ_CMD_ARG_TYPE_ZIGN_SPACE,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_space_add_help = {
	.summary = "Push previous zignspace and set",
	.args = zign_space_add_args,
};

static const RzCmdDescArg zign_space_rename_args[] = {
	{
		.name = "newname",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_space_rename_help = {
	.summary = "Rename selected zignspace",
	.args = zign_space_rename_args,
};

static const RzCmdDescHelp zi_help = {
	.summary = "Show zignatures matching information",
};
static const RzCmdDescArg zign_info_args[] = {
	{
		.name = "commens",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_info_help = {
	.summary = "Show zignatures matching information",
	.args = zign_info_args,
};

static const RzCmdDescArg zign_info_range_args[] = {
	{
		.name = "from",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{
		.name = "to",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp zign_info_range_help = {
	.summary = "Show zignatures matching information in range",
	.args = zign_info_range_args,
};

static const RzCmdDescDetailEntry tmp_modifiers_empty_detail_entries[] = {
	{ .text = "<cmd> @", .arg_str = " <addr>", .comment = "Temporary seek to <addr>" },
	{ .text = "<cmd> @", .arg_str = " <addr>!<blocksize>", .comment = "Temporary seek to <addr> and set blocksize to <blocksize>" },
	{ .text = "<cmd> @..", .arg_str = "<addr>", .comment = "Temporary partial address seek (see s..)" },
	{ .text = "<cmd> @!", .arg_str = "<blocksize>", .comment = "Temporary change the block size" },
	{ .text = "<cmd> @{", .arg_str = "<from> <to>}", .comment = "Temporary set from and to for commands supporting ranges" },
	{ .text = "<cmd> @a:", .arg_str = "<arch>[:<bits>]", .comment = "Temporary set arch and bits, if specified" },
	{ .text = "<cmd> @b:", .arg_str = "<bits>", .comment = "Temporary set asm.bits" },
	{ .text = "<cmd> @B:", .arg_str = "<nth>", .comment = "Temporary seek to nth instruction in current basic block (negative numbers too)" },
	{ .text = "<cmd> @e:", .arg_str = "<k>=<v>[<k>=<v>]", .comment = "Temporary change eval vars (multiple vars separated by comma)" },
	{ .text = "<cmd> @f:", .arg_str = "<file>", .comment = "Temporary replace block with file contents" },
	{ .text = "<cmd> @F:", .arg_str = "<flagspace>", .comment = "Temporary change flag space" },
	{ .text = "<cmd> @i:", .arg_str = "<nth.op>", .comment = "Temporary seek to the Nth relative instruction" },
	{ .text = "<cmd> @k:", .arg_str = "<key>", .comment = "Temporary seek at value of sdb key `key`" },
	{ .text = "<cmd> @o:", .arg_str = "<fd>", .comment = "Temporary switch to another fd" },
	{ .text = "<cmd> @r:", .arg_str = "<reg>", .comment = "Temporary seek to register value" },
	{ .text = "<cmd> @s:", .arg_str = "<string>", .comment = "Temporary replace block with string" },
	{ .text = "<cmd> @v:", .arg_str = "<value>", .comment = "Temporary replace block with value, written according to asm.bits and cfg.bigendian" },
	{ .text = "<cmd> @x:", .arg_str = "<hexstring>", .comment = "Temporary replace block with hexstring" },
	{ 0 },
};
static const RzCmdDescDetail tmp_modifiers_details[] = {
	{ .name = "", .entries = tmp_modifiers_empty_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp tmp_modifiers_help = {
	.summary = "'@' help, temporary modifiers",
	.usage = "<cmd> <@> <args>",
	.options = "[?]",
	.details = tmp_modifiers_details,
};

static const RzCmdDescDetailEntry iterators_empty_detail_entries[] = {
	{ .text = "<cmd> @@.", .arg_str = " <file>", .comment = "Run <cmd> over the offsets specified in <file>, one per line" },
	{ .text = "<cmd> @@=", .arg_str = "<addr1> [<addr2> ...]", .comment = "Run <cmd> over the listed addresses" },
	{ .text = "<cmd> @@@=", .arg_str = "<addr1> <blksz1> [<addr2> <blksz2> ...]", .comment = "Run <cmd> over the listed addresses and set the proper block size" },
	{ .text = "<cmd> @@/", .arg_str = "<search-cmd>", .comment = "Run <cmd> over the search results of /<search-cmd>" },
	{ .text = "<cmd> @@c:", .arg_str = "<cmd2>", .comment = "Run <cmd> on all addresses in the output of <cmd2>" },
	{ .text = "<cmd> @@@c:", .arg_str = "<cmd2>", .comment = "Run <cmd> on all addresses/blocksizes in the output of <cmd2>, similar to @@@=" },
	{ .text = "<cmd> @@C", .arg_str = "[:<glob>]", .comment = "Run <cmd> over all comments matching <glob>. <glob> may contain `*` to indicate multiple chars. If not specified all comments are considered." },
	{ .text = "<cmd> @@dbt[abs]", .arg_str = "", .comment = "Run <cmd> on every backtrace address, bp or sp" },
	{ .text = "<cmd> @@t", .arg_str = "", .comment = "Run <cmd> over all threads" },
	{ .text = "<cmd> @@b", .arg_str = "", .comment = "Run <cmd> over all basic blocks of the current function" },
	{ .text = "<cmd> @@i", .arg_str = "", .comment = "Run <cmd> over all instructions of the current basic block" },
	{ .text = "<cmd> @@iS", .arg_str = "", .comment = "Run <cmd> over all sections" },
	{ .text = "<cmd> @@iSS", .arg_str = "", .comment = "Run <cmd> over all segments" },
	{ .text = "<cmd> @@is", .arg_str = "", .comment = "Run <cmd> over all symbols" },
	{ .text = "<cmd> @@iz", .arg_str = "", .comment = "Run <cmd> over all strings" },
	{ .text = "<cmd> @@f", .arg_str = "[:<glob>]", .comment = "Run <cmd> over all flags matching <glob>. <glob> may contain `*` to indicate multiple chars. If not specified all flags are considered." },
	{ .text = "<cmd> @@F", .arg_str = "[:<glob>]", .comment = "Run <cmd> over all functions matching <glob>. <glob> may contain `*` to indicate multiple chars. If not specified all functions are considered." },
	{ .text = "<cmd> @@om", .arg_str = "", .comment = "Run <cmd> over all iomap (see `om`)" },
	{ .text = "<cmd> @@dm", .arg_str = "", .comment = "Run <cmd> over all debug maps (see `dm`)" },
	{ .text = "<cmd> @@r", .arg_str = "", .comment = "Run <cmd> over all registers" },
	{ .text = "<cmd> @@s:", .arg_str = "<from> <to> <step>", .comment = "Run <cmd> on all addresses starting from <from> and going up to <to> (excluded), with a step <step>." },
	{ 0 },
};
static const RzCmdDescDetail iterators_details[] = {
	{ .name = "", .entries = iterators_empty_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp iterators_help = {
	.summary = "'@@' help, iterators",
	.usage = "<cmd> <@@> <args>",
	.options = "[?]",
	.details = iterators_details,
};

static const RzCmdDescDetailEntry redirection_empty_detail_entries[] = {
	{ .text = "<cmd> >", .arg_str = " <file>|<$alias>", .comment = "Redirect STDOUT of <cmd> to <file> or save it to an alias (see $?)" },
	{ .text = "<cmd> 2>", .arg_str = " <file>|<$alias>", .comment = "Redirect STDERR of <cmd> to <file> or save it to an alias (see $?)" },
	{ .text = "<cmd> H>", .arg_str = " <file>|<$alias>", .comment = "Redirect HTML output of <cmd> to <file> or save it to an alias (see $?)" },
	{ 0 },
};
static const RzCmdDescDetail redirection_details[] = {
	{ .name = "", .entries = redirection_empty_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp redirection_help = {
	.summary = "Redirection help ('>')",
	.usage = "<cmd> > <arg>",
	.options = "[?]",
	.details = redirection_details,
};

static const RzCmdDescDetailEntry pipe_empty_detail_entries[] = {
	{ .text = "<cmd> |", .arg_str = NULL, .comment = "Disable scr.html and scr.color" },
	{ .text = "<cmd> |H", .arg_str = NULL, .comment = "Enable scr.html, respect scr.color" },
	{ .text = "<cmd> |", .arg_str = " <program>", .comment = "Pipe output of command to program" },
	{ .text = "<cmd> |.", .arg_str = NULL, .comment = "Alias for .<cmd>" },
	{ 0 },
};
static const RzCmdDescDetail pipe_details[] = {
	{ .name = "", .entries = pipe_empty_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp pipe_help = {
	.summary = "Pipe help ('|')",
	.usage = "<cmd> |[<program>|H|T|.|]",
	.options = "[?]",
	.details = pipe_details,
};

static const RzCmdDescDetailEntry grep_Modifiers_detail_entries[] = {
	{ .text = "&", .arg_str = NULL, .comment = "All words must match to grep the line" },
	{ .text = "$[n]", .arg_str = NULL, .comment = "Sort numerically / alphabetically the Nth column" },
	{ .text = "$!", .arg_str = NULL, .comment = "Sort in inverse order" },
	{ .text = ",", .arg_str = NULL, .comment = "Token to define another keyword" },
	{ .text = "+", .arg_str = NULL, .comment = "Case insensitive grep (grep -i)" },
	{ .text = "^", .arg_str = NULL, .comment = "Words must be placed at the beginning of line" },
	{ .text = "<", .arg_str = NULL, .comment = "Perform zoom operation on the buffer" },
	{ .text = "!", .arg_str = NULL, .comment = "Negate grep" },
	{ .text = "?", .arg_str = NULL, .comment = "Count number of matching lines" },
	{ .text = "?.", .arg_str = NULL, .comment = "Count number chars" },
	{ .text = ":s..e", .arg_str = NULL, .comment = "Show lines s-e" },
	{ .text = "..", .arg_str = NULL, .comment = "Internal 'less'" },
	{ .text = "...", .arg_str = NULL, .comment = "Internal 'hud' (like V_)" },
	{ .text = "{:", .arg_str = NULL, .comment = "Human friendly indentation (yes, it's a smiley)" },
	{ .text = "{:..", .arg_str = NULL, .comment = "Less the output of {:" },
	{ .text = "{:...", .arg_str = NULL, .comment = "Hud the output of {:" },
	{ .text = "{}", .arg_str = NULL, .comment = "Json indentation" },
	{ .text = "{}..", .arg_str = NULL, .comment = "Less json indentation" },
	{ .text = "{}...", .arg_str = NULL, .comment = "Hud json indentation" },
	{ .text = "{path}", .arg_str = NULL, .comment = "Json path grep" },
	{ 0 },
};

static const RzCmdDescDetailEntry grep_EndModifiers_detail_entries[] = {
	{ .text = "$", .arg_str = NULL, .comment = "Words must be placed at the end of line" },
	{ 0 },
};

static const RzCmdDescDetailEntry grep_Columns_detail_entries[] = {
	{ .text = "[n]", .arg_str = NULL, .comment = "Show only columns n" },
	{ .text = "[n-m]", .arg_str = NULL, .comment = "Show column n to m" },
	{ .text = "[n-]", .arg_str = NULL, .comment = "Show all columns starting from column n" },
	{ .text = "[i,j,k]", .arg_str = NULL, .comment = "Show the columns i, j and k" },
	{ 0 },
};

static const RzCmdDescDetailEntry grep_Examples_detail_entries[] = {
	{ .text = "i", .arg_str = "~:0", .comment = "Show first line of 'i' output" },
	{ .text = "i", .arg_str = "~:-2", .comment = "Show from the second to the last line of 'i' output" },
	{ .text = "i", .arg_str = "~:0..3", .comment = "Show first three lines of 'i' output" },
	{ .text = "pd", .arg_str = "~mov", .comment = "Disasm and grep for mov" },
	{ .text = "pi", .arg_str = "~[0]", .comment = "Show only opcode" },
	{ .text = "i", .arg_str = "~0x400$", .comment = "Show lines ending with 0x400" },
	{ 0 },
};
static const RzCmdDescDetail grep_details[] = {
	{ .name = "Modifiers", .entries = grep_Modifiers_detail_entries },
	{ .name = "EndModifiers", .entries = grep_EndModifiers_detail_entries },
	{ .name = "Columns", .entries = grep_Columns_detail_entries },
	{ .name = "Examples", .entries = grep_Examples_detail_entries },
	{ 0 },
};
static const RzCmdDescHelp grep_help = {
	.summary = "Internal grep help ('~')",
	.usage = "<command>~[modifier][word,word][endmodifier][[column]][:line]",
	.options = "[?]",
	.details = grep_details,
};

RZ_IPI void newshell_cmddescs_init(RzCore *core) {
	RzCmdDesc *root_cd = rz_cmd_get_root(core->rcmd);

	RzCmdDesc *cmd_system_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "!", rz_cmd_system, &cmd_system_help);
	rz_warn_if_fail(cmd_system_cd);

	RzCmdDesc *last_output_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "_", rz_last_output_handler, &last_output_help);
	rz_warn_if_fail(last_output_cd);

	RzCmdDesc *hash_bang_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "#!", rz_hash_bang_handler, &hash_bang_help);
	rz_warn_if_fail(hash_bang_cd);

	RzCmdDesc *cmd_alias_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "$", rz_cmd_alias, &cmd_alias_help);
	rz_warn_if_fail(cmd_alias_cd);

	RzCmdDesc *env_percentage_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "%", rz_env_handler, &env_percentage_help);
	rz_warn_if_fail(env_percentage_cd);

	RzCmdDesc *and__cd = rz_cmd_desc_group_modes_new(core->rcmd, root_cd, "&", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_tasks_handler, &tasks_help, &and__help);
	rz_warn_if_fail(and__cd);
	RzCmdDesc *tasks_transient_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&t", rz_tasks_transient_handler, &tasks_transient_help);
	rz_warn_if_fail(tasks_transient_cd);

	RzCmdDesc *tasks_output_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&=", rz_tasks_output_handler, &tasks_output_help);
	rz_warn_if_fail(tasks_output_cd);

	RzCmdDesc *tasks_break_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&b", rz_tasks_break_handler, &tasks_break_help);
	rz_warn_if_fail(tasks_break_cd);

	RzCmdDesc *tasks_delete_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&-", rz_tasks_delete_handler, &tasks_delete_help);
	rz_warn_if_fail(tasks_delete_cd);

	RzCmdDesc *tasks_delete_all_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&-*", rz_tasks_delete_all_handler, &tasks_delete_all_help);
	rz_warn_if_fail(tasks_delete_all_cd);

	RzCmdDesc *tasks_wait_cd = rz_cmd_desc_argv_new(core->rcmd, and__cd, "&&", rz_tasks_wait_handler, &tasks_wait_help);
	rz_warn_if_fail(tasks_wait_cd);

	RzCmdDesc *cmd_macro_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "(", rz_cmd_macro, &cmd_macro_help);
	rz_warn_if_fail(cmd_macro_cd);

	RzCmdDesc *pointer_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "*", rz_pointer_handler, &pointer_help);
	rz_warn_if_fail(pointer_cd);

	RzCmdDesc *cmd_stdin_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "-", rz_cmd_stdin, &cmd_stdin_help);
	rz_warn_if_fail(cmd_stdin_cd);

	RzCmdDesc *dot__cd = rz_cmd_desc_group_new(core->rcmd, root_cd, ".", rz_interpret_handler, &interpret_help, &dot__help);
	rz_warn_if_fail(dot__cd);
	RzCmdDesc *interpret_script_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, ". ", rz_interpret_script_handler, &interpret_script_help);
	rz_warn_if_fail(interpret_script_cd);

	RzCmdDesc *repeat_forward_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, "...", rz_repeat_forward_handler, &repeat_forward_help);
	rz_warn_if_fail(repeat_forward_cd);

	RzCmdDesc *interpret_output_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, "..", rz_interpret_output_handler, &interpret_output_help);
	rz_warn_if_fail(interpret_output_cd);

	RzCmdDesc *interpret_editor_2_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, ".-", rz_interpret_editor_2_handler, &interpret_editor_2_help);
	rz_warn_if_fail(interpret_editor_2_cd);

	RzCmdDesc *interpret_pipe_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, ".*", rz_interpret_pipe_handler, &interpret_pipe_help);
	rz_warn_if_fail(interpret_pipe_cd);

	RzCmdDesc *interpret_system_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, ".!", rz_interpret_system_handler, &interpret_system_help);
	rz_warn_if_fail(interpret_system_cd);

	RzCmdDesc *interpret_macro_cd = rz_cmd_desc_argv_new(core->rcmd, dot__cd, ".(", rz_interpret_macro_handler, &interpret_macro_help);
	rz_warn_if_fail(interpret_macro_cd);

	RzCmdDesc *cmd_search_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "/", rz_cmd_search, &cmd_search_help);
	rz_warn_if_fail(cmd_search_cd);

	RzCmdDesc *equal__cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "=", rz_remote_handler, &remote_help, &equal__help);
	rz_warn_if_fail(equal__cd);
	RzCmdDesc *remote_send_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=<", rz_remote_send_handler, &remote_send_help);
	rz_warn_if_fail(remote_send_cd);

	RzCmdDesc *io_system_run_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=!", rz_io_system_run_handler, &io_system_run_help);
	rz_warn_if_fail(io_system_run_cd);

	RzCmdDesc *remote_add_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=+", rz_remote_add_handler, &remote_add_help);
	rz_warn_if_fail(remote_add_cd);

	RzCmdDesc *remote_del_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=-", rz_remote_del_handler, &remote_del_help);
	rz_warn_if_fail(remote_del_cd);

	RzCmdDesc *remote_open_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "==", rz_remote_open_handler, &remote_open_help);
	rz_warn_if_fail(remote_open_cd);

	RzCmdDesc *remote_mode_enable_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=!=", rz_remote_mode_enable_handler, &remote_mode_enable_help);
	rz_warn_if_fail(remote_mode_enable_cd);

	RzCmdDesc *remote_mode_disable_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "!=!", rz_remote_mode_disable_handler, &remote_mode_disable_help);
	rz_warn_if_fail(remote_mode_disable_cd);

	RzCmdDesc *remote_rap_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=:", rz_remote_rap_handler, &remote_rap_help);
	rz_warn_if_fail(remote_rap_cd);

	RzCmdDesc *equal_g_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, equal__cd, "=g", rz_equal_g_handler_old, &equal_g_handler_old_help);
	rz_warn_if_fail(equal_g_handler_old_cd);

	RzCmdDesc *equal_h_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, equal__cd, "=h", rz_equal_h_handler_old, &equal_h_handler_old_help);
	rz_warn_if_fail(equal_h_handler_old_cd);

	RzCmdDesc *equal_H_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, equal__cd, "=H", rz_equal_H_handler_old, &equal_H_handler_old_help);
	rz_warn_if_fail(equal_H_handler_old_cd);

	RzCmdDesc *remote_tcp_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=t", rz_remote_tcp_handler, &remote_tcp_help);
	rz_warn_if_fail(remote_tcp_cd);

	RzCmdDesc *remote_rap_bg_cd = rz_cmd_desc_argv_new(core->rcmd, equal__cd, "=&:", rz_remote_rap_bg_handler, &remote_rap_bg_help);
	rz_warn_if_fail(remote_rap_bg_cd);

	RzCmdDesc *cmd_help_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "?", rz_cmd_help, &cmd_help_help);
	rz_warn_if_fail(cmd_help_cd);

	RzCmdDesc *push_escaped_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "<", rz_push_escaped_handler, &push_escaped_help);
	rz_warn_if_fail(push_escaped_cd);

	RzCmdDesc *cmd_ox_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "0", rz_cmd_ox, &cmd_ox_help);
	rz_warn_if_fail(cmd_ox_cd);

	RzCmdDesc *cmd_analysis_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "a", rz_cmd_analysis, &cmd_analysis_help);
	rz_warn_if_fail(cmd_analysis_cd);

	RzCmdDesc *cmd_bsize_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "b", rz_cmd_bsize, &cmd_bsize_help);
	rz_warn_if_fail(cmd_bsize_cd);

	RzCmdDesc *cmd_cmp_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "c", rz_cmd_cmp, &cmd_cmp_help);
	rz_warn_if_fail(cmd_cmp_cd);

	RzCmdDesc *cmd_meta_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "C", rz_cmd_meta, &cmd_meta_help);
	rz_warn_if_fail(cmd_meta_cd);

	RzCmdDesc *cmd_debug_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "d", rz_cmd_debug, &cmd_debug_help);
	rz_warn_if_fail(cmd_debug_cd);

	RzCmdDesc *e_cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "e", rz_eval_getset_handler, &eval_getset_help, &e_help);
	rz_warn_if_fail(e_cd);
	RzCmdDesc *eval_list_cd = rz_cmd_desc_argv_modes_new(core->rcmd, e_cd, "el", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET | RZ_OUTPUT_MODE_LONG | RZ_OUTPUT_MODE_LONG_JSON, rz_eval_list_handler, &eval_list_help);
	rz_warn_if_fail(eval_list_cd);

	RzCmdDesc *eval_reset_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "e-", rz_eval_reset_handler, &eval_reset_help);
	rz_warn_if_fail(eval_reset_cd);

	RzCmdDesc *eval_bool_invert_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "e!", rz_eval_bool_invert_handler, &eval_bool_invert_help);
	rz_warn_if_fail(eval_bool_invert_cd);

	RzCmdDesc *eval_color_cd = rz_cmd_desc_oldinput_new(core->rcmd, e_cd, "ec", rz_eval_color, &eval_color_help);
	rz_warn_if_fail(eval_color_cd);

	RzCmdDesc *eval_editor_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "ee", rz_eval_editor_handler, &eval_editor_help);
	rz_warn_if_fail(eval_editor_cd);

	RzCmdDesc *eval_readonly_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "er", rz_eval_readonly_handler, &eval_readonly_help);
	rz_warn_if_fail(eval_readonly_cd);

	RzCmdDesc *eval_spaces_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "es", rz_eval_spaces_handler, &eval_spaces_help);
	rz_warn_if_fail(eval_spaces_cd);

	RzCmdDesc *eval_type_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "et", rz_eval_type_handler, &eval_type_help);
	rz_warn_if_fail(eval_type_cd);

	RzCmdDesc *env_cd = rz_cmd_desc_argv_new(core->rcmd, e_cd, "env", rz_env_handler, &env_help);
	rz_warn_if_fail(env_cd);

	RzCmdDesc *cmd_flag_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "f", rz_cmd_flag, &cmd_flag_help);
	rz_warn_if_fail(cmd_flag_cd);

	RzCmdDesc *cmd_egg_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "g", rz_cmd_egg, &cmd_egg_help);
	rz_warn_if_fail(cmd_egg_cd);

	RzCmdDesc *cmd_info_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "i", rz_cmd_info, &cmd_info_help);
	rz_warn_if_fail(cmd_info_cd);

	RzCmdDesc *cmd_kuery_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "k", rz_cmd_kuery, &cmd_kuery_help);
	rz_warn_if_fail(cmd_kuery_cd);

	RzCmdDesc *ls_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "ls", rz_ls_handler, &ls_help);
	rz_warn_if_fail(ls_cd);

	RzCmdDesc *cmd_m_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "m", rz_cmd_m, &cmd_m_help);
	rz_warn_if_fail(cmd_m_cd);

	RzCmdDesc *cmd_plugins_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "L", rz_cmd_plugins, &cmd_plugins_help);
	rz_warn_if_fail(cmd_plugins_cd);

	RzCmdDesc *cmd_open_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "o", rz_cmd_open, &cmd_open_help);
	rz_warn_if_fail(cmd_open_cd);

	RzCmdDesc *cmd_print_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "p", rz_cmd_print, &cmd_print_help);
	rz_warn_if_fail(cmd_print_cd);

	RzCmdDesc *P_cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "P", NULL, NULL, &P_help);
	rz_warn_if_fail(P_cd);
	RzCmdDesc *project_save_cd = rz_cmd_desc_argv_new(core->rcmd, P_cd, "Ps", rz_project_save_handler, &project_save_help);
	rz_warn_if_fail(project_save_cd);

	RzCmdDesc *project_open_cd = rz_cmd_desc_argv_new(core->rcmd, P_cd, "Po", rz_project_open_handler, &project_open_help);
	rz_warn_if_fail(project_open_cd);

	RzCmdDesc *project_open_no_bin_io_cd = rz_cmd_desc_argv_new(core->rcmd, P_cd, "Poo", rz_project_open_no_bin_io_handler, &project_open_no_bin_io_help);
	rz_warn_if_fail(project_open_no_bin_io_cd);

	RzCmdDesc *cmd_quit_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "q", rz_cmd_quit, &cmd_quit_help);
	rz_warn_if_fail(cmd_quit_cd);

	RzCmdDesc *cmd_resize_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "r", rz_cmd_resize, &cmd_resize_help);
	rz_warn_if_fail(cmd_resize_cd);

	RzCmdDesc *s_cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "s", rz_seek_handler, &seek_help, &s_help);
	rz_warn_if_fail(s_cd);
	RzCmdDesc *seek_padded_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "s:", rz_seek_padded_handler, &seek_padded_help);
	rz_warn_if_fail(seek_padded_cd);

	RzCmdDesc *seek_base_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "s.", rz_seek_base_handler, &seek_base_help);
	rz_warn_if_fail(seek_base_cd);

	RzCmdDesc *seek_delta_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sd", rz_seek_delta_handler, &seek_delta_help);
	rz_warn_if_fail(seek_delta_cd);

	RzCmdDesc *seek_blocksize_backward_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "s--", rz_seek_blocksize_backward_handler, &seek_blocksize_backward_help);
	rz_warn_if_fail(seek_blocksize_backward_cd);

	RzCmdDesc *seek_blocksize_forward_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "s++", rz_seek_blocksize_forward_handler, &seek_blocksize_forward_help);
	rz_warn_if_fail(seek_blocksize_forward_cd);

	RzCmdDesc *sH_cd = rz_cmd_desc_group_modes_new(core->rcmd, s_cd, "sH", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_RIZIN, rz_seek_history_list_handler, &seek_history_list_help, &sH_help);
	rz_warn_if_fail(sH_cd);
	RzCmdDesc *seek_redo_cd = rz_cmd_desc_argv_new(core->rcmd, sH_cd, "sHr", rz_seek_redo_handler, &seek_redo_help);
	rz_warn_if_fail(seek_redo_cd);

	RzCmdDesc *seek_undo_cd = rz_cmd_desc_argv_new(core->rcmd, sH_cd, "sHu", rz_seek_undo_handler, &seek_undo_help);
	rz_warn_if_fail(seek_undo_cd);

	RzCmdDesc *seek_undo_reset_cd = rz_cmd_desc_argv_new(core->rcmd, sH_cd, "sH-", rz_seek_undo_reset_handler, &seek_undo_reset_help);
	rz_warn_if_fail(seek_undo_reset_cd);

	RzCmdDesc *seek_search_cd = rz_cmd_desc_oldinput_new(core->rcmd, s_cd, "s/", rz_seek_search, &seek_search_help);
	rz_warn_if_fail(seek_search_cd);

	RzCmdDesc *seek_asz_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sa", rz_seek_asz_handler, &seek_asz_help);
	rz_warn_if_fail(seek_asz_cd);

	RzCmdDesc *seek_basicblock_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sb", rz_seek_basicblock_handler, &seek_basicblock_help);
	rz_warn_if_fail(seek_basicblock_cd);

	RzCmdDesc *seek_function_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sf", rz_seek_function_handler, &seek_function_help);
	rz_warn_if_fail(seek_function_cd);

	RzCmdDesc *seek_function_current_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sf.", rz_seek_function_current_handler, &seek_function_current_help);
	rz_warn_if_fail(seek_function_current_cd);

	RzCmdDesc *seek_begin_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sg", rz_seek_begin_handler, &seek_begin_help);
	rz_warn_if_fail(seek_begin_cd);

	RzCmdDesc *seek_end_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sG", rz_seek_end_handler, &seek_end_help);
	rz_warn_if_fail(seek_end_cd);

	RzCmdDesc *seek_next_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sn", rz_seek_next_handler, &seek_next_help);
	rz_warn_if_fail(seek_next_cd);

	RzCmdDesc *seek_prev_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sp", rz_seek_prev_handler, &seek_prev_help);
	rz_warn_if_fail(seek_prev_cd);

	RzCmdDesc *seek_opcode_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "so", rz_seek_opcode_handler, &seek_opcode_help);
	rz_warn_if_fail(seek_opcode_cd);

	RzCmdDesc *seek_register_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sr", rz_seek_register_handler, &seek_register_help);
	rz_warn_if_fail(seek_register_cd);

	RzCmdDesc *sleep_cd = rz_cmd_desc_argv_new(core->rcmd, s_cd, "sleep", rz_sleep_handler, &sleep_help);
	rz_warn_if_fail(sleep_cd);

	RzCmdDesc *cmd_type_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "t", rz_cmd_type, &cmd_type_help);
	rz_warn_if_fail(cmd_type_cd);

	RzCmdDesc *uniq_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "uniq", rz_uniq_handler, &uniq_help);
	rz_warn_if_fail(uniq_cd);

	RzCmdDesc *uname_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "uname", rz_uname_handler, &uname_help);
	rz_warn_if_fail(uname_cd);

	RzCmdDesc *cmd_visual_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "V", rz_cmd_visual, &cmd_visual_help);
	rz_warn_if_fail(cmd_visual_cd);

	RzCmdDesc *cmd_panels_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "v", rz_cmd_panels, &cmd_panels_help);
	rz_warn_if_fail(cmd_panels_cd);

	RzCmdDesc *w_cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "w", rz_write_handler, &write_help, &w_help);
	rz_warn_if_fail(w_cd);
	RzCmdDesc *wB_cd = rz_cmd_desc_group_new(core->rcmd, w_cd, "wB", rz_write_bits_handler, &write_bits_help, &wB_help);
	rz_warn_if_fail(wB_cd);
	RzCmdDesc *write_unset_bits_cd = rz_cmd_desc_argv_new(core->rcmd, wB_cd, "wB-", rz_write_unset_bits_handler, &write_unset_bits_help);
	rz_warn_if_fail(write_unset_bits_cd);

	RzCmdDesc *wv_cd = rz_cmd_desc_group_new(core->rcmd, w_cd, "wv", rz_write_value_handler, &write_value_help, &wv_help);
	rz_warn_if_fail(wv_cd);
	RzCmdDesc *write_value1_cd = rz_cmd_desc_argv_new(core->rcmd, wv_cd, "wv1", rz_write_value1_handler, &write_value1_help);
	rz_warn_if_fail(write_value1_cd);

	RzCmdDesc *write_value2_cd = rz_cmd_desc_argv_new(core->rcmd, wv_cd, "wv2", rz_write_value2_handler, &write_value2_help);
	rz_warn_if_fail(write_value2_cd);

	RzCmdDesc *write_value4_cd = rz_cmd_desc_argv_new(core->rcmd, wv_cd, "wv4", rz_write_value4_handler, &write_value4_help);
	rz_warn_if_fail(write_value4_cd);

	RzCmdDesc *write_value8_cd = rz_cmd_desc_argv_new(core->rcmd, wv_cd, "wv8", rz_write_value8_handler, &write_value8_help);
	rz_warn_if_fail(write_value8_cd);

	RzCmdDesc *write_zero_cd = rz_cmd_desc_argv_new(core->rcmd, w_cd, "w0", rz_write_zero_handler, &write_zero_help);
	rz_warn_if_fail(write_zero_cd);

	RzCmdDesc *write_incdec_cd = rz_cmd_desc_inner_new(core->rcmd, w_cd, "w", &write_incdec_help);
	rz_warn_if_fail(write_incdec_cd);
	RzCmdDesc *w1_cd = rz_cmd_desc_group_new(core->rcmd, write_incdec_cd, "w1", NULL, NULL, &w1_help);
	rz_warn_if_fail(w1_cd);
	RzCmdDesc *write_1_inc_cd = rz_cmd_desc_argv_new(core->rcmd, w1_cd, "w1+", rz_write_1_inc_handler, &write_1_inc_help);
	rz_warn_if_fail(write_1_inc_cd);

	RzCmdDesc *write_1_dec_cd = rz_cmd_desc_argv_new(core->rcmd, w1_cd, "w1-", rz_write_1_dec_handler, &write_1_dec_help);
	rz_warn_if_fail(write_1_dec_cd);

	RzCmdDesc *w2_cd = rz_cmd_desc_group_new(core->rcmd, write_incdec_cd, "w2", NULL, NULL, &w2_help);
	rz_warn_if_fail(w2_cd);
	RzCmdDesc *write_2_inc_cd = rz_cmd_desc_argv_new(core->rcmd, w2_cd, "w2+", rz_write_2_inc_handler, &write_2_inc_help);
	rz_warn_if_fail(write_2_inc_cd);

	RzCmdDesc *write_2_dec_cd = rz_cmd_desc_argv_new(core->rcmd, w2_cd, "w2-", rz_write_2_dec_handler, &write_2_dec_help);
	rz_warn_if_fail(write_2_dec_cd);

	RzCmdDesc *w4_cd = rz_cmd_desc_group_new(core->rcmd, write_incdec_cd, "w4", NULL, NULL, &w4_help);
	rz_warn_if_fail(w4_cd);
	RzCmdDesc *write_4_inc_cd = rz_cmd_desc_argv_new(core->rcmd, w4_cd, "w4+", rz_write_4_inc_handler, &write_4_inc_help);
	rz_warn_if_fail(write_4_inc_cd);

	RzCmdDesc *write_4_dec_cd = rz_cmd_desc_argv_new(core->rcmd, w4_cd, "w4-", rz_write_4_dec_handler, &write_4_dec_help);
	rz_warn_if_fail(write_4_dec_cd);

	RzCmdDesc *w8_cd = rz_cmd_desc_group_new(core->rcmd, write_incdec_cd, "w8", NULL, NULL, &w8_help);
	rz_warn_if_fail(w8_cd);
	RzCmdDesc *write_8_inc_cd = rz_cmd_desc_argv_new(core->rcmd, w8_cd, "w8+", rz_write_8_inc_handler, &write_8_inc_help);
	rz_warn_if_fail(write_8_inc_cd);

	RzCmdDesc *write_8_dec_cd = rz_cmd_desc_argv_new(core->rcmd, w8_cd, "w8-", rz_write_8_dec_handler, &write_8_dec_help);
	rz_warn_if_fail(write_8_dec_cd);

	RzCmdDesc *w6_cd = rz_cmd_desc_group_new(core->rcmd, w_cd, "w6", NULL, NULL, &w6_help);
	rz_warn_if_fail(w6_cd);
	RzCmdDesc *write_base64_decode_cd = rz_cmd_desc_argv_new(core->rcmd, w6_cd, "w6d", rz_write_base64_decode_handler, &write_base64_decode_help);
	rz_warn_if_fail(write_base64_decode_cd);

	RzCmdDesc *write_base64_encode_cd = rz_cmd_desc_argv_new(core->rcmd, w6_cd, "w6e", rz_write_base64_encode_handler, &write_base64_encode_help);
	rz_warn_if_fail(write_base64_encode_cd);

	RzCmdDesc *wh_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wh", rz_wh_handler_old, &wh_handler_old_help);
	rz_warn_if_fail(wh_handler_old_cd);

	RzCmdDesc *we_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "we", rz_we_handler_old, &we_handler_old_help);
	rz_warn_if_fail(we_handler_old_cd);

	RzCmdDesc *wu_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wu", rz_wu_handler_old, &wu_handler_old_help);
	rz_warn_if_fail(wu_handler_old_cd);

	RzCmdDesc *wr_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wr", rz_wr_handler_old, &wr_handler_old_help);
	rz_warn_if_fail(wr_handler_old_cd);

	RzCmdDesc *wA_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wA", rz_wA_handler_old, &wA_handler_old_help);
	rz_warn_if_fail(wA_handler_old_cd);

	RzCmdDesc *wc_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wc", rz_wc_handler_old, &wc_handler_old_help);
	rz_warn_if_fail(wc_handler_old_cd);

	RzCmdDesc *wz_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wz", rz_wz_handler_old, &wz_handler_old_help);
	rz_warn_if_fail(wz_handler_old_cd);

	RzCmdDesc *wt_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wt", rz_wt_handler_old, &wt_handler_old_help);
	rz_warn_if_fail(wt_handler_old_cd);

	RzCmdDesc *wf_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wf", rz_wf_handler_old, &wf_handler_old_help);
	rz_warn_if_fail(wf_handler_old_cd);

	RzCmdDesc *ww_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "ww", rz_ww_handler_old, &ww_handler_old_help);
	rz_warn_if_fail(ww_handler_old_cd);

	RzCmdDesc *wx_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wx", rz_wx_handler_old, &wx_handler_old_help);
	rz_warn_if_fail(wx_handler_old_cd);

	RzCmdDesc *wa_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wa", rz_wa_handler_old, &wa_handler_old_help);
	rz_warn_if_fail(wa_handler_old_cd);

	RzCmdDesc *wb_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wb", rz_wb_handler_old, &wb_handler_old_help);
	rz_warn_if_fail(wb_handler_old_cd);

	RzCmdDesc *wm_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wm", rz_wm_handler_old, &wm_handler_old_help);
	rz_warn_if_fail(wm_handler_old_cd);

	RzCmdDesc *wo_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wo", rz_wo_handler_old, &wo_handler_old_help);
	rz_warn_if_fail(wo_handler_old_cd);

	RzCmdDesc *wd_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "wd", rz_wd_handler_old, &wd_handler_old_help);
	rz_warn_if_fail(wd_handler_old_cd);

	RzCmdDesc *ws_handler_old_cd = rz_cmd_desc_oldinput_new(core->rcmd, w_cd, "ws", rz_ws_handler_old, &ws_handler_old_help);
	rz_warn_if_fail(ws_handler_old_cd);

	RzCmdDesc *cmd_hexdump_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "x", rz_cmd_hexdump, &cmd_hexdump_help);
	rz_warn_if_fail(cmd_hexdump_cd);

	RzCmdDesc *cmd_yank_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "y", rz_cmd_yank, &cmd_yank_help);
	rz_warn_if_fail(cmd_yank_cd);

	RzCmdDesc *z_cd = rz_cmd_desc_group_modes_new(core->rcmd, root_cd, "z", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_QUIET | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_SDB, rz_zign_show_handler, &zign_show_help, &z_help);
	rz_warn_if_fail(z_cd);
	RzCmdDesc *zign_find_cd = rz_cmd_desc_argv_modes_new(core->rcmd, z_cd, "z.", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN, rz_zign_find_handler, &zign_find_help);
	rz_warn_if_fail(zign_find_cd);

	RzCmdDesc *zb_cd = rz_cmd_desc_group_new(core->rcmd, z_cd, "zb", rz_zign_best_handler, &zign_best_help, &zb_help);
	rz_warn_if_fail(zb_cd);
	RzCmdDesc *zign_best_name_cd = rz_cmd_desc_argv_new(core->rcmd, zb_cd, "zbr", rz_zign_best_name_handler, &zign_best_name_help);
	rz_warn_if_fail(zign_best_name_cd);

	RzCmdDesc *zign_delete_cd = rz_cmd_desc_argv_new(core->rcmd, z_cd, "z-", rz_zign_delete_handler, &zign_delete_help);
	rz_warn_if_fail(zign_delete_cd);

	RzCmdDesc *za_cd = rz_cmd_desc_group_new(core->rcmd, z_cd, "za", rz_zign_add_handler, &zign_add_help, &za_help);
	rz_warn_if_fail(za_cd);
	RzCmdDesc *zign_add_fcn_cd = rz_cmd_desc_argv_new(core->rcmd, za_cd, "zaf", rz_zign_add_fcn_handler, &zign_add_fcn_help);
	rz_warn_if_fail(zign_add_fcn_cd);

	RzCmdDesc *zign_add_all_fcns_cd = rz_cmd_desc_argv_new(core->rcmd, za_cd, "zaF", rz_zign_add_all_fcns_handler, &zign_add_all_fcns_help);
	rz_warn_if_fail(zign_add_all_fcns_cd);

	RzCmdDesc *zign_generate_cd = rz_cmd_desc_argv_new(core->rcmd, z_cd, "zg", rz_zign_generate_handler, &zign_generate_help);
	rz_warn_if_fail(zign_generate_cd);

	RzCmdDesc *zo_cd = rz_cmd_desc_group_new(core->rcmd, z_cd, "zo", rz_zign_load_sdb_handler, &zign_load_sdb_help, &zo_help);
	rz_warn_if_fail(zo_cd);
	RzCmdDesc *zign_save_sdb_cd = rz_cmd_desc_argv_new(core->rcmd, zo_cd, "zos", rz_zign_save_sdb_handler, &zign_save_sdb_help);
	rz_warn_if_fail(zign_save_sdb_cd);

	RzCmdDesc *zign_load_gzip_sdb_cd = rz_cmd_desc_argv_new(core->rcmd, zo_cd, "zoz", rz_zign_load_gzip_sdb_handler, &zign_load_gzip_sdb_help);
	rz_warn_if_fail(zign_load_gzip_sdb_cd);

	RzCmdDesc *zf_cd = rz_cmd_desc_group_new(core->rcmd, z_cd, "zf", NULL, NULL, &zf_help);
	rz_warn_if_fail(zf_cd);
	RzCmdDesc *zign_flirt_dump_cd = rz_cmd_desc_argv_new(core->rcmd, zf_cd, "zfd", rz_zign_flirt_dump_handler, &zign_flirt_dump_help);
	rz_warn_if_fail(zign_flirt_dump_cd);

	RzCmdDesc *zign_flirt_scan_cd = rz_cmd_desc_argv_new(core->rcmd, zf_cd, "zfs", rz_zign_flirt_scan_handler, &zign_flirt_scan_help);
	rz_warn_if_fail(zign_flirt_scan_cd);

	RzCmdDesc *z_slash__cd = rz_cmd_desc_group_modes_new(core->rcmd, z_cd, "z/", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN, rz_zign_search_handler, &zign_search_help, &z_slash__help);
	rz_warn_if_fail(z_slash__cd);
	RzCmdDesc *zign_search_fcn_cd = rz_cmd_desc_argv_modes_new(core->rcmd, z_slash__cd, "z/f", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN, rz_zign_search_fcn_handler, &zign_search_fcn_help);
	rz_warn_if_fail(zign_search_fcn_cd);

	RzCmdDesc *zc_cd = rz_cmd_desc_group_new(core->rcmd, z_cd, "zc", rz_zign_cmp_handler, &zign_cmp_help, &zc_help);
	rz_warn_if_fail(zc_cd);
	RzCmdDesc *zcn_cd = rz_cmd_desc_group_new(core->rcmd, zc_cd, "zcn", rz_zign_cmp_name_handler, &zign_cmp_name_help, &zcn_help);
	rz_warn_if_fail(zcn_cd);
	RzCmdDesc *zign_cmp_diff_name_cd = rz_cmd_desc_argv_new(core->rcmd, zcn_cd, "zcn!", rz_zign_cmp_diff_name_handler, &zign_cmp_diff_name_help);
	rz_warn_if_fail(zign_cmp_diff_name_cd);

	RzCmdDesc *zs_cd = rz_cmd_desc_group_modes_new(core->rcmd, z_cd, "zs", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_RIZIN, rz_zign_space_select_handler, &zign_space_select_help, &zs_help);
	rz_warn_if_fail(zs_cd);
	RzCmdDesc *zign_space_delete_cd = rz_cmd_desc_argv_new(core->rcmd, zs_cd, "zs-", rz_zign_space_delete_handler, &zign_space_delete_help);
	rz_warn_if_fail(zign_space_delete_cd);

	RzCmdDesc *zign_space_add_cd = rz_cmd_desc_argv_new(core->rcmd, zs_cd, "zs+", rz_zign_space_add_handler, &zign_space_add_help);
	rz_warn_if_fail(zign_space_add_cd);

	RzCmdDesc *zign_space_rename_cd = rz_cmd_desc_argv_new(core->rcmd, zs_cd, "zsr", rz_zign_space_rename_handler, &zign_space_rename_help);
	rz_warn_if_fail(zign_space_rename_cd);

	RzCmdDesc *zi_cd = rz_cmd_desc_group_modes_new(core->rcmd, z_cd, "zi", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_QUIET, rz_zign_info_handler, &zign_info_help, &zi_help);
	rz_warn_if_fail(zi_cd);
	RzCmdDesc *zign_info_range_cd = rz_cmd_desc_argv_new(core->rcmd, zi_cd, "zii", rz_zign_info_range_handler, &zign_info_range_help);
	rz_warn_if_fail(zign_info_range_cd);

	RzCmdDesc *tmp_modifiers_cd = rz_cmd_desc_fake_new(core->rcmd, root_cd, "@", &tmp_modifiers_help);
	rz_warn_if_fail(tmp_modifiers_cd);

	RzCmdDesc *iterators_cd = rz_cmd_desc_fake_new(core->rcmd, root_cd, "@@", &iterators_help);
	rz_warn_if_fail(iterators_cd);

	RzCmdDesc *redirection_cd = rz_cmd_desc_fake_new(core->rcmd, root_cd, ">", &redirection_help);
	rz_warn_if_fail(redirection_cd);

	RzCmdDesc *pipe_cd = rz_cmd_desc_fake_new(core->rcmd, root_cd, "|", &pipe_help);
	rz_warn_if_fail(pipe_cd);

	RzCmdDesc *grep_cd = rz_cmd_desc_fake_new(core->rcmd, root_cd, "~", &grep_help);
	rz_warn_if_fail(grep_cd);
}
