// SPDX-FileCopyrightText: 2020 RizinOrg <info@rizin.re>
// 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 remote_add_args[2];
static const RzCmdDescArg remote_del_args[2];
static const RzCmdDescArg remote_open_args[2];
static const RzCmdDescArg remote_mode_enable_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 cmd_help_search_args[2];
static const RzCmdDescArg push_escaped_args[2];
static const RzCmdDescArg analysis_function_blocks_list_args[2];
static const RzCmdDescArg analysis_function_blocks_add_args[7];
static const RzCmdDescArg analysis_function_blocks_del_args[2];
static const RzCmdDescArg analysis_function_blocks_del_all_args[2];
static const RzCmdDescArg analysis_function_blocks_edge_args[3];
static const RzCmdDescArg analysis_function_returns_args[2];
static const RzCmdDescArg analysis_function_blocks_asciiart_args[2];
static const RzCmdDescArg analysis_function_blocks_info_args[2];
static const RzCmdDescArg analysis_function_blocks_color_args[3];
static const RzCmdDescArg analysis_function_setbits_args[2];
static const RzCmdDescArg analysis_function_signature_args[2];
static const RzCmdDescArg analysis_function_signature_type_args[2];
static const RzCmdDescArg analysis_function_until_args[2];
static const RzCmdDescArg analysis_function_stacksz_args[2];
static const RzCmdDescArg analysis_function_vars_del_args[2];
static const RzCmdDescArg analysis_function_vars_display_args[2];
static const RzCmdDescArg analysis_function_vars_rename_args[3];
static const RzCmdDescArg analysis_function_vars_reads_args[2];
static const RzCmdDescArg analysis_function_vars_writes_args[2];
static const RzCmdDescArg analysis_function_vars_type_args[3];
static const RzCmdDescArg analysis_function_vars_xrefs_args[2];
static const RzCmdDescArg analysis_function_vars_bp_args[4];
static const RzCmdDescArg analysis_function_vars_bp_del_args[2];
static const RzCmdDescArg analysis_function_vars_bp_getref_args[3];
static const RzCmdDescArg analysis_function_vars_bp_setref_args[3];
static const RzCmdDescArg analysis_function_vars_regs_args[4];
static const RzCmdDescArg analysis_function_vars_regs_del_args[2];
static const RzCmdDescArg analysis_function_vars_regs_getref_args[3];
static const RzCmdDescArg analysis_function_vars_regs_setref_args[3];
static const RzCmdDescArg analysis_function_vars_sp_args[4];
static const RzCmdDescArg analysis_function_vars_sp_del_args[2];
static const RzCmdDescArg analysis_function_vars_sp_getref_args[3];
static const RzCmdDescArg analysis_function_vars_sp_setref_args[3];
static const RzCmdDescArg cmd_debug_step_until_args[2];
static const RzCmdDescArg cmd_debug_step_until_instr_args[2];
static const RzCmdDescArg cmd_debug_step_until_instr_regex_args[2];
static const RzCmdDescArg cmd_debug_step_until_optype_args[2];
static const RzCmdDescArg cmd_debug_step_until_esil_args[2];
static const RzCmdDescArg cmd_debug_step_until_flag_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 type_args[2];
static const RzCmdDescArg type_del_args[2];
static const RzCmdDescArg type_list_c_args[2];
static const RzCmdDescArg type_list_c_nl_args[2];
static const RzCmdDescArg type_cc_list_args[2];
static const RzCmdDescArg type_cc_del_args[2];
static const RzCmdDescArg type_define_args[2];
static const RzCmdDescArg type_list_enum_args[3];
static const RzCmdDescArg type_enum_bitfield_args[3];
static const RzCmdDescArg type_enum_c_args[2];
static const RzCmdDescArg type_enum_c_nl_args[2];
static const RzCmdDescArg type_enum_find_args[2];
static const RzCmdDescArg type_list_function_args[2];
static const RzCmdDescArg type_kuery_args[2];
static const RzCmdDescArg type_link_args[3];
static const RzCmdDescArg type_link_show_args[2];
static const RzCmdDescArg type_link_del_args[2];
static const RzCmdDescArg type_list_noreturn_args[2];
static const RzCmdDescArg type_noreturn_del_args[2];
static const RzCmdDescArg type_open_file_args[2];
static const RzCmdDescArg type_open_editor_args[2];
static const RzCmdDescArg type_open_sdb_args[2];
static const RzCmdDescArg type_print_args[3];
static const RzCmdDescArg type_print_value_args[3];
static const RzCmdDescArg type_print_hexstring_args[3];
static const RzCmdDescArg type_list_structure_args[2];
static const RzCmdDescArg type_structure_c_args[2];
static const RzCmdDescArg type_structure_c_nl_args[2];
static const RzCmdDescArg type_list_typedef_args[2];
static const RzCmdDescArg type_typedef_c_args[2];
static const RzCmdDescArg type_list_union_args[2];
static const RzCmdDescArg type_union_c_args[2];
static const RzCmdDescArg type_union_c_nl_args[2];
static const RzCmdDescArg type_xrefs_list_args[2];
static const RzCmdDescArg type_xrefs_function_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 write_from_io_args[3];
static const RzCmdDescArg write_from_io_xchg_args[3];
static const RzCmdDescArg write_from_file_args[4];
static const RzCmdDescArg write_from_socket_args[3];
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_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 RzCmdDescHelp io_system_run_oldhandler_help = {
	.summary = "Run <cmd> via rz_io_system",
	.args_str = "[<cmd>]",
	.options = "",
};

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

	},
	{ 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[] = {
	{
		.name = "fd",
		.type = RZ_CMD_ARG_TYPE_NUM,
		.default_value = "0",

	},
	{ 0 },
};
static const RzCmdDescHelp remote_mode_enable_help = {
	.summary = "Enable remote cmd mode, sending commands to remote <fd> server",
	.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 RzCmdDescArg cmd_help_search_args[] = {
	{
		.name = "search_cmd",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_help_search_help = {
	.summary = "Search help",
	.args = cmd_help_search_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,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 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_analysis_fcn_help = {
	.summary = "Analyze Functions commands",
};
static const RzCmdDescHelp afb_help = {
	.summary = "Basic blocks commands",
};
static const RzCmdDescArg analysis_function_blocks_list_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_list_help = {
	.summary = "List basic blocks of function",
	.args = analysis_function_blocks_list_args,
};

static const char *analysis_function_blocks_add_diff_choices[] = { "m", "u", NULL };
static const RzCmdDescArg analysis_function_blocks_add_args[] = {
	{
		.name = "fcn_addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "size",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "jump",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.optional = true,

	},
	{
		.name = "fail",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.optional = true,

	},
	{
		.name = "diff",
		.type = RZ_CMD_ARG_TYPE_CHOICES,
		.optional = true,
		.choices = analysis_function_blocks_add_diff_choices,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_add_help = {
	.summary = "Add basic block by hand",
	.args = analysis_function_blocks_add_args,
};

static const RzCmdDescArg analysis_function_blocks_del_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_del_help = {
	.summary = "Remove basic block from function",
	.args = analysis_function_blocks_del_args,
};

static const RzCmdDescArg analysis_function_blocks_del_all_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_del_all_help = {
	.summary = "Remove all basic blocks from function",
	.args = analysis_function_blocks_del_all_args,
};

static const RzCmdDescArg analysis_function_blocks_edge_args[] = {
	{
		.name = "switch_addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "case_addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_edge_help = {
	.summary = "Add basic-block edge for switch-cases",
	.args = analysis_function_blocks_edge_args,
};

static const RzCmdDescArg analysis_function_returns_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_returns_help = {
	.summary = "Show addresses of instructions which leave the function",
	.args = analysis_function_returns_args,
};

static const RzCmdDescArg analysis_function_blocks_asciiart_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_asciiart_help = {
	.summary = "Display ascii-art bars for basic block regions",
	.args = analysis_function_blocks_asciiart_args,
};

static const RzCmdDescArg analysis_function_blocks_info_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_info_help = {
	.summary = "Print single basic block information",
	.args = analysis_function_blocks_info_args,
};

static const RzCmdDescArg analysis_function_blocks_color_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "color",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_blocks_color_help = {
	.summary = "Set a color for the basic block at a given address",
	.args = analysis_function_blocks_color_args,
};

static const RzCmdDescArg analysis_function_setbits_args[] = {
	{
		.name = "bits",
		.type = RZ_CMD_ARG_TYPE_NUM,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_setbits_help = {
	.summary = "Set asm.bits for the current function",
	.args = analysis_function_setbits_args,
};

static const RzCmdDescHelp afs_help = {
	.summary = "Function signatures commands",
};
static const RzCmdDescArg analysis_function_signature_args[] = {
	{
		.name = "signature",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_signature_help = {
	.summary = "Get/Set function signature at current address",
	.args = analysis_function_signature_args,
};

static const RzCmdDescArg analysis_function_signature_editor_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_signature_editor_help = {
	.summary = "Set function signature at current address by using the editor",
	.args = analysis_function_signature_editor_args,
};

static const RzCmdDescArg analysis_function_signature_type_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_signature_type_help = {
	.summary = "Change type for current function",
	.args = analysis_function_signature_type_args,
};

static const RzCmdDescArg analysis_function_address_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_address_help = {
	.summary = "Show address of current function",
	.args = analysis_function_address_args,
};

static const RzCmdDescArg analysis_function_until_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_until_help = {
	.summary = "Resize and analyze function from current address until addr",
	.args = analysis_function_until_args,
};

static const RzCmdDescArg analysis_function_xrefs_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_xrefs_help = {
	.summary = "List function references",
	.args = analysis_function_xrefs_args,
};

static const RzCmdDescArg analysis_function_stacksz_args[] = {
	{
		.name = "size",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_stacksz_help = {
	.summary = "Set stack frame size for function at current address",
	.args = analysis_function_stacksz_args,
};

static const RzCmdDescHelp afv_help = {
	.summary = "Manipulate arguments/variables in a function",
};
static const RzCmdDescArg analysis_function_vars_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_help = {
	.summary = "List all variables and arguments of the current function",
	.args = analysis_function_vars_args,
};

static const RzCmdDescArg analysis_function_vars_dis_refs_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_dis_refs_help = {
	.summary = "List function variables and arguments with disasm refs",
	.args = analysis_function_vars_dis_refs_args,
};

static const RzCmdDescArg analysis_function_vars_del_args[] = {
	{
		.name = "varname|*",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_del_help = {
	.summary = "Remove all variables/arguments or just the specified one",
	.args = analysis_function_vars_del_args,
};

static const RzCmdDescArg analysis_function_vars_detect_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_detect_help = {
	.summary = "Analyze function arguments/locals",
	.args = analysis_function_vars_detect_args,
};

static const RzCmdDescArg analysis_function_vars_display_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_display_help = {
	.summary = "Display the value of arguments/variables",
	.args = analysis_function_vars_display_args,
};

static const RzCmdDescArg analysis_function_vars_stackframe_args[] = {
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_stackframe_help = {
	.summary = "Show BP relative stackframe variables",
	.args = analysis_function_vars_stackframe_args,
};

static const RzCmdDescArg analysis_function_vars_rename_args[] = {
	{
		.name = "new_name",
		.type = RZ_CMD_ARG_TYPE_STRING,

	},
	{
		.name = "old_name",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_rename_help = {
	.summary = "Rename argument/variable in current function",
	.args = analysis_function_vars_rename_args,
};

static const RzCmdDescArg analysis_function_vars_reads_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_reads_help = {
	.summary = "List addresses where vars are accessed (READ)",
	.args = analysis_function_vars_reads_args,
};

static const RzCmdDescArg analysis_function_vars_writes_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_writes_help = {
	.summary = "List addresses where vars are accessed (WRITE)",
	.args = analysis_function_vars_writes_args,
};

static const RzCmdDescArg analysis_function_vars_type_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,

	},
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_type_help = {
	.summary = "Change type for given argument/local",
	.args = analysis_function_vars_type_args,
};

static const RzCmdDescArg analysis_function_vars_xrefs_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_xrefs_help = {
	.summary = "Show function variable xrefs (same as afvR+afvW)",
	.args = analysis_function_vars_xrefs_args,
};

static const RzCmdDescHelp afvb_help = {
	.summary = "Manipulate BP based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_bp_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.optional = true,

	},
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_STRING,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_help = {
	.summary = "List base pointer based arguments and locals / Define a new one",
	.args = analysis_function_vars_bp_args,
};

static const RzCmdDescArg analysis_function_vars_bp_del_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_del_help = {
	.summary = "Delete argument/local with the given name",
	.args = analysis_function_vars_bp_del_args,
};

static const RzCmdDescArg analysis_function_vars_bp_getref_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_getref_help = {
	.summary = "Define var get reference",
	.args = analysis_function_vars_bp_getref_args,
};

static const RzCmdDescArg analysis_function_vars_bp_setref_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_setref_help = {
	.summary = "Define var set reference",
	.args = analysis_function_vars_bp_setref_args,
};

static const RzCmdDescHelp afvr_help = {
	.summary = "Manipulate register-based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_regs_args[] = {
	{
		.name = "reg",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_STRING,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_help = {
	.summary = "List register-based arguments and locals / Define a new one",
	.args = analysis_function_vars_regs_args,
};

static const RzCmdDescArg analysis_function_vars_regs_del_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_del_help = {
	.summary = "Delete register-based argument/local with the given name",
	.args = analysis_function_vars_regs_del_args,
};

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

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_getref_help = {
	.summary = "Define register-based arguments and locals get references",
	.args = analysis_function_vars_regs_getref_args,
};

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

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_setref_help = {
	.summary = "Define register-based arguments and locals set references",
	.args = analysis_function_vars_regs_setref_args,
};

static const RzCmdDescHelp afvs_help = {
	.summary = "Manipulate SP based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_sp_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.optional = true,

	},
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_STRING,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_help = {
	.summary = "List stack based arguments and locals / Define a new one",
	.args = analysis_function_vars_sp_args,
};

static const RzCmdDescArg analysis_function_vars_sp_del_args[] = {
	{
		.name = "varname",
		.type = RZ_CMD_ARG_TYPE_FCN_VAR,

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_del_help = {
	.summary = "Delete argument/local with the given name",
	.args = analysis_function_vars_sp_del_args,
};

static const RzCmdDescArg analysis_function_vars_sp_getref_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_getref_help = {
	.summary = "Define var get reference",
	.args = analysis_function_vars_sp_getref_args,
};

static const RzCmdDescArg analysis_function_vars_sp_setref_args[] = {
	{
		.name = "delta",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

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

	},
	{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_setref_help = {
	.summary = "Define var set reference",
	.args = analysis_function_vars_sp_setref_args,
};

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 debug_continue_oldhandler_help = {
	.summary = "Continue execution",
};

static const RzCmdDescHelp cmd_debug_step_help = {
	.summary = "Debug step commands",
};
static const RzCmdDescHelp dsu_help = {
	.summary = "Debug step until commands",
};
static const RzCmdDescArg cmd_debug_step_until_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_help = {
	.summary = "Step until <addr>",
	.args = cmd_debug_step_until_args,
};

static const RzCmdDescArg cmd_debug_step_until_instr_args[] = {
	{
		.name = "instr",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_instr_help = {
	.summary = "Step until an instruction that matches <instr>",
	.args = cmd_debug_step_until_instr_args,
};

static const RzCmdDescArg cmd_debug_step_until_instr_regex_args[] = {
	{
		.name = "regex",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_instr_regex_help = {
	.summary = "Step until an instruction that matches <regex>",
	.args = cmd_debug_step_until_instr_regex_args,
};

static const RzCmdDescArg cmd_debug_step_until_optype_args[] = {
	{
		.name = "optype",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_optype_help = {
	.summary = "Step until an instruction matches one of the <optype>s",
	.args = cmd_debug_step_until_optype_args,
};

static const RzCmdDescArg cmd_debug_step_until_esil_args[] = {
	{
		.name = "esil",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_esil_help = {
	.summary = "Step until <esil> expression matches",
	.args = cmd_debug_step_until_esil_args,
};

static const RzCmdDescArg cmd_debug_step_until_flag_args[] = {
	{
		.name = "flag",
		.type = RZ_CMD_ARG_TYPE_FLAG,

	},
	{ 0 },
};
static const RzCmdDescHelp cmd_debug_step_until_flag_help = {
	.summary = "Step until pc == <flag> matching name",
	.args = cmd_debug_step_until_flag_args,
};

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,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.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 RzCmdDescArg cmd_exit_args[] = {
	{ 0 },
};
static const RzCmdDescHelp cmd_exit_help = {
	.summary = "Exit Rizin",
	.args = cmd_exit_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 q_help = {
	.summary = "Quit rizin",
};
static const RzCmdDescArg cmd_quit_args[] = {
	{ 0 },
};
static const RzCmdDescHelp cmd_quit_help = {
	.summary = "Quit rizin",
	.args = cmd_quit_args,
};

static const RzCmdDescArg cmd_force_quit_args[] = {
	{ 0 },
};
static const RzCmdDescHelp cmd_force_quit_help = {
	.summary = "Force quit rizin",
	.args = cmd_force_quit_args,
};

static const RzCmdDescArg cmd_force_quit_without_history_args[] = {
	{ 0 },
};
static const RzCmdDescHelp cmd_force_quit_without_history_help = {
	.summary = "Force quit rizin without saving history",
	.args = cmd_force_quit_without_history_args,
};

static const RzCmdDescHelp quit_with_preference_help = {
	.summary = "Quit rizin and choose to kill the process and save projects",
	.options = "<yn><yn>",
};
static const RzCmdDescHelp qy_help = {
	.summary = "Quit rizin by killing the process and and choose to save the projects or not",
};
static const RzCmdDescArg quit_kill_save_args[] = {
	{ 0 },
};
static const RzCmdDescHelp quit_kill_save_help = {
	.summary = "Quit rizin by killing the process and saving the project",
	.args = quit_kill_save_args,
};

static const RzCmdDescArg quit_kill_nosave_args[] = {
	{ 0 },
};
static const RzCmdDescHelp quit_kill_nosave_help = {
	.summary = "Quit rizin by killing the process and not saving the project",
	.args = quit_kill_nosave_args,
};

static const RzCmdDescHelp qn_help = {
	.summary = "Quit rizin by not killing the process and choose to save the projects or not",
};
static const RzCmdDescArg quit_nokill_nosave_args[] = {
	{ 0 },
};
static const RzCmdDescHelp quit_nokill_nosave_help = {
	.summary = "Quit rizin by not killing the process and not saving the project",
	.args = quit_nokill_nosave_args,
};

static const RzCmdDescArg quit_nokill_save_args[] = {
	{ 0 },
};
static const RzCmdDescHelp quit_nokill_save_help = {
	.summary = "Quit rizin by not killing the process and saving the project",
	.args = quit_nokill_save_args,
};

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,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 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 t_help = {
	.summary = "Types, noreturn, signatures, C parser and more",
};
static const RzCmdDescArg type_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_help = {
	.summary = "List all types / Show type information",
	.args = type_args,
};

static const RzCmdDescArg type_del_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,

	},
	{ 0 },
};
static const RzCmdDescHelp type_del_help = {
	.summary = "Remove the type",
	.args = type_del_args,
};

static const RzCmdDescArg type_del_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_del_all_help = {
	.summary = "Remove all types",
	.args = type_del_all_args,
};

static const RzCmdDescHelp tc_help = {
	.summary = "List loaded types in C format",
};
static const RzCmdDescArg type_list_c_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_c_help = {
	.summary = "List loaded types in C format with newlines",
	.args = type_list_c_args,
};

static const RzCmdDescArg type_list_c_nl_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_c_nl_help = {
	.summary = "List loaded types in C format without newlines",
	.args = type_list_c_nl_args,
};

static const RzCmdDescHelp tcc_help = {
	.summary = "Manage calling convention types",
};
static const RzCmdDescArg type_cc_list_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_cc_list_help = {
	.summary = "List all calling conventions",
	.args = type_cc_list_args,
};

static const RzCmdDescArg type_cc_del_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_cc_del_help = {
	.summary = "Remove the calling convention",
	.args = type_cc_del_args,
};

static const RzCmdDescArg type_cc_del_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_cc_del_all_help = {
	.summary = "Remove all calling conventions",
	.args = type_cc_del_all_args,
};

static const RzCmdDescArg type_define_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_define_help = {
	.summary = "Define type from C definition",
	.args = type_define_args,
};

static const RzCmdDescHelp te_help = {
	.summary = "List loaded enums",
};
static const RzCmdDescArg type_list_enum_args[] = {
	{
		.name = "enum",
		.type = RZ_CMD_ARG_TYPE_ENUM_TYPE,
		.optional = true,

	},
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_enum_help = {
	.summary = "List loaded enums / Show enum member",
	.args = type_list_enum_args,
};

static const RzCmdDescArg type_enum_bitfield_args[] = {
	{
		.name = "enum",
		.type = RZ_CMD_ARG_TYPE_ENUM_TYPE,

	},
	{
		.name = "field",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_enum_bitfield_help = {
	.summary = "Show enum bitfield",
	.args = type_enum_bitfield_args,
};

static const RzCmdDescArg type_enum_c_args[] = {
	{
		.name = "enum",
		.type = RZ_CMD_ARG_TYPE_ENUM_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_enum_c_help = {
	.summary = "Show enum in the C output format",
	.args = type_enum_c_args,
};

static const RzCmdDescArg type_enum_c_nl_args[] = {
	{
		.name = "enum",
		.type = RZ_CMD_ARG_TYPE_ENUM_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_enum_c_nl_help = {
	.summary = "Show enum in the C output format without newlines",
	.args = type_enum_c_nl_args,
};

static const RzCmdDescArg type_enum_find_args[] = {
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_enum_find_help = {
	.summary = "Find enum and member by the member value",
	.args = type_enum_find_args,
};

static const RzCmdDescHelp tf_help = {
	.summary = "List loaded functions definitions",
};
static const RzCmdDescArg type_list_function_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_function_help = {
	.summary = "List loaded function definitions / Show function signature",
	.args = type_list_function_args,
};

static const RzCmdDescArg type_kuery_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_kuery_help = {
	.summary = "Perform SDB query on types database",
	.args = type_kuery_args,
};

static const RzCmdDescHelp tl_help = {
	.summary = "Manage type links to the address",
};
static const RzCmdDescArg type_link_args[] = {
	{
		.name = "typename",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.optional = true,

	},
	{
		.name = "address",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_link_help = {
	.summary = "List all type links / Add a type link",
	.args = type_link_args,
};

static const RzCmdDescArg type_link_show_args[] = {
	{
		.name = "address",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_link_show_help = {
	.summary = "Show the type link",
	.args = type_link_show_args,
};

static const RzCmdDescArg type_link_del_args[] = {
	{
		.name = "address",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_link_del_help = {
	.summary = "Remove the type link",
	.args = type_link_del_args,
};

static const RzCmdDescArg type_link_del_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_link_del_all_help = {
	.summary = "Remove all type links",
	.args = type_link_del_all_args,
};

static const RzCmdDescHelp tn_help = {
	.summary = "Manage noreturn function attributes and marks",
};
static const RzCmdDescArg type_list_noreturn_args[] = {
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_noreturn_help = {
	.summary = "List all noreturn references / Add a noreturn function",
	.args = type_list_noreturn_args,
};

static const RzCmdDescArg type_noreturn_del_args[] = {
	{
		.name = "name",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_ARRAY,

	},
	{ 0 },
};
static const RzCmdDescHelp type_noreturn_del_help = {
	.summary = "Remove the noreturn reference",
	.args = type_noreturn_del_args,
};

static const RzCmdDescArg type_noreturn_del_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_noreturn_del_all_help = {
	.summary = "Remove all noreturn references",
	.args = type_noreturn_del_all_args,
};

static const RzCmdDescHelp to_help = {
	.summary = "Open C header file and load types from it",
};
static const RzCmdDescArg type_open_file_args[] = {
	{
		.name = "file",
		.type = RZ_CMD_ARG_TYPE_FILE,

	},
	{ 0 },
};
static const RzCmdDescHelp type_open_file_help = {
	.summary = "Open C header file and load types from it",
	.args = type_open_file_args,
};

static const RzCmdDescArg type_open_editor_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_open_editor_help = {
	.summary = "Open cfg.editor to edit types",
	.args = type_open_editor_args,
};

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

	},
	{ 0 },
};
static const RzCmdDescHelp type_open_sdb_help = {
	.summary = "Open SDB file and load types from it",
	.args = type_open_sdb_args,
};

static const RzCmdDescHelp tp_help = {
	.summary = "Print formatted type casted to the address",
};
static const RzCmdDescArg type_print_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,

	},
	{
		.name = "address",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_print_help = {
	.summary = "Print formatted type casted to the address or variable",
	.args = type_print_args,
};

static const RzCmdDescArg type_print_value_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,

	},
	{
		.name = "value",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_print_value_help = {
	.summary = "Print formatted type casted to the value",
	.args = type_print_value_args,
};

static const RzCmdDescArg type_print_hexstring_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,

	},
	{
		.name = "hexpairs",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp type_print_hexstring_help = {
	.summary = "Print formatted type casted to the hexadecimal sequence",
	.args = type_print_hexstring_args,
};

static const RzCmdDescHelp ts_help = {
	.summary = "List loaded structures",
};
static const RzCmdDescArg type_list_structure_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRUCT_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_structure_help = {
	.summary = "List loaded structures / Show pf format string for given structure",
	.args = type_list_structure_args,
};

static const RzCmdDescArg type_structure_c_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRUCT_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_structure_c_help = {
	.summary = "Show structure in the C output format with newlines",
	.args = type_structure_c_args,
};

static const RzCmdDescArg type_structure_c_nl_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_STRUCT_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_structure_c_nl_help = {
	.summary = "Show structure in the C output format without newlines",
	.args = type_structure_c_nl_args,
};

static const RzCmdDescHelp tt_help = {
	.summary = "List loaded typedefs",
};
static const RzCmdDescArg type_list_typedef_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ALIAS_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_typedef_help = {
	.summary = "List loaded typedefs / Show name for given type alias",
	.args = type_list_typedef_args,
};

static const RzCmdDescArg type_typedef_c_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ALIAS_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_typedef_c_help = {
	.summary = "Show typedef in the C output format",
	.args = type_typedef_c_args,
};

static const RzCmdDescHelp tu_help = {
	.summary = "List loaded unions",
};
static const RzCmdDescArg type_list_union_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_UNION_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_list_union_help = {
	.summary = "List loaded unions / Show pf format string for given union",
	.args = type_list_union_args,
};

static const RzCmdDescArg type_union_c_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_UNION_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_union_c_help = {
	.summary = "Show union in the C output format with newlines",
	.args = type_union_c_args,
};

static const RzCmdDescArg type_union_c_nl_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_UNION_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_union_c_nl_help = {
	.summary = "Show union in the C output format without newlines",
	.args = type_union_c_nl_args,
};

static const RzCmdDescHelp tx_help = {
	.summary = "Type xrefs",
};
static const RzCmdDescArg type_xrefs_list_args[] = {
	{
		.name = "type",
		.type = RZ_CMD_ARG_TYPE_ANY_TYPE,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_xrefs_list_help = {
	.summary = "List functions using the type",
	.args = type_xrefs_list_args,
};

static const RzCmdDescArg type_xrefs_function_args[] = {
	{
		.name = "address",
		.type = RZ_CMD_ARG_TYPE_STRING,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.optional = true,

	},
	{ 0 },
};
static const RzCmdDescHelp type_xrefs_function_help = {
	.summary = "List all types used in the function",
	.args = type_xrefs_function_args,
};

static const RzCmdDescArg type_xrefs_graph_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_xrefs_graph_help = {
	.summary = "Render the type xrefs graph",
	.args = type_xrefs_graph_args,
};

static const RzCmdDescArg type_xrefs_list_all_args[] = {
	{ 0 },
};
static const RzCmdDescHelp type_xrefs_list_all_help = {
	.summary = "List all types used by any function",
	.args = type_xrefs_list_all_args,
};

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,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 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,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 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_help = {
	.summary = "Write data from file, socket, offset",
};
static const RzCmdDescArg write_from_io_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "size",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp write_from_io_help = {
	.summary = "Write <size> bytes from <addr> into current offset",
	.args = write_from_io_args,
};

static const RzCmdDescArg write_from_io_xchg_args[] = {
	{
		.name = "addr",
		.type = RZ_CMD_ARG_TYPE_RZNUM,

	},
	{
		.name = "size",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 0 },
};
static const RzCmdDescHelp write_from_io_xchg_help = {
	.summary = "Exchange <size> bytes between <addr> and current offset",
	.args = write_from_io_xchg_args,
};

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

	},
	{
		.name = "size",
		.type = RZ_CMD_ARG_TYPE_RZNUM,
		.optional = true,

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

	},
	{ 0 },
};
static const RzCmdDescHelp write_from_file_help = {
	.summary = "Write data from <file> into current offset",
	.args = write_from_file_args,
};

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

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

	},
	{ 0 },
};
static const RzCmdDescHelp write_from_socket_help = {
	.summary = "Write data from socket into current offset",
	.args = write_from_socket_args,
};

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,
		.default_value = "5",

	},
	{ 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,
		.default_value = "5",

	},
	{ 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,
		.flags = RZ_CMD_ARG_FLAG_LAST,
		.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,
		.flags = RZ_CMD_ARG_FLAG_LAST,

	},
	{ 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[] = {
	{ 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);
	rz_cmd_batch_start(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_oldhandler_cd = rz_cmd_desc_oldinput_new(core->rcmd, equal__cd, "=!", rz_io_system_run_oldhandler, &io_system_run_oldhandler_help);
	rz_warn_if_fail(io_system_run_oldhandler_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, "=r", 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, "=&r", rz_remote_rap_bg_handler, &remote_rap_bg_help);
	rz_warn_if_fail(remote_rap_bg_cd);

	RzCmdDesc *cmd_help_search_cd = rz_cmd_desc_argv_modes_new(core->rcmd, root_cd, "?*", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_cmd_help_search_handler, &cmd_help_search_help);
	rz_warn_if_fail(cmd_help_search_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_analysis_fcn_cd = rz_cmd_desc_oldinput_new(core->rcmd, cmd_analysis_cd, "af", rz_cmd_analysis_fcn, &cmd_analysis_fcn_help);
	rz_warn_if_fail(cmd_analysis_fcn_cd);
	RzCmdDesc *afb_cd = rz_cmd_desc_group_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afb", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET | RZ_OUTPUT_MODE_TABLE, rz_analysis_function_blocks_list_handler, &analysis_function_blocks_list_help, &afb_help);
	rz_warn_if_fail(afb_cd);
	RzCmdDesc *analysis_function_blocks_add_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afb+", rz_analysis_function_blocks_add_handler, &analysis_function_blocks_add_help);
	rz_warn_if_fail(analysis_function_blocks_add_cd);

	RzCmdDesc *analysis_function_blocks_del_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afb-", rz_analysis_function_blocks_del_handler, &analysis_function_blocks_del_help);
	rz_warn_if_fail(analysis_function_blocks_del_cd);

	RzCmdDesc *analysis_function_blocks_del_all_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afb-*", rz_analysis_function_blocks_del_all_handler, &analysis_function_blocks_del_all_help);
	rz_warn_if_fail(analysis_function_blocks_del_all_cd);

	RzCmdDesc *analysis_function_blocks_edge_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afbe", rz_analysis_function_blocks_edge_handler, &analysis_function_blocks_edge_help);
	rz_warn_if_fail(analysis_function_blocks_edge_cd);

	RzCmdDesc *analysis_function_returns_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afbr", rz_analysis_function_returns_handler, &analysis_function_returns_help);
	rz_warn_if_fail(analysis_function_returns_cd);

	RzCmdDesc *analysis_function_blocks_asciiart_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afb=", rz_analysis_function_blocks_asciiart_handler, &analysis_function_blocks_asciiart_help);
	rz_warn_if_fail(analysis_function_blocks_asciiart_cd);

	RzCmdDesc *analysis_function_blocks_info_cd = rz_cmd_desc_argv_modes_new(core->rcmd, afb_cd, "afbi", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_LONG | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET | RZ_OUTPUT_MODE_TABLE, rz_analysis_function_blocks_info_handler, &analysis_function_blocks_info_help);
	rz_warn_if_fail(analysis_function_blocks_info_cd);

	RzCmdDesc *analysis_function_blocks_color_cd = rz_cmd_desc_argv_new(core->rcmd, afb_cd, "afbc", rz_analysis_function_blocks_color_handler, &analysis_function_blocks_color_help);
	rz_warn_if_fail(analysis_function_blocks_color_cd);

	RzCmdDesc *analysis_function_setbits_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_fcn_cd, "afB", rz_analysis_function_setbits_handler, &analysis_function_setbits_help);
	rz_warn_if_fail(analysis_function_setbits_cd);

	RzCmdDesc *afs_cd = rz_cmd_desc_group_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afs", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_analysis_function_signature_handler, &analysis_function_signature_help, &afs_help);
	rz_warn_if_fail(afs_cd);
	RzCmdDesc *analysis_function_signature_editor_cd = rz_cmd_desc_argv_new(core->rcmd, afs_cd, "afs!", rz_analysis_function_signature_editor_handler, &analysis_function_signature_editor_help);
	rz_warn_if_fail(analysis_function_signature_editor_cd);

	RzCmdDesc *analysis_function_signature_type_cd = rz_cmd_desc_argv_new(core->rcmd, afs_cd, "afsr", rz_analysis_function_signature_type_handler, &analysis_function_signature_type_help);
	rz_warn_if_fail(analysis_function_signature_type_cd);

	RzCmdDesc *analysis_function_address_cd = rz_cmd_desc_argv_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afo", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_analysis_function_address_handler, &analysis_function_address_help);
	rz_warn_if_fail(analysis_function_address_cd);

	RzCmdDesc *analysis_function_until_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_fcn_cd, "afu", rz_analysis_function_until_handler, &analysis_function_until_help);
	rz_warn_if_fail(analysis_function_until_cd);

	RzCmdDesc *analysis_function_xrefs_cd = rz_cmd_desc_argv_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afx", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_analysis_function_xrefs_handler, &analysis_function_xrefs_help);
	rz_warn_if_fail(analysis_function_xrefs_cd);

	RzCmdDesc *analysis_function_stacksz_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_fcn_cd, "afS", rz_analysis_function_stacksz_handler, &analysis_function_stacksz_help);
	rz_warn_if_fail(analysis_function_stacksz_cd);

	RzCmdDesc *afv_cd = rz_cmd_desc_group_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afv", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_RIZIN, rz_analysis_function_vars_handler, &analysis_function_vars_help, &afv_help);
	rz_warn_if_fail(afv_cd);
	RzCmdDesc *analysis_function_vars_dis_refs_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afv=", rz_analysis_function_vars_dis_refs_handler, &analysis_function_vars_dis_refs_help);
	rz_warn_if_fail(analysis_function_vars_dis_refs_cd);

	RzCmdDesc *analysis_function_vars_del_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afv-", rz_analysis_function_vars_del_handler, &analysis_function_vars_del_help);
	rz_warn_if_fail(analysis_function_vars_del_cd);

	RzCmdDesc *analysis_function_vars_detect_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afva", rz_analysis_function_vars_detect_handler, &analysis_function_vars_detect_help);
	rz_warn_if_fail(analysis_function_vars_detect_cd);

	RzCmdDesc *analysis_function_vars_display_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvd", rz_analysis_function_vars_display_handler, &analysis_function_vars_display_help);
	rz_warn_if_fail(analysis_function_vars_display_cd);

	RzCmdDesc *analysis_function_vars_stackframe_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvf", rz_analysis_function_vars_stackframe_handler, &analysis_function_vars_stackframe_help);
	rz_warn_if_fail(analysis_function_vars_stackframe_cd);

	RzCmdDesc *analysis_function_vars_rename_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvn", rz_analysis_function_vars_rename_handler, &analysis_function_vars_rename_help);
	rz_warn_if_fail(analysis_function_vars_rename_cd);

	RzCmdDesc *analysis_function_vars_reads_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvR", rz_analysis_function_vars_reads_handler, &analysis_function_vars_reads_help);
	rz_warn_if_fail(analysis_function_vars_reads_cd);

	RzCmdDesc *analysis_function_vars_writes_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvW", rz_analysis_function_vars_writes_handler, &analysis_function_vars_writes_help);
	rz_warn_if_fail(analysis_function_vars_writes_cd);

	RzCmdDesc *analysis_function_vars_type_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvt", rz_analysis_function_vars_type_handler, &analysis_function_vars_type_help);
	rz_warn_if_fail(analysis_function_vars_type_cd);

	RzCmdDesc *analysis_function_vars_xrefs_cd = rz_cmd_desc_argv_modes_new(core->rcmd, afv_cd, "afvx", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_xrefs_handler, &analysis_function_vars_xrefs_help);
	rz_warn_if_fail(analysis_function_vars_xrefs_cd);

	RzCmdDesc *afvb_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvb", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_bp_handler, &analysis_function_vars_bp_help, &afvb_help);
	rz_warn_if_fail(afvb_cd);
	RzCmdDesc *analysis_function_vars_bp_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvb-", rz_analysis_function_vars_bp_del_handler, &analysis_function_vars_bp_del_help);
	rz_warn_if_fail(analysis_function_vars_bp_del_cd);

	RzCmdDesc *analysis_function_vars_bp_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvbg", rz_analysis_function_vars_bp_getref_handler, &analysis_function_vars_bp_getref_help);
	rz_warn_if_fail(analysis_function_vars_bp_getref_cd);

	RzCmdDesc *analysis_function_vars_bp_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvbs", rz_analysis_function_vars_bp_setref_handler, &analysis_function_vars_bp_setref_help);
	rz_warn_if_fail(analysis_function_vars_bp_setref_cd);

	RzCmdDesc *afvr_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvr", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_regs_handler, &analysis_function_vars_regs_help, &afvr_help);
	rz_warn_if_fail(afvr_cd);
	RzCmdDesc *analysis_function_vars_regs_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvr-", rz_analysis_function_vars_regs_del_handler, &analysis_function_vars_regs_del_help);
	rz_warn_if_fail(analysis_function_vars_regs_del_cd);

	RzCmdDesc *analysis_function_vars_regs_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvrg", rz_analysis_function_vars_regs_getref_handler, &analysis_function_vars_regs_getref_help);
	rz_warn_if_fail(analysis_function_vars_regs_getref_cd);

	RzCmdDesc *analysis_function_vars_regs_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvrs", rz_analysis_function_vars_regs_setref_handler, &analysis_function_vars_regs_setref_help);
	rz_warn_if_fail(analysis_function_vars_regs_setref_cd);

	RzCmdDesc *afvs_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvs", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_sp_handler, &analysis_function_vars_sp_help, &afvs_help);
	rz_warn_if_fail(afvs_cd);
	RzCmdDesc *analysis_function_vars_sp_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvs-", rz_analysis_function_vars_sp_del_handler, &analysis_function_vars_sp_del_help);
	rz_warn_if_fail(analysis_function_vars_sp_del_cd);

	RzCmdDesc *analysis_function_vars_sp_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvsg", rz_analysis_function_vars_sp_getref_handler, &analysis_function_vars_sp_getref_help);
	rz_warn_if_fail(analysis_function_vars_sp_getref_cd);

	RzCmdDesc *analysis_function_vars_sp_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvss", rz_analysis_function_vars_sp_setref_handler, &analysis_function_vars_sp_setref_help);
	rz_warn_if_fail(analysis_function_vars_sp_setref_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 *debug_continue_oldhandler_cd = rz_cmd_desc_oldinput_new(core->rcmd, cmd_debug_cd, "dc", rz_debug_continue_oldhandler, &debug_continue_oldhandler_help);
	rz_warn_if_fail(debug_continue_oldhandler_cd);

	RzCmdDesc *cmd_debug_step_cd = rz_cmd_desc_oldinput_new(core->rcmd, cmd_debug_cd, "ds", rz_cmd_debug_step, &cmd_debug_step_help);
	rz_warn_if_fail(cmd_debug_step_cd);
	RzCmdDesc *dsu_cd = rz_cmd_desc_group_new(core->rcmd, cmd_debug_step_cd, "dsu", rz_cmd_debug_step_until_handler, &cmd_debug_step_until_help, &dsu_help);
	rz_warn_if_fail(dsu_cd);
	RzCmdDesc *cmd_debug_step_until_instr_cd = rz_cmd_desc_argv_new(core->rcmd, dsu_cd, "dsui", rz_cmd_debug_step_until_instr_handler, &cmd_debug_step_until_instr_help);
	rz_warn_if_fail(cmd_debug_step_until_instr_cd);

	RzCmdDesc *cmd_debug_step_until_instr_regex_cd = rz_cmd_desc_argv_new(core->rcmd, dsu_cd, "dsuir", rz_cmd_debug_step_until_instr_regex_handler, &cmd_debug_step_until_instr_regex_help);
	rz_warn_if_fail(cmd_debug_step_until_instr_regex_cd);

	RzCmdDesc *cmd_debug_step_until_optype_cd = rz_cmd_desc_argv_new(core->rcmd, dsu_cd, "dsuo", rz_cmd_debug_step_until_optype_handler, &cmd_debug_step_until_optype_help);
	rz_warn_if_fail(cmd_debug_step_until_optype_cd);

	RzCmdDesc *cmd_debug_step_until_esil_cd = rz_cmd_desc_argv_new(core->rcmd, dsu_cd, "dsue", rz_cmd_debug_step_until_esil_handler, &cmd_debug_step_until_esil_help);
	rz_warn_if_fail(cmd_debug_step_until_esil_cd);

	RzCmdDesc *cmd_debug_step_until_flag_cd = rz_cmd_desc_argv_new(core->rcmd, dsu_cd, "dsuf", rz_cmd_debug_step_until_flag_handler, &cmd_debug_step_until_flag_help);
	rz_warn_if_fail(cmd_debug_step_until_flag_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_exit_cd = rz_cmd_desc_argv_new(core->rcmd, root_cd, "exit", rz_cmd_exit_handler, &cmd_exit_help);
	rz_warn_if_fail(cmd_exit_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 *q_cd = rz_cmd_desc_group_new(core->rcmd, root_cd, "q", rz_cmd_quit_handler, &cmd_quit_help, &q_help);
	rz_warn_if_fail(q_cd);
	RzCmdDesc *cmd_force_quit_cd = rz_cmd_desc_argv_new(core->rcmd, q_cd, "q!", rz_cmd_force_quit_handler, &cmd_force_quit_help);
	rz_warn_if_fail(cmd_force_quit_cd);

	RzCmdDesc *cmd_force_quit_without_history_cd = rz_cmd_desc_argv_new(core->rcmd, q_cd, "q!!", rz_cmd_force_quit_without_history_handler, &cmd_force_quit_without_history_help);
	rz_warn_if_fail(cmd_force_quit_without_history_cd);

	RzCmdDesc *quit_with_preference_cd = rz_cmd_desc_inner_new(core->rcmd, q_cd, "q", &quit_with_preference_help);
	rz_warn_if_fail(quit_with_preference_cd);
	RzCmdDesc *qy_cd = rz_cmd_desc_group_new(core->rcmd, quit_with_preference_cd, "qy", NULL, NULL, &qy_help);
	rz_warn_if_fail(qy_cd);
	RzCmdDesc *quit_kill_save_cd = rz_cmd_desc_argv_new(core->rcmd, qy_cd, "qyy", rz_quit_kill_save_handler, &quit_kill_save_help);
	rz_warn_if_fail(quit_kill_save_cd);

	RzCmdDesc *quit_kill_nosave_cd = rz_cmd_desc_argv_new(core->rcmd, qy_cd, "qyn", rz_quit_kill_nosave_handler, &quit_kill_nosave_help);
	rz_warn_if_fail(quit_kill_nosave_cd);

	RzCmdDesc *qn_cd = rz_cmd_desc_group_new(core->rcmd, quit_with_preference_cd, "qn", NULL, NULL, &qn_help);
	rz_warn_if_fail(qn_cd);
	RzCmdDesc *quit_nokill_nosave_cd = rz_cmd_desc_argv_new(core->rcmd, qn_cd, "qnn", rz_quit_nokill_nosave_handler, &quit_nokill_nosave_help);
	rz_warn_if_fail(quit_nokill_nosave_cd);

	RzCmdDesc *quit_nokill_save_cd = rz_cmd_desc_argv_new(core->rcmd, qn_cd, "qny", rz_quit_nokill_save_handler, &quit_nokill_save_help);
	rz_warn_if_fail(quit_nokill_save_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, "spad", 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 *t_cd = rz_cmd_desc_group_modes_new(core->rcmd, root_cd, "t", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_type_handler, &type_help, &t_help);
	rz_warn_if_fail(t_cd);
	RzCmdDesc *type_del_cd = rz_cmd_desc_argv_new(core->rcmd, t_cd, "t-", rz_type_del_handler, &type_del_help);
	rz_warn_if_fail(type_del_cd);

	RzCmdDesc *type_del_all_cd = rz_cmd_desc_argv_new(core->rcmd, t_cd, "t-*", rz_type_del_all_handler, &type_del_all_help);
	rz_warn_if_fail(type_del_all_cd);

	RzCmdDesc *tc_cd = rz_cmd_desc_group_new(core->rcmd, t_cd, "tc", rz_type_list_c_handler, &type_list_c_help, &tc_help);
	rz_warn_if_fail(tc_cd);
	RzCmdDesc *type_list_c_nl_cd = rz_cmd_desc_argv_new(core->rcmd, tc_cd, "tcd", rz_type_list_c_nl_handler, &type_list_c_nl_help);
	rz_warn_if_fail(type_list_c_nl_cd);

	RzCmdDesc *tcc_cd = rz_cmd_desc_group_modes_new(core->rcmd, tc_cd, "tcc", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_LONG | RZ_OUTPUT_MODE_SDB | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_type_cc_list_handler, &type_cc_list_help, &tcc_help);
	rz_warn_if_fail(tcc_cd);
	RzCmdDesc *type_cc_del_cd = rz_cmd_desc_argv_new(core->rcmd, tcc_cd, "tcc-", rz_type_cc_del_handler, &type_cc_del_help);
	rz_warn_if_fail(type_cc_del_cd);

	RzCmdDesc *type_cc_del_all_cd = rz_cmd_desc_argv_new(core->rcmd, tcc_cd, "tcc-*", rz_type_cc_del_all_handler, &type_cc_del_all_help);
	rz_warn_if_fail(type_cc_del_all_cd);

	RzCmdDesc *type_define_cd = rz_cmd_desc_argv_new(core->rcmd, t_cd, "td", rz_type_define_handler, &type_define_help);
	rz_warn_if_fail(type_define_cd);

	RzCmdDesc *te_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "te", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_SDB, rz_type_list_enum_handler, &type_list_enum_help, &te_help);
	rz_warn_if_fail(te_cd);
	RzCmdDesc *type_enum_bitfield_cd = rz_cmd_desc_argv_new(core->rcmd, te_cd, "teb", rz_type_enum_bitfield_handler, &type_enum_bitfield_help);
	rz_warn_if_fail(type_enum_bitfield_cd);

	RzCmdDesc *type_enum_c_cd = rz_cmd_desc_argv_new(core->rcmd, te_cd, "tec", rz_type_enum_c_handler, &type_enum_c_help);
	rz_warn_if_fail(type_enum_c_cd);

	RzCmdDesc *type_enum_c_nl_cd = rz_cmd_desc_argv_new(core->rcmd, te_cd, "ted", rz_type_enum_c_nl_handler, &type_enum_c_nl_help);
	rz_warn_if_fail(type_enum_c_nl_cd);

	RzCmdDesc *type_enum_find_cd = rz_cmd_desc_argv_new(core->rcmd, te_cd, "tef", rz_type_enum_find_handler, &type_enum_find_help);
	rz_warn_if_fail(type_enum_find_cd);

	RzCmdDesc *tf_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "tf", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_SDB, rz_type_list_function_handler, &type_list_function_help, &tf_help);
	rz_warn_if_fail(tf_cd);

	RzCmdDesc *type_kuery_cd = rz_cmd_desc_argv_new(core->rcmd, t_cd, "tk", rz_type_kuery_handler, &type_kuery_help);
	rz_warn_if_fail(type_kuery_cd);

	RzCmdDesc *tl_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "tl", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_SDB | RZ_OUTPUT_MODE_LONG, rz_type_link_handler, &type_link_help, &tl_help);
	rz_warn_if_fail(tl_cd);
	RzCmdDesc *type_link_show_cd = rz_cmd_desc_argv_new(core->rcmd, tl_cd, "tls", rz_type_link_show_handler, &type_link_show_help);
	rz_warn_if_fail(type_link_show_cd);

	RzCmdDesc *type_link_del_cd = rz_cmd_desc_argv_new(core->rcmd, tl_cd, "tl-", rz_type_link_del_handler, &type_link_del_help);
	rz_warn_if_fail(type_link_del_cd);

	RzCmdDesc *type_link_del_all_cd = rz_cmd_desc_argv_new(core->rcmd, tl_cd, "tl-*", rz_type_link_del_all_handler, &type_link_del_all_help);
	rz_warn_if_fail(type_link_del_all_cd);

	RzCmdDesc *tn_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "tn", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN, rz_type_list_noreturn_handler, &type_list_noreturn_help, &tn_help);
	rz_warn_if_fail(tn_cd);
	RzCmdDesc *type_noreturn_del_cd = rz_cmd_desc_argv_new(core->rcmd, tn_cd, "tn-", rz_type_noreturn_del_handler, &type_noreturn_del_help);
	rz_warn_if_fail(type_noreturn_del_cd);

	RzCmdDesc *type_noreturn_del_all_cd = rz_cmd_desc_argv_new(core->rcmd, tn_cd, "tn-*", rz_type_noreturn_del_all_handler, &type_noreturn_del_all_help);
	rz_warn_if_fail(type_noreturn_del_all_cd);

	RzCmdDesc *to_cd = rz_cmd_desc_group_new(core->rcmd, t_cd, "to", rz_type_open_file_handler, &type_open_file_help, &to_help);
	rz_warn_if_fail(to_cd);
	RzCmdDesc *type_open_editor_cd = rz_cmd_desc_argv_new(core->rcmd, to_cd, "toe", rz_type_open_editor_handler, &type_open_editor_help);
	rz_warn_if_fail(type_open_editor_cd);

	RzCmdDesc *type_open_sdb_cd = rz_cmd_desc_argv_new(core->rcmd, to_cd, "tos", rz_type_open_sdb_handler, &type_open_sdb_help);
	rz_warn_if_fail(type_open_sdb_cd);

	RzCmdDesc *tp_cd = rz_cmd_desc_group_new(core->rcmd, t_cd, "tp", rz_type_print_handler, &type_print_help, &tp_help);
	rz_warn_if_fail(tp_cd);
	RzCmdDesc *type_print_value_cd = rz_cmd_desc_argv_new(core->rcmd, tp_cd, "tpv", rz_type_print_value_handler, &type_print_value_help);
	rz_warn_if_fail(type_print_value_cd);

	RzCmdDesc *type_print_hexstring_cd = rz_cmd_desc_argv_new(core->rcmd, tp_cd, "tpx", rz_type_print_hexstring_handler, &type_print_hexstring_help);
	rz_warn_if_fail(type_print_hexstring_cd);

	RzCmdDesc *ts_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "ts", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_type_list_structure_handler, &type_list_structure_help, &ts_help);
	rz_warn_if_fail(ts_cd);
	RzCmdDesc *type_structure_c_cd = rz_cmd_desc_argv_new(core->rcmd, ts_cd, "tsc", rz_type_structure_c_handler, &type_structure_c_help);
	rz_warn_if_fail(type_structure_c_cd);

	RzCmdDesc *type_structure_c_nl_cd = rz_cmd_desc_argv_new(core->rcmd, ts_cd, "tsd", rz_type_structure_c_nl_handler, &type_structure_c_nl_help);
	rz_warn_if_fail(type_structure_c_nl_cd);

	RzCmdDesc *tt_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "tt", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_type_list_typedef_handler, &type_list_typedef_help, &tt_help);
	rz_warn_if_fail(tt_cd);
	RzCmdDesc *type_typedef_c_cd = rz_cmd_desc_argv_new(core->rcmd, tt_cd, "ttc", rz_type_typedef_c_handler, &type_typedef_c_help);
	rz_warn_if_fail(type_typedef_c_cd);

	RzCmdDesc *tu_cd = rz_cmd_desc_group_modes_new(core->rcmd, t_cd, "tu", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_type_list_union_handler, &type_list_union_help, &tu_help);
	rz_warn_if_fail(tu_cd);
	RzCmdDesc *type_union_c_cd = rz_cmd_desc_argv_new(core->rcmd, tu_cd, "tuc", rz_type_union_c_handler, &type_union_c_help);
	rz_warn_if_fail(type_union_c_cd);

	RzCmdDesc *type_union_c_nl_cd = rz_cmd_desc_argv_new(core->rcmd, tu_cd, "tud", rz_type_union_c_nl_handler, &type_union_c_nl_help);
	rz_warn_if_fail(type_union_c_nl_cd);

	RzCmdDesc *tx_cd = rz_cmd_desc_group_new(core->rcmd, t_cd, "tx", rz_type_xrefs_list_handler, &type_xrefs_list_help, &tx_help);
	rz_warn_if_fail(tx_cd);
	RzCmdDesc *type_xrefs_function_cd = rz_cmd_desc_argv_new(core->rcmd, tx_cd, "txf", rz_type_xrefs_function_handler, &type_xrefs_function_help);
	rz_warn_if_fail(type_xrefs_function_cd);

	RzCmdDesc *type_xrefs_graph_cd = rz_cmd_desc_argv_new(core->rcmd, tx_cd, "txg", rz_type_xrefs_graph_handler, &type_xrefs_graph_help);
	rz_warn_if_fail(type_xrefs_graph_cd);

	RzCmdDesc *type_xrefs_list_all_cd = rz_cmd_desc_argv_new(core->rcmd, tx_cd, "txl", rz_type_xrefs_list_all_handler, &type_xrefs_list_all_help);
	rz_warn_if_fail(type_xrefs_list_all_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_cd = rz_cmd_desc_group_new(core->rcmd, w_cd, "wf", rz_write_from_io_handler, &write_from_io_help, &wf_help);
	rz_warn_if_fail(wf_cd);
	RzCmdDesc *write_from_io_xchg_cd = rz_cmd_desc_argv_new(core->rcmd, wf_cd, "wfx", rz_write_from_io_xchg_handler, &write_from_io_xchg_help);
	rz_warn_if_fail(write_from_io_xchg_cd);

	RzCmdDesc *write_from_file_cd = rz_cmd_desc_argv_new(core->rcmd, wf_cd, "wff", rz_write_from_file_handler, &write_from_file_help);
	rz_warn_if_fail(write_from_file_cd);

	RzCmdDesc *write_from_socket_cd = rz_cmd_desc_argv_new(core->rcmd, wf_cd, "wfs", rz_write_from_socket_handler, &write_from_socket_help);
	rz_warn_if_fail(write_from_socket_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);
	rz_cmd_batch_end(core->rcmd);
}
