Module idaapi

Classes
	Appcall__
	Appcall_array__ This class is used with Appcall.array() method
	Appcall_callable__ Helper class to issue appcalls using a natural syntax:...
	Appcall_consts__ Helper class used by Appcall.Consts attribute It is used to retrieve constants via attribute access
	BasicBlock Basic block class.
	Choose Choose - class for choose() with callbacks
	Choose2 Choose2 wrapper class.
	DBG_Hooks Proxy of C++ DBG_Hooks class
	FlowChart Flowchart class used to determine basic blocks.
	Form
	GraphViewer This class wraps the user graphing facility provided by the graph.hpp file
	IDB_Hooks Proxy of C++ IDB_Hooks class
	IDP_Hooks Proxy of C++ IDP_Hooks class
	NearestName Utility class to help find the nearest name in a given ea/name dictionary
	PluginForm PluginForm class.
	PyIdc_cvt_int64__ Helper class for explicitly representing VT_INT64 values
	PyIdc_cvt_refclass__ Helper class for representing references to immutable objects
	UI_Hooks Proxy of C++ UI_Hooks class
	addon_info_t Proxy of C++ addon_info_t class
	area_t Proxy of C++ area_t class
	area_visitor2_t Proxy of C++ area_visitor2_t class
	areacb_t Proxy of C++ areacb_t class
	areaset_t Proxy of C++ areaset_t class
	areavec_t Proxy of C++ areavec_t class
	asm_t Proxy of C++ asm_t class
	auto_display_t Proxy of C++ auto_display_t class
	bgcolors_t Proxy of C++ bgcolors_t class
	bpt_location_t Proxy of C++ bpt_location_t class
	bpt_t Proxy of C++ bpt_t class
	call_stack_info_t Proxy of C++ call_stack_info_t class
	call_stack_t Proxy of C++ call_stack_t class
	channel_redir_t Proxy of C++ channel_redir_t class
	cli_t cli_t wrapper class.
	compiler_info_t Proxy of C++ compiler_info_t class
	curloc Proxy of C++ curloc class
	data_format_t Information about a data format
	data_type_t Custom data type definition.
	debug_event_t Proxy of C++ debug_event_t class
	e_breakpoint_t Proxy of C++ e_breakpoint_t class
	e_exception_t Proxy of C++ e_exception_t class
	ea_array Proxy of C++ ea_array class
	ea_name_t Proxy of C++ ea_name_t class
	ea_pointer Proxy of C++ ea_pointer class
	enum_const_t Proxy of C++ enum_const_t class
	enum_member_visitor_t Proxy of C++ enum_member_visitor_t class
	exception_info_t Proxy of C++ exception_info_t class
	fixup_data_t Proxy of C++ fixup_data_t class
	func_item_iterator_t Proxy of C++ func_item_iterator_t class
	func_parent_iterator_t Proxy of C++ func_parent_iterator_t class
	func_t Proxy of C++ func_t class
	func_tail_iterator_t Proxy of C++ func_tail_iterator_t class
	func_type_info_t Proxy of C++ func_type_info_t class
	funcarg_info_t Proxy of C++ funcarg_info_t class
	generic_linput_t Proxy of C++ generic_linput_t class
	get_strmem_t Proxy of C++ get_strmem_t class
	graph_location_info_t Proxy of C++ graph_location_info_t class
	hidden_area_t Proxy of C++ hidden_area_t class
	ida_false_type Proxy of C++ ida_false_type class
	ida_true_type Proxy of C++ ida_true_type class
	idainfo Proxy of C++ idainfo class
	idc_global_t Proxy of C++ idc_global_t class
	idc_value_t Proxy of C++ idc_value_t class
	insn_t Class representing instructions
	int_pointer Proxy of C++ int_pointer class
	llabel_t Proxy of C++ llabel_t class
	loader_input_t Proxy of C++ loader_input_t class
	loader_t Proxy of C++ loader_t class
	location_t Proxy of C++ location_t class
	lock_area Proxy of C++ lock_area class
	lock_func Proxy of C++ lock_func class
	lock_segment Proxy of C++ lock_segment class
	lock_segreg Proxy of C++ lock_segreg class
	member_t Proxy of C++ member_t class
	module_info_t Proxy of C++ module_info_t class
	netnode Proxy of C++ netnode class
	node_iterator Proxy of C++ node_iterator class
	object_t Helper class used to initialize empty objects
	op_t Class representing operands
	opinfo_t Proxy of C++ opinfo_t class
	plugin_t Base class for all scripted plugins.
	process_info_t Proxy of C++ process_info_t class
	processor_t Base class for all processor module scripts
	py_clinked_object_t This is a utility and base class for C linked objects
	pyidc_cvt_helper__ This is a special helper object that helps detect which kind of object is this python object wrapping and how to convert it back and from IDC.
	pyidc_opaque_object_t This is the base class for all Python<->IDC opaque objects
	qbasic_block_t Proxy of C++ qbasic_block_t class
	qfile_t Proxy of C++ qfile_t class
	qflow_chart_t Proxy of C++ qflow_chart_t class
	qrefcnt_obj_t Proxy of C++ qrefcnt_obj_t class
	qstrvec_t Class representing an qstrvec_t
	refinfo_t Proxy of C++ refinfo_t class
	reg_info_t Proxy of C++ reg_info_t class
	regarg_t Proxy of C++ regarg_t class
	regobjs_t Proxy of C++ regobjs_t class
	regval_t Proxy of C++ regval_t class
	regvar_t Proxy of C++ regvar_t class
	segment_t Proxy of C++ segment_t class
	segreg_t Proxy of C++ segreg_t class
	sel_array Proxy of C++ sel_array class
	sel_pointer Proxy of C++ sel_pointer class
	simplecustviewer_t The base class for implementing simple custom viewers
	stkpnt_t Proxy of C++ stkpnt_t class
	strarray_t Proxy of C++ strarray_t class
	string_info_t Proxy of C++ string_info_t class
	strpath_t Proxy of C++ strpath_t class
	struc_t Proxy of C++ struc_t class
	struct_field_visitor_t Proxy of C++ struct_field_visitor_t class
	strwinsetup_t Proxy of C++ strwinsetup_t class
	sval_pointer Proxy of C++ sval_pointer class
	switch_info_ex_t
	tev_info_t Proxy of C++ tev_info_t class
	text_options_t Proxy of C++ text_options_t class
	textctrl_info_t Class representing textctrl_info_t
	tid_array Proxy of C++ tid_array class
	til_symbol_t Proxy of C++ til_symbol_t class
	til_t Proxy of C++ til_t class
	type_names_t Proxy of C++ type_names_t class
	type_pair_t Proxy of C++ type_pair_t class
	type_pair_vec_t Proxy of C++ type_pair_vec_t class
	type_visitor_t Proxy of C++ type_visitor_t class
	uchar_array Proxy of C++ uchar_array class
	uval_array Proxy of C++ uval_array class
	xrefblk_t Proxy of C++ xrefblk_t class

Functions

AskUsingForm(*args)
Calls the AskUsingForm()

PyObject

AssembleLine(ea, cs, ip, use32, line)
Assemble an instruction to a string (display a warning if an error is found)

COLSTR(str, tag)
Utility function to create a colored line

bool

Compile(file)

bool

CompileEx(file, del_macros)

bool

CompileLine(line)

ExtraDel(ea, what)

ssize_t

ExtraGet(ea, what)

ExtraUpdate(ea, str, what)

IDAPython_ExecScript(script, g)
Run the specified script.

IDAPython_ExecSystem(cmd)
Executes a command with popen().

IDAPython_FormatExc(etype, value, tb, limit=None)
This function is used to format an exception given the values returned by a PyErr_Fetch()

bool

InstrIsSet(icode, bit)

bool

MakeBorder()

bool

MakeLine(contents, indent= -1)

bool

MakeNull()

bool

MakeSolidBorder()

OutBadInstruction()

OutChar(c)

OutImmChar(x)
Output operand value as a commented character constant

OutLine(s)

OutLong(Word, radix)

int

OutMnem(width= 8, postfix= None)

flags_t

OutValue(x, outflags= 0)
Output immediate value

ssize_t

QueueGetMessage(t, ea)

ea_t

QueueGetType(type, lowea)

bool

QueueIsPresent(t, ea)

QueueSet(*args)
QueueSet(type, ea, $ignore = None)

bool

SetDefaultRegisterValue(sg, rg, value)

error_t

VarAssign(dst, src)

error_t

VarCopy(dst, src)

error_t

VarDelAttr(obj, attr)

idc_value_t

VarDeref(v, vref_flags)

char

VarFirstAttr(obj)

error_t

VarGetAttr(obj, attr, res, may_use_getattr= False)

error_t

VarGetClassName(obj, name)

error_t

VarGetSlice(v, i1, i2, res, flags= 0)

error_t

VarInt64(v)

char

VarLastAttr(obj)

error_t

VarMove(dst, src)

char

VarNextAttr(obj, attr)

error_t

VarObject(v, icls= None)

char

VarPrevAttr(obj, attr)

VarPrint(out, v, name= None, indent= 0)

bool

VarRef(ref, v)

error_t

VarSetAttr(obj, attr, value, may_use_setattr= False)

error_t

VarSetSlice(v, i1, i2, _in, flags= 0)

error_t

VarString2(v)

VarSwap(v1, v2)

char

a2funcoff(ea)

bool

add_auto_stkpnt2(pfn, ea, delta)

bool

add_bpt(ea, size, type)
add_bpt(bpt) -> bool

add_byte(ea, value)

bool

add_chooser_command(chooser_caption, cmd_caption, chooser_cb, menu_index= -1, icon= -1, flags= 0)
add_chooser_command(chooser_caption, cmd_caption, chooser_cb, hotkey, menu_index = -1,...

bool

add_cref(frm, to, type)

bool

add_dref(frm, to, type)

int

add_encoding(encoding)

bool

add_entry(ord, ea, name, makecode)

enum_t

add_enum(idx, name, flag)

int

add_enum_member(id, name, value, bmask= (bmask_t(-1)))

bool

add_frame(pfn, frsize, frregs, argsize)

bool

add_func(ea1, ea2)

bool

add_func_ex(fn)

bool

add_hidden_area(ea1, ea2, description, header, footer, color)

PyObject

add_hotkey(hotkey, pyfunc)
Associates a function call with a hotkey.

idc_class_t

add_idc_class(name, super= None)

idc_value_t

add_idc_gvar(name)

int

add_idc_hotkey(hotkey, idcfunc)

add_long(ea, value)

add_long_cmt(ea, isprev, format, *args)

PyObject

add_menu_item(menupath, name, hotkey, flags, pyfunc, args)
Adds a menu item

add_pgm_cmt(format, *args)

add_qword(ea, value)

add_regarg(pfn, reg, type, name)

int

add_regvar(pfn, ea1, ea2, canon, user, cmt)

int

add_segm(para, start, end, name, sclass)

int

add_segm_ex(s, name, sclass, flags)

bool

add_segment_translation(segstart, mappedseg)

bool

add_sourcefile(ea1, ea2, filename)

bool

add_stkvar2(pfn, name, off, flags, ti, nbytes)

bool

add_stkvar3(py_op, py_v, flags)
Automatically add stack variable if doesn't exist Processor modules should use ua_stkvar2()

tid_t

add_struc(idx, name, is_union= False)

int

add_struc_member(sptr, fieldname, offset, flag, mt, nbytes)

int

add_til2(name, flags)

bool

add_user_stkpnt(ea, delta)

bool

add_virt_module(mod)

add_word(ea, value)

int

addon_count()

flags_t

alignflag()

uint32

alloc_type_ordinal(ti)

uint32

alloc_type_ordinals(ti, qty)

sel_t

allocate_selector(segbase)

int

analyze_area(sEA, eEA)

analyzer_options()

char

ansi2idb(name)

PyObject

appcall(func_ea, tid, py_type, py_fields, arg_list)

bool

append_cmt(ea, str, rptble)

bool

append_da(type, n1, n2)

bool

append_de(type, n)

bool

append_dt(type, n)

bool

append_func_tail(pfn, ea1, ea2)

bool

append_name(fields, name)

bool

apply_cdecl2(til, ea, decl, flags= 0)

bool

apply_idasgn(advance)

int

apply_idasgn_to(signame, ea, is_startup)

bool

apply_named_type(ea, name)

bool

apply_once_type_and_name(ea, type, name)

bool

apply_startup_sig(ea, startup)

bool

apply_tinfo(til, ea, type, fields, flags)

bool

apply_type_to_stkarg(py_op, py_uv, py_type, name)
Apply type information to a stack variable

size_t

area_t_print(cb)

as_cstr(val)
Returns a C str from the passed value.

as_int32(v)
Returns a number as a signed int32 number

as_signed(v, nbits=32)
Returns a number as signed.

as_uint32(v)
Returns a number as an unsigned int32 number

as_unicode(s)
Convenience function to convert a string into appropriate unicode format

flags_t

asciflag()

ask_for_feedback(format, *args)

ea_t

ask_selector(selector)

askaddr(defval, format)

int

askbuttons_c(Yes, No, Cancel, deflt, format, *args)

char

askfile_c(savefile, defval, format, *args)

char

askident(defval, format, *args)

asklong(defval, format)

askseg(defval, format)

char

askstr(hist, defval, format, *args)

PyObject

asktext(max_text, defval, prompt)
Asks for a long text

int

askyn_c(deflt, format, *args)

bool

assemble(ea, cs, ip, use32, line)
Assemble an instruction into the database (display a warning if an error is found)

int

attach_process(pid, event_id)

autoCancel(ea1, ea2)

char

autoGetName(type)

bool

autoIsOk()

autoMark(ea, type)

bool

autoStep()

autoUnmark(start, end, type)

bool

autoWait()

auto_apply_type(caller, callee)

ea_t

auto_get(lowEA, highEA, type)

auto_make_code(ea)

auto_make_proc(ea)

auto_mark_range(start, end, type)

bool

banner(wait)

int

base2file(fp, pos, ea1, ea2)

beep(beep_type= beep_default)

begin_type_updating(utp)

ea_t

bin_search(startEA, endEA, image, mask, len, step, flags)

flags_t

binflag()

flags_t

bnot_data_flag()

bring_debugger_to_front()

bool

build_array_type(outtype, type, size)

bool

build_func_type2(ti, p_type, p_fields, fi)

int

build_funcarg_info(til, type, fields, info, bfi_flags)

char

build_stkvar_name(pfn, v)

flags_t

byteflag()

int

bytesize(ea)

int

calc_argloc_info(til, type, arglocs, maxn)

bgcolor_t

calc_bg_color(ea)

int

calc_def_align(ea, mina, maxa)

int

calc_default_idaplace_flags()

int

calc_func_nargs(til, type)

int

calc_idasgn_state(n)

bool

calc_idc_expr(where, line, rv)

int

calc_max_align(endea)

ea_t

calc_max_item_end(ea, how= 15)

int

calc_min_align(length)

color_t

calc_prefix_color(ea)

ea_t

calc_probable_base_by_value(ea, off)

int

calc_purged_bytes(type)

ea_t

calc_reference_basevalue(frm, ri, opval, target)

ea_t

calc_reference_target(frm, ri, opval)

ea_t

calc_stkvar_struc_offset(pfn, ea, n)

bool

calc_switch_cases(insn_ea, si, casevec, targets)

ea_t

calc_target(frm, ea, n, opval)

ea_t

calc_thunk_func_target(fn, fptr)

bool

calcexpr(where, line, rv)

bool

call_idc_method(obj, name, nargs, args, result)

bool

call_script_method(obj, name, nargs, args, result)

int

call_system(command)

ea_t

can_be_off32(ea)

bool

can_define_item(ea, length, flags)

bool

can_exc_continue(ev)

bool

change_encoding_name(idx, encoding)

int

change_segment_status(s, is_deb_segm)

error_t

change_storage_type(startEA, endEA, stt)

flags_t

charflag()

int

check_bpt(ea)

bool

check_skip_type(ti, ptr)

bool

check_type_trait(arg0)
check_type_trait(arg0) -> bool

choose2_activate(self)

int

choose2_add_command(self, caption, flags, menu_index, icon)

choose2_close(self)

int

choose2_create(self, embedded)

PyObject

choose2_find(title)

PyObject

choose2_get_embedded(self)

PyObject

choose2_get_embedded_selection(self)

choose2_refresh(self)

uint32

choose_choose(self, flags, x0, y0, x1, y1, width, deflt, icon)
choose_choose(self, flags, x0, y0, x1, y1, width, deflt, icon) -> uint32

choose_enter(self, n)

ea_t

choose_entry(title)

enum_t

choose_enum(title, default_id)

enum_t

choose_enum_by_value(title, default_id, value)

func_t

choose_func(title, default_ea)

char

choose_getl(self, n, buf)

PyObject

choose_idasgn()
Opens the signature chooser

uint32

choose_local_type(ti, title, func, ud)

ea_t

choose_name(title)

bool

choose_named_type2(root_til, title, ntf_flags, func, sym)

segment_t

choose_segm(title, default_ea)

segreg_t

choose_segreg(title)

uint32

choose_sizer(self)

ea_t

choose_stkvar_xref(pfn, mptr)

struc_t

choose_struc(title)

bool

choose_til()

bool

choose_trace_file()

ea_t

choose_xref(to)

asize_t

chunksize(ea)

ea_t

chunkstart(ea)

error_t

cleanup_appcall(tid)

clearBreak()

clear_func_struct(fn)

clear_requests_queue()

clear_trace()

bool

close_chooser(title)

close_linput(li)

close_tform(form, options)

clr_abits(ea, bits)

bool

clr_lzero(ea, n)

ea_t

codeSeg(addr, opnum)

flags_t

codeflag()

bool

compact_til(ti)

bool

compile_script_file(file)

bool

compile_script_func(name, current_ea, expr)

int

contains_fixups(ea, size)

bool

continue_process()

int

convert_encoding(fromcode, tocode, indata, out, flags= 0)

copy_bits(v, s, e=-1)
Copy bits from a value

TCustomControl

create_code_viewer(parent, custview, flags= 0)

linput_t

create_generic_linput(gl)

int

create_insn(ea)

linput_t

create_memory_linput(start, size)

size_t

create_numbered_type_name(ord)

source_view_t

create_source_viewer(parent, custview, sf, lines, lnnum, colnum, flags)

bool

create_switch_table(insn_ea, py_swi)
Create switch table from the switch information

bool

create_switch_xrefs(insn_ea, py_swi)
This function creates xrefs from the indirect jump.

TForm

create_tform(caption, handle)

flags_t

custflag()

flags_t

custfmtflag()

ea_t

dataSeg()

ea_t

dataSeg_op(opnum)

ea_t

dataSeg_opreg(opnum, rgnum)

bool

dbg_can_query()
This function can be used to check if the debugger can be queried:

ssize_t

dbg_get_input_path()

PyObject

dbg_get_memory_info()
This function returns the memory configuration of a debugged process.

PyObject

dbg_get_name()
This function returns the current debugger's name.

PyObject

dbg_get_registers()
This function returns the register definition from the currently loaded debugger.

PyObject

dbg_get_thread_sreg_base(py_tid, py_sreg_value)
Returns the segment register base value

bool

dbg_is_loaded()
Checks if a debugger is loaded

PyObject

dbg_read_memory(py_ea, py_sz)
Reads from the debugee's memory at the specified ea

PyObject

dbg_write_memory(py_ea, py_buf)
Writes a buffer to the debugee's memory

flags_t

decflag()

int

decode_insn(ea)

PyObject

decode_preceding_insn(ea)
Decodes the preceding instruction.

ea_t

decode_prev_insn(ea)

comp_t

default_compiler()

char

define_exception(code, name, desc, flags)

delValue(ea)

del_aflags(ea)

del_aflags0(ea)

bool

del_bpt(ea)
del_bpt(bptloc) -> bool

int

del_cref(frm, to, expand)

del_debug_names(ea1, ea2)

del_dref(frm, to)

bool

del_encoding(idx)

del_enum(id)

bool

del_enum_member(id, value, serial, bmask)

del_fixup(source)

bool

del_frame(pfn)

bool

del_func(ea)

del_func_cmt(fn, repeatable)

bool

del_global_name(ea)

bool

del_hidden_area(ea)

bool

del_hotkey(pyctx)
Deletes a previously registered function hotkey

int

del_idasgn(n)

bool

del_idc_hotkey(hotkey)

del_item_color(ea)

bool

del_local_name(ea)

bool

del_member_tinfo(sptr, mptr)

bool

del_menu_item(py_ctx)
Deletes a menu item previously added with add_menu_item()

bool

del_named_type(ti, name, ntf_flags)

bool

del_numbered_type(ti, ordinal)

int

del_refinfo(ea, n)

int

del_regvar(pfn, ea1, ea2, canon)

int

del_segm(ea, flags)

del_segment_cmt(s, repeatable)

bool

del_segment_translations(ea)

del_selector(selector)

del_source_linnum(ea)

bool

del_sourcefile(ea)

bool

del_stkpnt(pfn, ea)

bool

del_stroff_path(ea, n)

bool

del_struc(sptr)

bool

del_struc_member(sptr, offset)

int

del_struc_members(sptr, off1, off2)

del_switch_info_ex(ea)
Deletes stored switch information

bool

del_til(name)

bool

del_virt_module(base)

bool

del_xml(path)

int

delete_unreferenced_stkvars(pfn)

int

delete_wrong_stkvar_ops(pfn)

int32

demangle_name(name, disable_mask)

bool

deref_ptr(ti, type, ptr_ea, closure_obj= None)

describe(ea, isprev, format, *args)

bool

detach_process()

bool

diff_trace_file(filename)

error_t

disable_flags(startEA, endEA)

disable_script_timeout()
Disables the script timeout and hides the script wait box.

bool

display_copyright_warning()

int

display_gdl(fname)

bool

do16bit(ea, length)

bool

do32bit(ea, length)

bool

do3byte(ea, length)

bool

doASCI(ea, length)

bool

doAlign(ea, length, alignment)

bool

doByte(ea, length)

bool

doCustomData(ea, length, dtid, fid)

bool

doDouble(ea, length)

bool

doDwrd(ea, length)

bool

doFloat(ea, length)

bool

doImmd(ea)

bool

doOwrd(ea, length)

bool

doPackReal(ea, length)

bool

doQwrd(ea, length)

bool

doStruct(ea, length, tid)

bool

doTbyt(ea, length)

doVar(ea, isvar= True)

bool

doWord(ea, length)

bool

do_data_ex(ea, dataflag, size, tid)

bool

do_name_anyway(ea, name, maxlen= 0)

do_unknown(ea, flags)

do_unknown_range(ea, size, flags)

bool

dosysfile(complain_if_no_file, file)

flags_t

doubleflag()

dto_copy_from_inf(arg0, inf)

dto_copy_to_inf(arg0, inf)

dto_init(dt, for_graph)

flags_t

dwrdflag()

ea_array

ea_array_frompointer(t)

ea_pointer

ea_pointer_frompointer(t)

echsize(fp, size)

eclose(fp)

FILE

ecreate(file)

FILE

ecreateT(file)

edit_manual_regions()

bool

enable_bblk_trace(enable)

bool

enable_bpt(ea, enable)
enable_bpt(bptloc, enable) -> bool

bool

enable_chooser_item_attrs(chooser_caption, enable)

enable_extlang_python(enable)
Enables or disables Python extlang.

error_t

enable_flags(startEA, endEA, stt)

bool

enable_func_trace(enable)

bool

enable_input_hotkeys(enable)

bool

enable_insn_trace(enable)

enable_manual_regions(enable)

bool

enable_menu_item(item_name, enable)

enable_python_cli(enable)

bool

enable_step_trace(enable)

char

encoding_from_strtype(strtype)

end_type_updating(utp)

enum_t

enum_decode(code)

uval_t

enum_encode(id, serial)

int

enum_import_names(mod_index, py_cb)
Enumerate imports from a specific module.

PyObject

enumerate_files(path, fname, callback)
Enumerate files in the specified directory while the callback returns 0.

enumerate_system_files(subdir, fname, callback)
Similar to enumerate_files() however it searches inside IDA directory or its subdirectories

flags_t

enumflag()

bool

equal_bytes(ea, image, mask, len, sense_case)

error(format)

eseek(fp, pos)

bool

execute(line)

int

execute_sync(py_callable, reqf)
Executes a function in the context of the main thread.

bool

execute_ui_requests(py_list)
Inserts a list of callables into the UI message processing queue.

bool

exit_process()

bool

expand_struc(sptr, offset, delta, recalc= True)

bool

extlang_call_method_exists()

bool

extlang_compile_file_exists(el= None)

bool

extlang_run_statements_exists(elang= None)

bool

extlang_set_attr_exists()

uint32

extract_and_convert_argloc(tp)

char

extract_name(line, x)

extract_spoiledreg(ptr, reg, len)

bool

f_any(arg0, arg1)

bool

f_hasRef(f, arg1)

bool

f_hasValue(f, arg1)

bool

f_has_dummy_name(f, arg1)

bool

f_has_name(f, arg1)

bool

f_has_user_name(F, arg1)

bool

f_is3byte(F, arg1)

bool

f_isASCII(F, arg1)

bool

f_isAlign(F, arg1)

bool

f_isByte(F, arg1)

bool

f_isCode(F, arg1)

bool

f_isCustom(F, arg1)

bool

f_isData(F, arg1)

bool

f_isDouble(F, arg1)

bool

f_isDwrd(F, arg1)

bool

f_isFloat(F, arg1)

bool

f_isHead(F, arg1)

bool

f_isNotTail(F, arg1)

bool

f_isOwrd(F, arg1)

bool

f_isPackReal(F, arg1)

bool

f_isQwrd(F, arg1)

bool

f_isStruct(F, arg1)

bool

f_isTail(F, arg1)

bool

f_isTbyt(F, arg1)

bool

f_isWord(F, arg1)

int

file2base(li, pos, ea1, ea2, patchable)

ea_t

find_binary(startea, endea, ubinstr, radix, sflag)

bool

find_bpt(bptloc, bpt)

ea_t

find_byte(sEA, size, value, sense_case)

ea_t

find_byter(sEA, size, value, sense_case)

ea_t

find_code(ea, sflag)

int

find_custom_data_format(name)

int

find_custom_data_type(name)

ea_t

find_data(ea, sflag)

ea_t

find_defined(ea, sflag)

ea_t

find_error(ea, sflag)

find_extlang_by_ext(ext)

find_extlang_by_name(name)

sel_t

find_free_selector()

int

find_func_bounds(ea, nfn, flags)

idc_class_t

find_idc_class(name)

idc_value_t

find_idc_gvar(name)

ea_t

find_imm(newEA, sflag, srchValue)

ea_t

find_not_func(ea, sflag)

ea_t

find_notype(ea, sflag)

regvar_t

find_regvar(pfn, ea1, ea2, canon, user)
find_regvar(pfn, ea, canon) -> regvar_t

sel_t

find_selector(base)

ea_t

find_text(startEA, y, x, ustr, sflag)

TForm

find_tform(caption)

ea_t

find_unknown(ea, sflag)

ea_t

find_void(ea, sflag)

char

first_named_type(ti, ntf_flags)

flags_t

floatflag()

flags_t

fltflag()

int

flush_buffers()

FILE

fopenA(file)

FILE

fopenM(file)

FILE

fopenRB(file)

FILE

fopenRT(file)

FILE

fopenWB(file)

FILE

fopenWT(file)

int

for_all_enum_members(id, cv)

int

for_all_types(ptype, tv)

formchgcbfa_close(p_fa, fid, close_normally)

bool

formchgcbfa_enable_field(p_fa, fid, enable)

PyObject

formchgcbfa_get_field_value(p_fa, fid, ft, sz)

int

formchgcbfa_get_focused_field(p_fa)

bool

formchgcbfa_move_field(p_fa, fid, x, y, w, h)

formchgcbfa_refresh_field(p_fa, fid)

bool

formchgcbfa_set_field_value(p_fa, fid, ft, py_val)

bool

formchgcbfa_set_focused_field(p_fa, fid)

bool

formchgcbfa_show_field(p_fa, fid, show)

free_custom_icon(icon_id)
Frees an icon loaded with load_custom_icon()

free_til(ti)

ea_t

freechunk(bottom, size, step)

bool

func_contains(pfn, ea)

bool

func_does_return(callee)

bool

func_item_iterator_decode_preceding_insn(fii, visited, p_farref)

bool

func_item_iterator_decode_prev_insn(fii)

bool

func_item_iterator_next(fii, testf, ud)

bool

func_item_iterator_prev(fii, testf, ud)

bool

func_parent_iterator_set(fpi, pfn)

bool

func_parent_iterator_set2(fpi, pfn)

bool

func_setend(ea, newend)

int

func_setstart(ea, newstart)

bool

func_tail_iterator_set(fti, pfn, ea)

bool

func_tail_iterator_set2(fti, pfn, ea)

bool

func_tail_iterator_set_ea(fti, ea)

bool

gen_abssym(ea, name)

bool

gen_cmt_line(format, *args)

bool

gen_collapsed_line(format, *args)

bool

gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth= -1)

bool

gen_comvar(ea, name)

gen_disasm_text(ea1, ea2, text, truncate_lines)

int

gen_exe_file(fp)

bool

gen_extern(ea, name)

int

gen_file(otype, fp, ea1, ea2, flags)

gen_fix_fixups(frm, to, size)

bool

gen_flow_graph(filename, title, pfn, ea1, ea2, gflags)

gen_gdl(g, fname)

int

gen_name_decl(ea, name)

bool

gen_simple_call_chart(filename, wait, title, gflags)

bool

gen_spcdef(ea, segtype)

bool

generate_big_comment(cmt, color)

bool

generate_disasm_line(ea, flags= 0)

PyObject

generate_disassembly(ea, max_lines, as_stack, notags)
Generate disassembly lines (many lines) and put them into a buffer

bool

generate_many_lines(string, color)

int

getDefaultRadix()

flags_t

getFlags(ea)

int

getRadix(F, n)

int

getRadixEA(ea, n)

sel_t

getSR(ea, rg)

segreg_t

getSRarea(ea)

uint32

get_16bit(ea)

uint32

get_32bit(ea)

uint32

get_3byte(ea)

uint64

get_64bit(ea)

bool

get_addon_info(id, info)

bool

get_addon_info_idx(index, info)

uint32

get_aflags(ea)

uint32

get_aflags0(ea)

uint32

get_alias_target(ti, ordinal)

int

get_argloc_r1(reg_argloc)

int

get_argloc_r2(reg_argloc)

PyObject

get_ascii_contents(ea, len, type)
Get contents of ascii string This function returns the displayed part of the string It works even if the string has not been created in the database yet.

PyObject

get_ascii_contents2(ea, len, type, flags= 0x00000000)
Get contents of ascii string This function returns the displayed part of the string It works even if the string has not been created in the database yet.

ssize_t

get_asm_inc_file()

ssize_t

get_auto_plugins()

type_t

get_base_type(t)

filetype_t

get_basic_file_type(li)

int

get_bblk_trace_options()

member_t

get_best_fit_member(sptr, offset)

ssize_t

get_bmask_cmt(id, bmask, repeatable)

ssize_t

get_bmask_name(id, bmask)

netnode

get_bmask_node(id, bmask)

bool

get_bpt(ea, bpt)

int

get_bpt_qty()

ea_t

get_bpt_tev_ea(n)

char

get_bptloc_string(i)

uchar

get_byte(ea)

ssize_t

get_c_header_path()

ssize_t

get_c_macros()

ea_t

get_call_tev_callee(n)

void

get_chooser_obj(chooser_caption)

ssize_t

get_cmt(ea, rptble)

char

get_colored_demangled_name(frm, ea, inhibitor, demform, strict)

char

get_colored_name(frm, ea)

comp_t

get_comp(comp)

char

get_compiler_name(id)

char

get_curline()

int

get_current_idasgn()

TForm

get_current_tform()

thid_t

get_current_thread()

TCustomControl

get_current_viewer()

bool

get_cursor()

PyObject

get_custom_data_format(dtid, fid)
Returns a dictionary populated with the data format values or None on failure.

int

get_custom_data_formats(out, dtid)

PyObject

get_custom_data_type(dtid)
Returns a dictionary populated with the data type values or None on failure.

int

get_custom_data_types(out, min_size= 0, max_size= BADADDR)

char

get_custom_viewer_curline(custom_viewer, mouse)

asize_t

get_data_elsize(ea, F, ti= None)

bool

get_data_value(ea, v, size)

uchar

get_db_byte(ea)

bool

get_dbg_byte(ea, x)

int

get_dbg_memory_info(areas)

debug_event_t

get_debug_event()

ea_t

get_debug_name_ea(name)

PyObject

get_debug_names(ea1, ea2)

char

get_debugger_event_cond()

int

get_default_encoding_idx(strtype)

reftype_t

get_default_reftype(ea)

sel_t

get_defsr(s, reg)

char

get_demangled_name(frm, ea, inhibitor, demform, strict)

char

get_dtyp_by_size(size)

flags_t

get_dtyp_flag(dtype)

size_t

get_dtyp_size(dtype)

char

get_encoding_name(idx)

int

get_encodings_count()

ea_t

get_entry(ord)

ssize_t

get_entry_name(ord)

uval_t

get_entry_ordinal(idx)

size_t

get_entry_qty()

enum_t

get_enum(name)

ssize_t

get_enum_cmt(id, repeatable)

flags_t

get_enum_flag(id)

enum_t

get_enum_id(ea, n)

uval_t

get_enum_idx(id)

const_t

get_enum_member(id, value, serial, mask)

bmask_t

get_enum_member_bmask(id)

const_t

get_enum_member_by_name(name)

ssize_t

get_enum_member_cmt(id, repeatable)

enum_t

get_enum_member_enum(id)

ssize_t

get_enum_member_name(id)

uchar

get_enum_member_serial(cid)

uval_t

get_enum_member_value(id)

ssize_t

get_enum_name(id)

size_t

get_enum_qty()

size_t

get_enum_size(id)

int32

get_enum_type_ordinal(id)

size_t

get_enum_width(id)

ea_t

get_event_bpt_hea(ev)

uint

get_event_exc_code(ev)

ea_t

get_event_exc_ea(ev)

char

get_event_exc_info(ev)

char

get_event_info(ev)

ea_t

get_event_module_base(ev)

char

get_event_module_name(ev)

asize_t

get_event_module_size(ev)

char

get_extlang_fileext()

func_t

get_fchunk(ea)

int

get_fchunk_num(ea)

size_t

get_fchunk_qty()

ea_t

get_fchunk_referer(ea, idx)

size_t

get_file_type_name()

ea_t

get_fileregion_ea(offset)

int32

get_fileregion_offset(ea)

bmask_t

get_first_bmask(id)

ea_t

get_first_cref_from(frm)

ea_t

get_first_cref_to(to)

ea_t

get_first_dref_from(frm)

ea_t

get_first_dref_to(to)

uval_t

get_first_enum_member(id, bmask= (bmask_t(-1)))

ea_t

get_first_fcref_from(frm)

ea_t

get_first_fcref_to(to)

ea_t

get_first_fixup_ea()

bool

get_first_module(modinfo)

segment_t

get_first_seg()

const_t

get_first_serial_enum_member(id, value, bmask)

uval_t

get_first_struc_idx()

bool

get_fixup(source, fd)

ea_t

get_fixup_base(source, fd)

char

get_fixup_desc(source, fdp)

ea_t

get_fixup_extdef_ea(source, fd)
get_fixup_extdef_ea(ea) -> ea_t

sel_t

get_fixup_segdef_sel(fd)
get_fixup_segdef_sel(ea) -> sel_t

flags_t

get_flags_by_size(size)

flags_t

get_flags_ex(ea, how)

flags_t

get_flags_novalue(ea)

ssize_t

get_forced_operand(ea, n)

struc_t

get_frame(pfn)
get_frame(ea) -> struc_t

int

get_frame_retsize(pfn)

asize_t

get_frame_size(pfn)

uint32

get_full_byte(ea)

asize_t

get_full_data_elsize(ea, F, ti= None)

uint64

get_full_long(ea)

type_t

get_full_type(t)

uint64

get_full_word(ea)

func_t

get_func(ea)

int

get_func_bitness(pfn)

int

get_func_bits(pfn)

ea_t

get_func_by_frame(frame_id)

int

get_func_bytes(pfn)

cm_t

get_func_cc(til, p_type, p_fields= None)

int

get_func_chunknum(pfn, ea)

PyObject

get_func_cmt(fn, repeatable)
Retrieve function comment

bool

get_func_limits(pfn, limits)

char

get_func_name(ea)

int

get_func_num(ea)

size_t

get_func_qty()

int

get_func_rettype(til, type, fields, rettype, retfields= None, p_retloc= None, p_cc= None)

int

get_func_trace_options()

size_t

get_funcarg_size(til, type, lp= None)

sel_t

get_group_selector(grpsel)

ea_t

get_hexdump_ea(hexdump_num)

hidden_area_t

get_hidden_area(ea)

int

get_hidden_area_num(ea)

int

get_hidden_area_qty()

PyObject

get_highlighted_identifier(flags= 0)
Returns the currently highlighted identifier

bool

get_idainfo_by_type2(til, rtype, fields, psize, pflags, mt, alsize= None)

PyObject

get_idasgn_desc(n)
Get information about a signature in the list.

int

get_idasgn_qty()

char

get_idasgn_title(name)

char

get_idc_filename(file)

char

get_idcpath()

char

get_idp_name()

netnode

get_ids_modnode()

ea_t

get_imagebase()

PyObject

get_import_module_name(mod_index)
Returns the name of an imported module given its index

int

get_import_module_qty()

idainfo

get_inf_structure()
Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp)

ssize_t

get_input_file_path()

bool

get_insn_tev_reg_mem(n, memmap)

bool

get_insn_tev_reg_result(n, regname, regval)

bool

get_insn_tev_reg_val(n, regname, regval)

int

get_insn_trace_options()

bgcolor_t

get_item_color(ea)

ea_t

get_item_end(ea)

flags_t

get_item_flag(frm, n, ea, appzero)

ea_t

get_item_head(ea)

asize_t

get_item_size(ea)

ushort

get_key_code(keyname)

bmask_t

get_last_bmask(id)

uval_t

get_last_enum_member(id, bmask= (bmask_t(-1)))

segment_t

get_last_seg()

const_t

get_last_serial_enum_member(id, value, bmask)

uval_t

get_last_struc_idx()

linput_type_t

get_linput_type(li)

uint32

get_long(ea)

char

get_long_queue_name(type)

char

get_manual_insn(ea)

PyObject

get_manual_regions()
Returns the manual memory regions

PyObject

get_many_bytes(ea, size)
Get the specified number of bytes of the program into the buffer.

int

get_many_bytes_ex(ea, buf, size, mask)

size_t

get_max_ascii_length(ea, strtype, options= 0)

ea_t

get_max_offset(sptr)

member_t

get_member(sptr, offset)

member_t

get_member_by_fullname(fullname, sptr_place)

member_t

get_member_by_name(sptr, membername)

ssize_t

get_member_cmt(mid, repeatable)

ssize_t

get_member_fullname(mid)

ssize_t

get_member_name(mid)

asize_t

get_member_size(mptr)

struc_t

get_member_struc(fullname)

bool

get_member_tinfo(mptr, buf, fields)

ea_t

get_min_spd_ea(pfn)

char

get_name(frm, ea)

ea_t

get_name_base_ea(frm, to)

color_t

get_name_color(frm, ea)

ea_t

get_name_ea(frm, name)

ssize_t

get_name_expr(frm, n, ea, off, flags= 0x0001)

int

get_name_value(frm, name)

bmask_t

get_next_bmask(id, bmask)

ea_t

get_next_cref_from(frm, current)

ea_t

get_next_cref_to(frm, current)

ea_t

get_next_dref_from(frm, current)

ea_t

get_next_dref_to(to, current)

uval_t

get_next_enum_member(id, value, bmask= (bmask_t(-1)))

func_t

get_next_fchunk(ea)

ea_t

get_next_fcref_from(frm, current)

ea_t

get_next_fcref_to(to, current)

ea_t

get_next_fixup_ea(ea)

func_t

get_next_func(ea)

ea_t

get_next_func_addr(pfn, ea)

hidden_area_t

get_next_hidden_area(ea)

ssize_t

get_next_member_idx(sptr, off)

bool

get_next_module(modinfo)

segment_t

get_next_seg(ea)

const_t

get_next_serial_enum_member(first_cid)

uval_t

get_next_struc_idx(idx)

ssize_t

get_nice_colored_name(ea, flags= 0)

ea_t

get_nlist_ea(idx)

size_t

get_nlist_idx(ea)

char

get_nlist_name(idx)

size_t

get_nlist_size()

bool

get_numbered_type(ti, ordinal, type= None, fields= None, cmt= None, fieldcmts= None, sclass= None)

char

get_numbered_type_name(ti, ordinal)

ea_t

get_offbase(ea, n)

int

get_offset_expr(ea, n, ri, frm, offset, getn_flags= 0)

int

get_offset_expression(ea, n, frm, offset, getn_flags= 0)

size_t

get_operand_immvals(ea, n, v)

opinfo_t

get_opinfo(ea, n, flags, buf)

int

get_opnum()

flags_t

get_optype_flags0(F)

flags_t

get_optype_flags1(F)

bool

get_or_guess_member_tinfo(mptr, type, fields)

int

get_ordinal_from_idb_type(name, type)

uint32

get_ordinal_qty(ti)

uint32

get_original_byte(ea)

uint64

get_original_long(ea)

uint64

get_original_word(ea)

char

get_plugin_options(plugin)

bmask_t

get_prev_bmask(id, bmask)

uval_t

get_prev_enum_member(id, value, bmask= (bmask_t(-1)))

func_t

get_prev_fchunk(ea)

ea_t

get_prev_fixup_ea(ea)

func_t

get_prev_func(ea)

ea_t

get_prev_func_addr(pfn, ea)

hidden_area_t

get_prev_hidden_area(ea)

ssize_t

get_prev_member_idx(sptr, off)

segment_t

get_prev_seg(ea)

const_t

get_prev_serial_enum_member(first_cid)

uval_t

get_prev_struc_idx(idx)

pid_t

get_process_info(n, process_info)

get_process_options(path, args, sdir, host, _pass, port)

int

get_process_qty()

int

get_process_state()

ssize_t

get_ptr_object_size(til, type)

uint64

get_qword(ea)

int

get_refinfo(ea, n, ri)

reftype_t

get_reftype_by_size(size)

char

get_reg_info(regname, mask)

ssize_t

get_reg_name(reg, width, reghi= -1)

bool

get_reg_val(regname, regval)

int

get_reg_vals(tid, clsmask, values)

ea_t

get_ret_tev_return(n)

ssize_t

get_root_filename()

dbg_notification_t

get_running_notification()

ui_notification_t

get_running_request()

ea_t

get_screen_ea()

ea_t

get_segm_base(s)

segment_t

get_segm_by_name(name)

segment_t

get_segm_by_sel(selector)

ssize_t

get_segm_class(s)

ssize_t

get_segm_name(s)
get_segm_name(ea) -> ssize_t

ea_t

get_segm_para(s)

int

get_segm_qty()

char

get_segment_alignment(align)

char

get_segment_cmt(s, repeatable)

char

get_segment_combination(comb)

ea_t

get_segment_translations(segstart, buf, bufsize)

int

get_selector_qty()

char

get_short_queue_name(type)

char

get_sig_filename(signame)

uval_t

get_source_linnum(ea)

char

get_sourcefile(ea, bounds= None)

sval_t

get_sp_delta(pfn, ea)

sval_t

get_spd(pfn, ea)

unsigned int

get_spoil_cnt(t)

struc_t

get_sptr(mptr)

int

get_step_trace_options()

int

get_stkarg_offset()

PyObject

get_stkvar(py_op, py_v)
Get pointer to stack variable

uchar

get_str_encoding_idx(strtype)

char

get_str_term1(strtype)

char

get_str_term2(strtype)

char

get_str_type_code(strtype)

bool

get_strlist_item(n, si)

size_t

get_strlist_qty()

bool

get_strmem2(til, type, fields, info)

int

get_stroff_path(ea, n, path, delta)

struc_t

get_struc(id)

tid_t

get_struc_by_idx(idx)

ssize_t

get_struc_cmt(id, repeatable)

ea_t

get_struc_first_offset(sptr)

tid_t

get_struc_id(name)

uval_t

get_struc_idx(id)

ea_t

get_struc_last_offset(sptr)

ssize_t

get_struc_name(id)

ea_t

get_struc_next_offset(sptr, offset)

ea_t

get_struc_prev_offset(sptr, offset)

size_t

get_struc_qty()

asize_t

get_struc_size(sptr)
get_struc_size(id) -> asize_t

PyObject

get_switch_info_ex(ea)
Returns the a switch_info_ex_t structure containing the information about the switch.

int

get_tab_size(path)

bool

get_tev_event(n, d)

bool

get_tev_info(n, tev_info)

bool

get_tev_memory_info(n, mi)

int

get_tev_qty()

HWND

get_tform_handle(form)

int

get_thread_qty()

bool

get_trace_file_desc(filename)

char

get_true_name(frm, ea)

ssize_t

get_true_segm_name(s)

type_t

get_type_flags(t)

int32

get_type_ordinal(ti, name)

type_sign_t

get_type_sign(til, type)

PyObject

get_type_size0(ti, tp)
Returns the size of a type

char

get_user_idadir()

ushort

get_word(ea)

bool

get_xml(path, value)

bool

get_zero_areas(zareas, range)

uint64

getdspace(path)

segreg_t

getnSRarea(n)

bool

getn_bpt(n, bpt)

enum_t

getn_enum(n)

func_t

getn_fchunk(n)

func_t

getn_func(n)

hidden_area_t

getn_hidden_area(n)

bool

getn_selector(n, sel, base)

thid_t

getn_thread(n)

segment_t

getnseg(n)

segment_t

getseg(ea)

char

getsysfile(filename, subdir)

ushort

gettof(F)

bool

graph_trace()

int

guess_func_tinfo(pfn, type, fields)

ea_t

guess_table_address()

asize_t

guess_table_size(jump_table)

int

guess_tinfo(id, type, fields)

int

handle_debug_event(ev, rqflags)

bool

hasExtra(F)

bool

hasRef(F)

bool

hasValue(F)

bool

has_any_name(F)

bool

has_auto_name(F)

bool

has_cmt(F)

bool

has_dummy_name(F)

bool

has_external_refs(pfn, ea)

bool

has_name(F)

bool

has_user_name(F)

bool

have_set_options(_dbg)

flags_t

hexflag()

int

hide_all_bpts()

hide_name(ea)

hide_wait_box()

char

idadir(subdir)

char

idb2scr(name)

int

idc_get_local_type(ordinal, flags, buf)

char

idc_get_local_type_name(ordinal)

char

idc_get_type(ea)

char

idc_guess_type(ea)

PyObject

idc_parse_decl(ti, decl, flags)

int

idc_parse_types(input, flags)

int

idc_set_local_type(ordinal, dcl, flags)

tid_t

import_type(til, idx, name, flags= 0)

info(format, *args)

PyObject

init_output_buffer(size= 1024)
This function initialize an output buffer with the given size.

bool

insn_t_assign(self, other)

PyObject

insn_t_create()

bool

insn_t_destroy(py_obj)

PyObject

insn_t_get_auxpref(self)

PyObject

insn_t_get_canon_feature(itype)

PyObject

insn_t_get_canon_mnem(itype)

PyObject

insn_t_get_cs(self)

PyObject

insn_t_get_ea(self)

PyObject

insn_t_get_flags(self)

PyObject

insn_t_get_insnpref(self)

PyObject

insn_t_get_ip(self)

PyObject

insn_t_get_itype(self)

PyObject

insn_t_get_op_link(py_insn_lnk, i)

PyObject

insn_t_get_segpref(self)

PyObject

insn_t_get_size(self)

PyObject

insn_t_is_canon_insn(itype)

insn_t_set_auxpref(self, value)

insn_t_set_cs(self, value)

insn_t_set_ea(self, value)

insn_t_set_flags(self, value)

insn_t_set_insnpref(self, value)

insn_t_set_ip(self, value)

insn_t_set_itype(self, value)

insn_t_set_segpref(self, value)

insn_t_set_size(self, value)

int

install_command_interpreter(py_obj)

bool

install_extlang(el)

int_pointer

int_pointer_frompointer(t)

intel_data(ea)

int

internal_get_sreg_base(tid, sreg_value, answer)

int

internal_ioctl(fn, buf, size, poutbuf, poutsize)

invalidate_dbgmem_config()

invalidate_dbgmem_contents(ea, size)

bool

is3byte(F)

bool

isASCII(F)

bool

isAlign(F)

bool

isByte(F)

bool

isChar(F, n)

bool

isChar0(F)

bool

isChar1(F)

bool

isCode(F)

bool

isCustFmt(F, n)

bool

isCustFmt0(F)

bool

isCustFmt1(F)

bool

isCustom(F)

bool

isData(F)

bool

isDefArg(F, n)

bool

isDefArg0(F)

bool

isDefArg1(F)

bool

isDouble(F)

bool

isDwrd(F)

bool

isEnabled(ea)

bool

isEnum(F, n)

bool

isEnum0(F)

bool

isEnum1(F)

bool

isFloat(F)

bool

isFloat0(F)

bool

isFloat1(F)

bool

isFlow(F)

bool

isFltnum(F, n)

bool

isFop(F, n)

bool

isFop0(F)

bool

isFop1(F)

bool

isFunc(F)

bool

isHead(F)

bool

isImmd(F)

bool

isLoaded(ea)

bool

isNotTail(F)

bool

isNum(F, n)

bool

isNum0(F)

bool

isNum1(F)

bool

isOff(F, n)

bool

isOff0(F)

bool

isOff1(F)

bool

isOwrd(F)

bool

isPackReal(F)

bool

isQwrd(F)

bool

isSeg(F, n)

bool

isSeg0(F)

bool

isSeg1(F)

bool

isStkvar(F, n)

bool

isStkvar0(F)

bool

isStkvar1(F)

bool

isStroff(F, n)

bool

isStroff0(F)

bool

isStroff1(F)

bool

isStruct(F)

bool

isTail(F)

bool

isTbyt(F)

bool

isUnknown(F)

bool

isVar(F)

bool

isVoid(ea, F, n)

bool

isWord(F)

bool

is_anonymous_member_name(name)

bool

is_autosync(name, type)

bool

is_basic_block_end(call_insn_stops_block)

bool

is_bblk_trace_enabled()

bool

is_bf(id)

bool

is_bnot(ea, F, n)

bool

is_bnot_data(F)

bool

is_call_insn(ea)

bool

is_castable2(til, frm, to)

bool

is_code_far(cm)

comp_t

is_comp_unsure(comp)

bool

is_data_far(cm)

bool

is_debugger_busy()

bool

is_debugger_memory(ea)

bool

is_debugger_on()

bool

is_dummy_member_name(name)

bool

is_enum_fromtil(id)

bool

is_enum_hidden(id)

bool

is_finally_visible_func(pfn)

bool

is_finally_visible_item(ea)

bool

is_finally_visible_segm(s)

bool

is_forced_operand(ea, n)

bool

is_func_entry(pfn)

bool

is_func_locked(pfn)

bool

is_func_tail(pfn)

bool

is_func_trace_enabled()

bool

is_idaq()
Returns True or False depending if IDAPython is hosted by IDAQ

bool

is_ident_char(c)

bool

is_in_nlist(ea)

bool

is_indirect_jump_insn(ea)

bool

is_insn_trace_enabled()

bool

is_invsign(ea, F, n)

bool

is_lzero(ea, n)

bool

is_main_thread()

bool

is_manual_insn(ea)

bool

is_member_id(mid)

bool

is_miniidb()

bool

is_msg_inited()

bool

is_name_defined_locally(pfn, name, ignore, ea1= BADADDR, ea2= BADADDR)

bool

is_noret_block(btype)

bool

is_one_bit_mask(mask)

bool

is_ordinal_name(name, ord)

bool

is_pascal(strtype)

bool

is_public_name(ea)

bool

is_purging_cc(cm)

bool

is_reg2_argloc(reg_argloc)

bool

is_reg_argloc(argloc)

bool

is_reg_custom(regname)

bool

is_reg_float(regname)

bool

is_reg_integer(regname)

bool

is_restype_array(til, type)

bool

is_restype_bitfld(til, type)

bool

is_restype_complex(til, type)

bool

is_restype_const(til, type)

bool

is_restype_enum(til, type)

bool

is_restype_func(til, type)

bool

is_restype_ptr(til, type)

bool

is_restype_struct(til, type)

bool

is_restype_struni(til, type)

bool

is_restype_union(til, type)

bool

is_restype_void(til, type)

bool

is_ret_block(btype)

bool

is_ret_insn(ea, strict= True)

bool

is_same_data_type(F1, F2)

bool

is_segm_locked(segm)

bool

is_segreg_locked(sreg)

bool

is_signed_data(F)

bool

is_spec_ea(ea)

bool

is_spec_segm(seg_type)

bool

is_special_member(id)

bool

is_stack_argloc(argloc)

bool

is_step_trace_enabled()

bool

is_type_array(t)

bool

is_type_bitfld(t)

bool

is_type_bool(t)

bool

is_type_char(t)

bool

is_type_complex(t)

bool

is_type_const(t)

bool

is_type_double(t)

bool

is_type_enum(t)

bool

is_type_float(t)

bool

is_type_floating(t)

bool

is_type_func(t)

bool

is_type_int64(t)

bool

is_type_ldouble(t)

bool

is_type_long(t)

bool

is_type_partial(t)

bool

is_type_ptr(t)

bool

is_type_resolvable(p, namebuf= None)

bool

is_type_scalar2(til, type)

bool

is_type_sdacl(t)

bool

is_type_short(t)

bool

is_type_struct(t)

bool

is_type_struni(t)

bool

is_type_sue(t)

bool

is_type_typedef(t)

bool

is_type_uchar(t)

bool

is_type_uint(t)

bool

is_type_uint64(t)

bool

is_type_ulong(t)

bool

is_type_union(t)

bool

is_type_unknown(t)

bool

is_type_ushort(t)

bool

is_type_void(t)

bool

is_type_volatile(t)

bool

is_typeid_last(t)

bool

is_uname(name)

bool

is_unicode(strtype)

bool

is_union(id)

bool

is_user_cc(cm)

bool

is_valid_full_type(ti, ptr)

bool

is_valid_trace_file(filename)

bool

is_valid_typename(name)

bool

is_vararg_cc(cm)

bool

is_varmember(mptr)

int

is_varsize_item(ea, F, ti= None, itemsize= None)

bool

is_varstr(id)

bool

is_visible_char(c)

bool

is_visible_func(pfn)

bool

is_visible_item(ea)

bool

is_visible_segm(s)

bool

is_weak_name(ea)

bool

isident(name)

bool

jumpto(ea, opnum= -1)
jumpto(custom_viewer, place, x, y) -> bool

bool

leading_zero_important(ea, n)

bool

load_and_run_plugin(name, arg)

bool

load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes)

load_custom_icon(file_name=None, data=None, format=None)
Loads a custom icon and returns an identifier that can be used with other APIs

bool

load_debugger(dbgname, use_remote)

int

load_ids_module(fname)

int

load_loader_module(li, lname, fname, is_remote)

PyObject

load_plugin(name)
Loads a plugin

til_t

load_til(tildir, name, errbuf, bufsize)
load_til(tildir, name) -> til_t

til_t

load_til_header(tildir, name, errbuf, bufsize)
load_til_header(tildir, name) -> til_t

bool

load_trace_file(filename)

loader_input_t

loader_input_t_from_cobject(pycobject)

loader_input_t

loader_input_t_from_fp(fp)

loader_input_t

loader_input_t_from_linput(linput)

ushort

lookup_key_code(key, shift, is_qt)

argloc_t

make_argloc(r1, r2)

bool

make_ascii_string(start, len, strtype)

bool

make_name_auto(ea)

make_name_non_public(ea)

make_name_non_weak(ea)

make_name_public(ea)

bool

make_name_user(ea)

make_name_weak(ea)

char

make_visible_name(srcname, dstsize)

bool

may_create_stkvars()

bool

may_trace_sp()

int

mem2base(py_mem, ea, fpos= -1)
Load database from the memory.

int

move_segm(s, to, flags= 0)

int

move_segm_start(ea, newstart, mode)

int

msg(format)

int

nbits(ea)

til_t

new_til(name, desc)

ea_t

next_head(ea, maxea)

char

next_named_type(ti, name, ntf_flags)

ea_t

next_not_tail(ea)

ea_t

next_unknown(ea, maxea)

ea_t

nextaddr(ea)

ea_t

nextchunk(ea)

ea_t

nextthat(ea, maxea, callable)
Find next address with a flag satisfying the function 'testf'.

bool

noImmd(ea)

bool

noType(ea, n)

noUsed(ea)
noUsed(sEA, eEA)

nomem(format, *args)

bool

notify_when(when, py_callable)
Register a callback that will be called when an event happens.

flags_t

numflag()

flags_t

octflag()

flags_t

offflag()

bool

op_adds_xrefs(F, n)

bool

op_bin(ea, n)

bool

op_chr(ea, n)

bool

op_custfmt(ea, n, fid)

bool

op_dec(ea, n)

bool

op_enum(ea, n, id, serial)

bool

op_flt(ea, n)

bool

op_hex(ea, n)

bool

op_num(ea, n)

bool

op_oct(ea, n)

int

op_offset(ea, n, type, target= BADADDR, base= 0, tdelta= 0)

int

op_offset_ex(ea, n, ri)

bool

op_seg(ea, n)

bool

op_stkvar(ea, n)

bool

op_stroff(ea, n, path, path_len, delta)

bool

op_t_assign(self, other)

PyObject

op_t_create()

bool

op_t_destroy(py_obj)

PyObject

op_t_get_addr(self)

PyObject

op_t_get_dtyp(self)

PyObject

op_t_get_flags(self)

PyObject

op_t_get_n(self)

PyObject

op_t_get_offb(self)

PyObject

op_t_get_offo(self)

PyObject

op_t_get_reg_phrase(self)

PyObject

op_t_get_specflag1(self)

PyObject

op_t_get_specflag2(self)

PyObject

op_t_get_specflag3(self)

PyObject

op_t_get_specflag4(self)

PyObject

op_t_get_specval(self)

PyObject

op_t_get_type(self)

PyObject

op_t_get_value(self)

op_t_set_addr(self, value)

op_t_set_dtyp(self, value)

op_t_set_flags(self, value)

op_t_set_n(self, value)

op_t_set_offb(self, value)

op_t_set_offo(self, value)

op_t_set_reg_phrase(self, value)

op_t_set_specflag1(self, value)

op_t_set_specflag2(self, value)

op_t_set_specflag3(self, value)

op_t_set_specflag4(self, value)

op_t_set_specval(self, value)

op_t_set_type(self, value)

op_t_set_value(self, value)

FILE

openM(file)

FILE

openR(file)

FILE

openRT(file)

TForm

open_bpts_window(ea)

TForm

open_calls_window(ea)

TForm

open_disasm_window(window_title, ranges= None)

TForm

open_enums_window(const_id= BADADDR)

TForm

open_exports_window(ea)

TForm

open_frame_window(pfn, offset)

TForm

open_funcs_window(ea)

TForm

open_hexdump_window(window_title)

TForm

open_imports_window(ea)

linput_t

open_linput(file, remote)

TForm

open_loctypes_window(ordinal)

TForm

open_modules_window()

TForm

open_names_window(ea)

TForm

open_navband_window(ea, zoom)

TForm

open_notepad_window()

TForm

open_problems_window(ea)

TForm

open_segments_window(ea)

TForm

open_segregs_window(ea)

TForm

open_selectors_window()

TForm

open_signatures_window()

TForm

open_stack_window()

TForm

open_strings_window(ea, selstart= BADADDR, selend= BADADDR)

TForm

open_structs_window(id= BADADDR, offset= 0)

open_tform(form, options)

TForm

open_threads_window()

TForm

open_tils_window()

TForm

open_trace_window()

open_url(url)

TForm

open_xrefs_window(ea)

out_addr_tag(ea)

out_colored_register_line(str)

out_keyword(str)

out_line(str, color)

out_long(v, radix)

bool

out_name_expr(py_op, ea, py_off)
Output a name expression

int

out_one_operand(n)

out_register(str)

out_symbol(c)

out_tagoff(tag)

out_tagon(tag)

flags_t

owrdflag()

PyObject

pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags= 0)
Packs a typed object to a string

PyObject

pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags= 0)
Write a typed object to the database.

flags_t

packrealflag()

PyObject

parse_command_line2(cmdline)

bool

parse_decl(til, decl, name, type, fields, flags)

int

parse_decls(til, input, printer, hti_flags)

bool

parse_reg_name(regname, ri)

bool

patch_byte(ea, x)

bool

patch_long(ea, x)

patch_many_bytes(ea, buf)

bool

patch_word(ea, x)

size_t

ph_get_cnbits()
Returns the 'ph.cnbits'

size_t

ph_get_dnbits()
Returns the 'ph.dnbits'

size_t

ph_get_flag()
Returns the 'ph.flag'

size_t

ph_get_high_fixup_bits()
Returns the 'ph.high_fixup_bits'

size_t

ph_get_icode_return()
Returns the 'ph.icode_return'

size_t

ph_get_id()
Returns the 'ph.id' field

PyObject

ph_get_instruc()
Returns a list of tuples (instruction_name, instruction_feature) containing the instructions list as defined in he processor module

size_t

ph_get_instruc_end()
Returns the 'ph.instruc_end'

size_t

ph_get_instruc_start()
Returns the 'ph.instruc_start'

PyObject

ph_get_operand_info(ea, n)
Returns the operand information given an ea and operand number.

size_t

ph_get_regCodeSreg()
Returns the 'ph.regCodeSreg'

size_t

ph_get_regDataSreg()
Returns the 'ph.regDataSreg'

size_t

ph_get_regFirstSreg()
Returns the 'ph.regFirstSreg'

size_t

ph_get_regLastSreg()
Returns the 'ph.regLastSreg'

PyObject

ph_get_regnames()
Returns the list of register names as defined in the processor module

size_t

ph_get_segreg_size()
Returns the 'ph.segreg_size'

size_t

ph_get_tbyte_size()
Returns the 'ph.tbyte_size' field as defined in he processor module

size_t

ph_get_version()
Returns the 'ph.version'

int

plan_to_apply_idasgn(fname)

plgform_close(py_link, options)

PyObject

plgform_new()

bool

plgform_show(py_link, py_obj, caption, options= FORM_TAB|FORM_MENU|FORM_RESTORE)

bool

pop_xml()

ea_t

prev_head(ea, minea)

ea_t

prev_not_tail(ea)

ea_t

prev_unknown(ea, minea)

ea_t

prevaddr(ea)

ea_t

prevchunk(ea)

ea_t

prevthat(ea, minea, callable)

char

print_ascii_string_type(strtype)

PyObject

print_type(ea, one_line)
Returns the type of an item

ssize_t

print_type_to_qstring(result, prefix, indent, cmtindent, flags, ti, pt, name= None, cmt= None, field_names= None, field_cmts= None)

bool

printf_line(indent, format, *args)

bool

process_ui_action(name, flags)
Invokes an IDA UI action by name

bool

push_xml(path)

bool

put_byte(ea, x)

bool

put_dbg_byte(ea, x)

put_long(ea, x)

put_many_bytes(ea, buf)

put_qword(ea, x)

put_word(ea, x)

size_t

py_get_AskUsingForm()

size_t

py_get_call_idc_func()

PyObject

py_get_global_cmd_link()

int

py_load_custom_icon_data(data, format)

int

py_load_custom_icon_fn(filename)

bool

py_menu_item_callback(userdata)

bool

py_set_idc_func_ex(name, fp_ptr, args, flags)

PyObject

pyg_add_command(self, title, hotkey)

pyg_close(self)

pyg_refresh(self)

pyg_select_node(self, nid)

bool

pyg_show(self)

bool

pyscv_add_line(py_this, py_sl)

size_t

pyscv_add_popup_menu(py_this, title, hotkey)

PyObject

pyscv_clear_lines(py_this)

pyscv_clear_popup_menu(py_this)

pyscv_close(py_this)

size_t

pyscv_count(py_this)

bool

pyscv_del_line(py_this, nline)

bool

pyscv_delete(py_this)

bool

pyscv_edit_line(py_this, nline, py_sl)

PyObject

pyscv_get_current_line(py_this, mouse, notags)

PyObject

pyscv_get_current_word(py_this, mouse)

PyObject

pyscv_get_line(py_this, nline)

PyObject

pyscv_get_pos(py_this, mouse)

PyObject

pyscv_get_selection(py_this)

PyObject

pyscv_init(py_link, title)

bool

pyscv_insert_line(py_this, nline, py_sl)

bool

pyscv_is_focused(py_this)

bool

pyscv_jumpto(py_this, ln, x, y)

bool

pyscv_patch_line(py_this, nline, offs, value)

bool

pyscv_refresh(py_this)

bool

pyscv_refresh_current(py_this)

bool

pyscv_show(py_this)

size_t

pyw_register_idc_func(name, args, py_fp)

bool

pyw_unregister_idc_func(ctxptr)

qexit(code)

qfile_t

qfile_t_from_cobject(pycobject)

qfile_t

qfile_t_from_fp(fp)

qfile_t

qfile_t_tmpfile()

uint32

qfsize(fp)

char

qlgetz(li, fpos)

bool

qstrvec_t_add(self, s)

PyObject

qstrvec_t_addressof(self, idx)

bool

qstrvec_t_assign(self, other)

bool

qstrvec_t_clear(self, qclear)

PyObject

qstrvec_t_create()

bool

qstrvec_t_destroy(py_obj)

bool

qstrvec_t_from_list(self, py_list)

PyObject

qstrvec_t_get(self, idx)

qstrvec_t_get_clink(self)

PyObject

qstrvec_t_get_clink_ptr(self)

bool

qstrvec_t_insert(self, idx, s)

bool

qstrvec_t_remove(self, idx)

bool

qstrvec_t_set(self, idx, s)

size_t

qstrvec_t_size(self)

void

qvector_reserve(vec, old, cnt, elsize)

flags_t

qwrdflag()

ssize_t

read_dbg_memory(ea, buffer, size)

read_regargs(pfn)

bool

read_selection()

int

read_struc_path(node, idx, path, delta)

int

readbytes(h, res, size, mf)

bool

readsel2(v, p1, p2)

reanalyze_callers(ea, noret)

reanalyze_function(pfn, ea1= 0, ea2= BADADDR, analyze_parents= False)

int

rebase_program(delta, flags)

rebuild_nlist()

bool

recalc_spd(cur_ea)

bool

refresh_chooser(title)

PyObject

refresh_debugger_memory()
Refreshes the debugger memory

refresh_idaview()

refresh_idaview_anyway()

refresh_lists()

refresh_navband(force)

refresh_strlist(ea1, ea2)

int

register_addon(info)

int

register_custom_data_format(dtid, py_df)
Registers a custom data format with a given data type.

int

register_custom_data_type(py_dt)
Registers a custom data type.

register_data_types_and_formats(formats)
Registers multiple data types and formats at once.

PyObject

register_timer(interval, py_callback)
Register a timer

int

reload_file(file, is_remote)

reloc_value(value, size, delta, mf)

bool

relocate_relobj(_relobj, ea, mf)

remove_command_interpreter(cli_idx)

bool

remove_extlang(el)

bool

remove_func_tail(pfn, tail_ea)

bool

remove_type_pointer(til, ptype, pname)

bool

rename_entry(ord, name)

int

rename_named_type(ti, frm, to, ntf_flags)

int

rename_regvar(pfn, v, user)

reorder_dummy_names()

repaint_custom_viewer(custom_viewer)

int

replace_subtypes(type, type_pairs)

bool

replace_tabs(out, str, tabsize)

replace_wait_box(format, *args)

bool

request_add_bpt(ea, size, type)
request_add_bpt(bpt) -> bool

int

request_attach_process(pid, event_id)

request_clear_trace()

bool

request_continue_process()

bool

request_del_bpt(ea)
request_del_bpt(bptloc) -> bool

bool

request_detach_process()

bool

request_enable_bblk_trace(enable)

bool

request_enable_bpt(ea, enable)
request_enable_bpt(bptloc, enable) -> bool

bool

request_enable_func_trace(enable)

bool

request_enable_insn_trace(enable)

bool

request_enable_step_trace(enable)

bool

request_exit_process()

request_refresh(mask)

int

request_resume_thread(tid)

bool

request_run_to(ea)

bool

request_select_thread(tid)

request_set_bblk_trace_options(options)

request_set_func_trace_options(options)

request_set_insn_trace_options(options)

bool

request_set_reg_val(regname, regval)

request_set_step_trace_options(options)

int

request_start_process(path, args, sdir)

bool

request_step_into()

bool

request_step_over()

bool

request_step_until_ret()

bool

request_suspend_process()

int

request_suspend_thread(tid)

requires_color_esc(c)
Checks if the given character requires escaping

bool

resolve_complex_type2(til, ptype, fields, type_name, bt, N)

type_t

resolve_typedef2(ti, p, fields= None, namebuf= None)

int

resume_thread(tid)

excvec_t

retrieve_exceptions()

uint32

retrieve_input_file_crc32()

bool

retrieve_input_file_md5(hash)

opinfo_t

retrieve_member_info(mptr, buf)

bool

run_plugin(plg, arg)
Runs a plugin

bool

run_requests()

bool

run_statements(str, elang= None)

bool

run_to(ea)

save_struc2(sptr, may_update_ltypes= True)

bool

save_trace_file(filename, description)

char

scr2idb(name)

int

sdacl_pack(algn)

int

sdacl_unpack(t)

bool

search_down(sflag)

flags_t

segflag()

adiff_t

segm_adjust_diff(s, delta)

ea_t

segm_adjust_ea(s, ea)

uchar

segtype(ea)

ea_t

sel2ea(selector)

sel_array

sel_array_frompointer(t)

sel_pointer

sel_pointer_frompointer(t)

bool

select_extlang(el)

bool

select_thread(tid)

setBreak()

setFlags(ea, flags)

idastate_t

setStat(st)

set_abits(ea, bits)

set_aflags(ea, flags)

set_aflags0(ea, flags)

bool

set_asm_inc_file(file)

bool

set_auto_plugins(list, listsize= 0)

set_bblk_trace_options(options)

bool

set_bmask_cmt(id, bmask, cmt, repeatable)

bool

set_bmask_name(id, bmask, name)

int

set_bptloc_string(s)

set_c_header_path(incdir)

set_c_macros(macros)

bool

set_cmt(ea, comm, rptble)

void

set_code_viewer_handler(code_viewer, handler_id, handler_or_data)

bool

set_code_viewer_is_source(code_viewer)

set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler)

bool

set_code_viewer_lines_alignment(code_viewer, align)

bool

set_code_viewer_lines_icon_margin(code_viewer, margin)

bool

set_code_viewer_lines_radix(code_viewer, radix)

bool

set_code_viewer_user_data(code_viewer, ud)

bool

set_compiler(cc, flags)

bool

set_compiler_id(id)

bool

set_custom_viewer_qt_aware(custom_viewer)

char

set_dbg_options(keyword, value_type, value)

bool

set_debug_name(ea, name)

set_debugger_event_cond(cond)

uint

set_debugger_options(options)

set_default_dataseg(ds_sel)

bool

set_default_encoding_idx(strtype, idx)

set_defsr(s, reg, value)

bool

set_dock_pos(src_ctrl, dest_ctrl, orient, left= 0, top= 0, right= 0, bottom= 0)
Sets the dock orientation of a window relatively to another window.

bool

set_dummy_name(frm, ea)

bool

set_enum_bf(id, bf)

bool

set_enum_cmt(id, cmt, repeatable)

bool

set_enum_fromtil(id, fromtil)

bool

set_enum_hidden(id, hidden)

bool

set_enum_idx(id, idx)

bool

set_enum_member_cmt(id, cmt, repeatable)

bool

set_enum_member_name(id, name)

bool

set_enum_name(id, name)

set_enum_type_ordinal(id, ord)

bool

set_enum_width(id, width)

set_fixup(source, fp)

set_fixup_ex(source, fd, offset_base)

bool

set_forced_operand(ea, n, op)

bool

set_frame_size(pfn, frsize, frregs, argsize)

bool

set_func_cmt(fn, cmt, repeatable)

int

set_func_name_if_jumpfunc(fn, oldname)

set_func_trace_options(options)

int

set_group_selector(grp, sel)

bool

set_header_path(path, add)

set_idc_func_ex(name, fp=None, args=(), flags=0)
Extends the IDC language by exposing a new IDC function that is backed up by a Python function This function also unregisters the IDC function if 'fp' was passed as None

set_ids_modnode(id)

set_imagebase(base)

set_insn_trace_options(options)

set_item_color(ea, color)

bool

set_lzero(ea, n)

set_manual_insn(ea, manual_insn)

bool

set_member_cmt(mptr, cmt, repeatable)

bool

set_member_name(sptr, offset, name)

bool

set_member_tinfo(til, sptr, mptr, memoff, type, fields, flags)

bool

set_member_type(sptr, offset, flag, mt, nbytes)

bool

set_menu_item_icon(item_name, icon_id)

bool

set_name(ea, name, flag)
set_name(ea, name) -> bool

bool

set_noret_insn(insn_ea, noret)

bool

set_numbered_type(ti, ordinal, ntf_flags, name, type, fields= None, cmt= None, fldcmts= None, sclass= None)

bool

set_offset(ea, n, base)

bool

set_op_type(ea, type, n)

bool

set_opinfo(ea, n, flag, ti)

set_process_options(path, args, sdir, host, _pass, port)

int

set_process_state(newstate, p_thid, dbginv)

char

set_processor_type(procname, level)

bool

set_purged(ea, nbytes, override_old_value)

int

set_refinfo(ea, n, type, target= BADADDR, base= 0, tdelta= 0)

int

set_refinfo_ex(ea, n, ri)

bool

set_reg_val(regname, regval)
set_reg_val(tid, regidx, value) -> int

int

set_regvar_cmt(pfn, v, cmt)

set_remote_debugger(host, _pass, port= -1)

set_root_filename(file)

int

set_script_timeout(timeout)
Changes the script timeout value.

bool

set_segm_addressing(s, bitness)

bool

set_segm_base(s, newbase)

int

set_segm_class(s, sclass)

int

set_segm_end(ea, newend, flags)

int

set_segm_name(s, format, *args)

int

set_segm_start(ea, newstart, flags)

set_segment_cmt(s, cmt, repeatable)

bool

set_segment_translations(segstart, transmap)

int

set_selector(selector, paragraph)

set_source_linnum(ea, lnnum)

type_t

set_spoils(pt, reg, size)

set_sreg_at_next_code(ea1, ea2, reg, value)

set_step_trace_options(options)

bool

set_strlist_options(options)

bool

set_stroff_path(ea, n, path, plen, delta)

bool

set_struc_cmt(id, cmt, repeatable)

bool

set_struc_idx(sptr, idx)

bool

set_struc_name(id, name)

bool

set_switch_info_ex(ea, py_swi)
Saves the switch information in the database Please refer to the SDK sample 'uiswitch'

bool

set_tail_owner(fnt, func_start)

bool

set_target_assembler(asmnum)

bool

set_trace_file_desc(filename, description)

bool

set_trace_size(size)

bool

set_type_alias(ti, src_ordinal, dst_ordinal)

PyObject

set_user_defined_prefix(width, pycb)
User-defined line-prefixes are displayed just after the autogenerated line prefixes.

set_visible_func(pfn, visible)

set_visible_item(ea, visible)

set_visible_segm(s, visible)

bool

set_xml(path, name, value)
set_xml(path, name, value) -> bool

sel_t

setup_selector(segbase)

bool

should_create_stkvars()

bool

should_trace_sp()

showAddr(ea)

bool

showAllComments()

showAuto(ea, type= AU_NONE)

bool

showComments()

bool

showRepeatables()

show_name(ea)

show_wait_box(format, *args)

flags_t

signed_data_flag()

size_t

sizeof_ldbl()

type_t

skip_spoiled_info(ptr)

bool

splitSRarea1(ea, rg, v, tag, silent= False)

split_argloc(al, r1, r2)

int

start_process(path, args, sdir)

std_gen_func_header(pfn)

std_gen_segm_footer(ea)

bool

step_into()

bool

step_over()

bool

step_until_ret()

flags_t

stkvarflag()

bool

store_exceptions()

bool

store_til(ti, tildir, name)

ea_t

str2ea(str, screenEA= BADADDR)
Converts a string express to EA.

int

str2reg(p)

int

str2regf(p)

char

strarray(array, array_size, code)

bool

stroff_as_size(plen, sptr, value)

flags_t

stroffflag()

struct_unpack(buffer, signed=False, offs=0)
Unpack a buffer given its length and offset using struct.unpack_from().

flags_t

struflag()

bool

suspend_process()

int

suspend_thread(tid)

sval_pointer

sval_pointer_frompointer(t)

bool

switch_info_ex_t_assign(self, other)

PyObject

switch_info_ex_t_create()

bool

switch_info_ex_t_destroy(py_obj)

PyObject

switch_info_ex_t_get_custom(self)

PyObject

switch_info_ex_t_get_defjump(self)

PyObject

switch_info_ex_t_get_elbase(self)

PyObject

switch_info_ex_t_get_flags(self)

PyObject

switch_info_ex_t_get_flags2(self)

PyObject

switch_info_ex_t_get_ind_lowcase(self)

PyObject

switch_info_ex_t_get_jcases(self)

PyObject

switch_info_ex_t_get_jumps(self)

PyObject

switch_info_ex_t_get_ncases(self)

PyObject

switch_info_ex_t_get_regdtyp(self)

PyObject

switch_info_ex_t_get_regnum(self)

PyObject

switch_info_ex_t_get_startea(self)

PyObject

switch_info_ex_t_get_values_lowcase(self)

switch_info_ex_t_set_custom(self, value)

switch_info_ex_t_set_defjump(self, value)

switch_info_ex_t_set_elbase(self, value)

switch_info_ex_t_set_flags(self, value)

switch_info_ex_t_set_flags2(self, value)

switch_info_ex_t_set_ind_lowcase(self, value)

switch_info_ex_t_set_jcases(self, value)

switch_info_ex_t_set_jumps(self, value)

switch_info_ex_t_set_ncases(self, value)

switch_info_ex_t_set_regdtyp(self, value)

switch_info_ex_t_set_regnum(self, value)

switch_info_ex_t_set_startea(self, value)

switch_info_ex_t_set_values_lowcase(self, value)

switchto_tform(form, take_focus)

PyObject

tag_addr(ea)

int

tag_advance(line, cnt)

PyObject

tag_remove(instr)
Remove color escape sequences from a string

int

tag_skipcode(line)

int

tag_skipcodes(line)

ssize_t

tag_strlen(line)

bool

take_memory_snapshot(only_loader_segs)

flags_t

tbytflag()

term_output_buffer()
Use this function to terminate an output buffer.

bool

textctrl_info_t_assign(self, other)

PyObject

textctrl_info_t_create()

bool

textctrl_info_t_destroy(py_obj)

textctrl_info_t_get_clink(self)

PyObject

textctrl_info_t_get_clink_ptr(self)

unsigned int

textctrl_info_t_get_flags(self, flags)

unsigned int

textctrl_info_t_get_tabsize(self, tabsize)

char

textctrl_info_t_get_text(self)

bool

textctrl_info_t_set_flags(self, flags)

bool

textctrl_info_t_set_tabsize(self, tabsize)

bool

textctrl_info_t_set_text(self, s)

tid_array

tid_array_frompointer(t)

ea_t

toEA(reg_cs, reg_ip)

bool

toggle_bnot(ea, n)

bool

toggle_lzero(ea, n)

bool

toggle_sign(ea, n)

flags_t

tribyteflag()

int

try_to_add_libfunc(ea)

flags_t

typeflag(ea, oldflag, type, n)

int

typncmp(dst, src, size)

ua_add_cref(opoff, to, type)

ua_add_dref(opoff, to, type)

ea_t

ua_add_off_drefs(py_op, type)
Add xrefs for offset operand of the current instruction Please check ua.hpp / ua_add_off_drefs()

ea_t

ua_add_off_drefs2(py_op, type, outf)
Add xrefs for offset operand of the current instruction Please check ua.hpp / ua_add_off_drefs2()

bool

ua_dodata2(opoff, ea, dtype)

char

ua_mnem(ea)

uint8

ua_next_byte()

uint32

ua_next_long()

uint64

ua_next_qword()

uint16

ua_next_word()

bool

ua_outop2(ea, n, flags= 0)

bool

ua_stkvar2(x, v, flags)
Create or modify a stack variable in the function frame.

uchar_array

uchar_array_frompointer(t)

bool

ui_load_new_file(filename, li, neflags)

ui_run_debugger(*args)
ui_run_debugger(dbgopts, $ignore, argc, argv) -> bool

unmark_selection()

PyObject

unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags= 0)
Unpacks a buffer into an object.

PyObject

unpack_object_from_idb(ti, py_type, py_fields, ea, pio_flags= 0)

bool

unregister_custom_data_format(dtid, dfid)
Unregisters a custom data format

bool

unregister_custom_data_type(dtid)
Unregisters a custom data type.

unregister_data_types_and_formats(formats)
As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once.

PyObject

unregister_timer(py_timerctx)
Unregister a timer

bool

update_bpt(bpt)

bool

update_fpd(pfn, fpd)

bool

update_func(fn)

bool

update_hidden_area(ha)

uval_array

uval_array_frompointer(t)

char

validate_name(name)

int

visit_patched_bytes(ea1, ea2, py_callable)
Enumerates patched bytes in the given range and invokes a callable

flags_t

visit_stroff_fields(sfv, path, plen, disp, appzero)

dbg_event_code_t

wait_for_next_event(wfne, timeout_in_secs)

warning(format)

bool

wasBreak()

bool

was_ida_decision(ea)

flags_t

wordflag()

ssize_t

write_dbg_memory(ea, buffer, size)

write_struc_path(node, idx, path, plen, delta)

int

writebytes(h, l, size, mf)

char

xrefchar(xrtype)

Variables
	__EA64__ = `False`
	A80_addc = `171`
	A80_addcix = `172`
	A80_addciy = `173`
	A80_addix = `169`
	A80_addiy = `170`
	A80_cmpd = `182`
	A80_cmpi = `181`
	A80_im0 = `183`
	A80_im1 = `184`
	A80_im2 = `185`
	A80_jrc = `177`
	A80_jrnc = `178`
	A80_jrnz = `180`
	A80_jrz = `179`
	A80_lbcd = `149`
	A80_lded = `150`
	A80_lixd = `152`
	A80_liyd = `153`
	A80_lspd = `151`
	A80_mvai = `168`
	A80_mvar = `167`
	A80_mvia = `166`
	A80_mvra = `165`
	A80_otd = `186`
	A80_oti = `187`
	A80_pcix = `163`
	A80_pciy = `164`
	A80_sbcd = `154`
	A80_sded = `155`
	A80_sixd = `157`
	A80_siyd = `158`
	A80_spix = `161`
	A80_spiy = `162`
	A80_sspd = `156`
	A80_subc = `174`
	A80_subcix = `175`
	A80_subciy = `176`
	A80_xtix = `159`
	A80_xtiy = `160`
	ACCEPT_FIRST = `32768`
	ACFOPT_ASCII = `0`
	ACFOPT_CONVMASK = `15`
	ACFOPT_ESCAPE = `16`
	ACFOPT_UTF16 = `1`
	ACFOPT_UTF8 = `2`
	AD218X_alu_00 = `48`
	AD218X_alu_01 = `49`
	AD218X_alu_02 = `50`
	AD218X_alu_03 = `51`
	AD218X_alu_04 = `52`
	AD218X_alu_05 = `53`
	AD218X_alu_06 = `54`
	AD218X_alu_07 = `55`
	AD218X_alu_08 = `56`
	AD218X_alu_09 = `57`
	AD218X_alu_0a = `58`
	AD218X_alu_0b = `59`
	AD218X_alu_0c = `60`
	AD218X_alu_0d = `61`
	AD218X_alu_0e = `62`
	AD218X_alu_0f = `63`
	AD218X_alu_10 = `64`
	AD218X_alu_11 = `65`
	AD218X_alu_12 = `66`
	AD218X_alu_13 = `67`
	AD218X_alu_14 = `68`
	AD218X_alu_15 = `69`
	AD218X_alu_16 = `70`
	AD218X_alu_17 = `71`
	AD218X_alu_18 = `72`
	AD218X_alu_19 = `73`
	AD218X_alu_1a = `74`
	AD218X_alu_1b = `75`
	AD218X_alu_1c = `76`
	AD218X_alu_1d = `77`
	AD218X_amf = `90`
	AD218X_amf_01 = `1`
	AD218X_amf_02 = `3`
	AD218X_amf_03 = `2`
	AD218X_amf_04 = `4`
	AD218X_amf_05 = `5`
	AD218X_amf_06 = `6`
	AD218X_amf_07 = `7`
	AD218X_amf_08 = `8`
	AD218X_amf_09 = `9`
	AD218X_amf_0a = `10`
	AD218X_amf_0b = `11`
	AD218X_amf_0c = `12`
	AD218X_amf_0d = `13`
	AD218X_amf_0e = `14`
	AD218X_amf_0f = `15`
	AD218X_amf_10 = `16`
	AD218X_amf_11 = `17`
	AD218X_amf_12 = `18`
	AD218X_amf_13 = `19`
	AD218X_amf_14 = `20`
	AD218X_amf_15 = `21`
	AD218X_amf_16 = `22`
	AD218X_amf_17 = `23`
	AD218X_amf_18 = `24`
	AD218X_amf_19 = `25`
	AD218X_amf_1a = `26`
	AD218X_amf_1b = `27`
	AD218X_amf_1c = `28`
	AD218X_amf_1d = `29`
	AD218X_amf_1e = `30`
	AD218X_amf_1f = `31`
	AD218X_amf_move_0 = `137`
	AD218X_amf_move_1 = `138`
	AD218X_amf_move_2 = `139`
	AD218X_amf_move_3 = `140`
	AD218X_amf_move_4 = `141`
	AD218X_amf_move_5 = `142`
	AD218X_amf_move_6 = `143`
	AD218X_amf_move_7 = `144`
	AD218X_amf_move_8 = `145`
	AD218X_amf_move_9 = `146`
	AD218X_amf_move_a = `147`
	AD218X_call = `117`
	AD218X_call_1 = `118`
	AD218X_call_2 = `119`
	AD218X_do = `125`
	AD218X_double_move = `136`
	AD218X_flag_out = `128`
	AD218X_idle = `126`
	AD218X_idle_1 = `127`
	AD218X_ints_dis = `133`
	AD218X_ints_ena = `134`
	AD218X_jump = `112`
	AD218X_jump_1 = `113`
	AD218X_jump_2 = `114`
	AD218X_jump_3 = `115`
	AD218X_jump_4 = `116`
	AD218X_last = `148`
	AD218X_mac_0 = `78`
	AD218X_mac_1 = `79`
	AD218X_mac_2 = `80`
	AD218X_mac_3 = `81`
	AD218X_mac_4 = `82`
	AD218X_mac_5 = `83`
	AD218X_mac_6 = `84`
	AD218X_mac_7 = `85`
	AD218X_mac_8 = `86`
	AD218X_mac_9 = `87`
	AD218X_mac_a = `88`
	AD218X_mac_b = `89`
	AD218X_mode_ctl = `130`
	AD218X_modify = `135`
	AD218X_move_0 = `100`
	AD218X_move_1 = `101`
	AD218X_move_2 = `102`
	AD218X_move_3 = `103`
	AD218X_move_4 = `104`
	AD218X_move_5 = `105`
	AD218X_move_6 = `106`
	AD218X_move_7 = `107`
	AD218X_move_8 = `108`
	AD218X_move_9 = `109`
	AD218X_move_a = `110`
	AD218X_move_b = `111`
	AD218X_nop = `124`
	AD218X_null = `0`
	AD218X_rti = `122`
	AD218X_rti_cond = `123`
	AD218X_rts = `120`
	AD218X_rts_cond = `121`
	AD218X_shft = `91`
	AD218X_shft_0 = `32`
	AD218X_shft_1 = `33`
	AD218X_shft_2 = `34`
	AD218X_shft_3 = `35`
	AD218X_shft_4 = `36`
	AD218X_shft_5 = `37`
	AD218X_shft_6 = `38`
	AD218X_shft_7 = `39`
	AD218X_shft_8 = `40`
	AD218X_shft_9 = `41`
	AD218X_shft_a = `42`
	AD218X_shft_b = `43`
	AD218X_shft_c = `44`
	AD218X_shft_d = `45`
	AD218X_shft_e = `46`
	AD218X_shft_f = `47`
	AD218X_shifter_0 = `92`
	AD218X_shifter_1 = `93`
	AD218X_shifter_2 = `94`
	AD218X_shifter_3 = `95`
	AD218X_shifter_4 = `96`
	AD218X_shifter_5 = `97`
	AD218X_shifter_6 = `98`
	AD218X_shifter_7 = `99`
	AD218X_stack_ctl = `129`
	AD218X_tops_r = `132`
	AD218X_tops_w = `131`
	ADDSEG_FILLGAP = `16`
	ADDSEG_NOSREG = `1`
	ADDSEG_NOTRUNC = `4`
	ADDSEG_OR_DIE = `2`
	ADDSEG_QUIET = `8`
	ADDSEG_SPARSE = `32`
	ADDTIL_COMP = `2`
	ADDTIL_DEFAULT = `0`
	ADDTIL_FAILED = `0`
	ADDTIL_INCOMP = `1`
	ADDTIL_OK = `1`
	ADDTIL_SILENT = `2`
	AF2_ANORET = `1024`
	AF2_CHKUNI = `32`
	AF2_DATOFF = `512`
	AF2_DOCODE = `4096`
	AF2_DODATA = `2`
	AF2_FTAIL = `256`
	AF2_HFLIRT = `4`
	AF2_JUMPTBL = `1`
	AF2_PURDAT = `16384`
	AF2_REGARG = `16`
	AF2_SIGCMT = `64`
	AF2_SIGMLT = `128`
	AF2_STKARG = `8`
	AF2_TRFUNC = `8192`
	AF2_VERSP = `2048`
	AFL_ALIGNFLOW = `16777216`
	AFL_BNOT0 = `256`
	AFL_BNOT1 = `512`
	AFL_COLORED = `262144`
	AFL_FIXEDSPD = `8388608`
	AFL_HIDDEN = `16`
	AFL_LIB = `1024`
	AFL_LINNUM = `1`
	AFL_LNAME = `16384`
	AFL_LZERO0 = `65536`
	AFL_LZERO1 = `131072`
	AFL_MANUAL = `32`
	AFL_NOBRD = `64`
	AFL_NORET = `4194304`
	AFL_PUBNAM = `4`
	AFL_RETFP = `67108864`
	AFL_SIGN0 = `1048576`
	AFL_SIGN1 = `2097152`
	AFL_TERSESTR = `524288`
	AFL_TI = `2048`
	AFL_TI0 = `4096`
	AFL_TI1 = `8192`
	AFL_TILCMT = `32768`
	AFL_USERSP = `2`
	AFL_USERTI = `33554432`
	AFL_WEAKNAM = `8`
	AFL_ZSTROFF = `128`
	AF_ASCII = `4096`
	AF_CODE = `8`
	AF_DREFOFF = `16384`
	AF_FINAL = `32768`
	AF_FIXUP = `1`
	AF_FLIRT = `64`
	AF_IMMOFF = `8192`
	AF_JFUNC = `256`
	AF_LVAR = `1024`
	AF_MARKCODE = `2`
	AF_NULLSUB = `512`
	AF_PROC = `16`
	AF_PROCPTR = `128`
	AF_TRACE = `2048`
	AF_UNK = `4`
	AF_USED = `32`
	ALOPT_IGNHEADS = `1`
	ALOPT_IGNPRINT = `2`
	ALPHA_addf = `1`
	ALPHA_addg = `2`
	ALPHA_addl = `3`
	ALPHA_addl_v = `4`
	ALPHA_addq = `5`
	ALPHA_addq_v = `6`
	ALPHA_adds = `7`
	ALPHA_addt = `8`
	ALPHA_amask = `9`
	ALPHA_and = `10`
	ALPHA_andnot = `220`
	ALPHA_beq = `11`
	ALPHA_bge = `12`
	ALPHA_bgt = `13`
	ALPHA_bic = `14`
	ALPHA_bis = `15`
	ALPHA_blbc = `16`
	ALPHA_blbs = `17`
	ALPHA_ble = `18`
	ALPHA_blt = `19`
	ALPHA_bne = `20`
	ALPHA_br = `21`
	ALPHA_br0 = `222`
	ALPHA_bsr = `22`
	ALPHA_call_pal = `23`
	ALPHA_clr = `203`
	ALPHA_cmoveq = `24`
	ALPHA_cmovge = `25`
	ALPHA_cmovgt = `26`
	ALPHA_cmovlbc = `27`
	ALPHA_cmovlbs = `28`
	ALPHA_cmovle = `29`
	ALPHA_cmovlt = `30`
	ALPHA_cmovne = `31`
	ALPHA_cmpbge = `32`
	ALPHA_cmpeq = `33`
	ALPHA_cmpgeq = `34`
	ALPHA_cmpgle = `35`
	ALPHA_cmpglt = `36`
	ALPHA_cmple = `37`
	ALPHA_cmplt = `38`
	ALPHA_cmpteq = `39`
	ALPHA_cmptle = `40`
	ALPHA_cmptlt = `41`
	ALPHA_cmptun = `42`
	ALPHA_cmpule = `43`
	ALPHA_cmpult = `44`
	ALPHA_cpys = `45`
	ALPHA_cpyse = `46`
	ALPHA_cpysn = `47`
	ALPHA_ctlz = `48`
	ALPHA_ctpop = `49`
	ALPHA_cttz = `50`
	ALPHA_cvtdg = `51`
	ALPHA_cvtgd = `52`
	ALPHA_cvtgf = `53`
	ALPHA_cvtgq = `54`
	ALPHA_cvtlq = `55`
	ALPHA_cvtqf = `56`
	ALPHA_cvtqg = `57`
	ALPHA_cvtql = `58`
	ALPHA_cvtqs = `59`
	ALPHA_cvtqt = `60`
	ALPHA_cvtst = `61`
	ALPHA_cvttq = `62`
	ALPHA_cvtts = `63`
	ALPHA_divf = `64`
	ALPHA_divg = `65`
	ALPHA_divs = `66`
	ALPHA_divt = `67`
	ALPHA_ecb = `68`
	ALPHA_eqv = `69`
	ALPHA_excb = `70`
	ALPHA_extbl = `71`
	ALPHA_extlh = `72`
	ALPHA_extll = `73`
	ALPHA_extqh = `74`
	ALPHA_extql = `75`
	ALPHA_extwh = `76`
	ALPHA_extwl = `77`
	ALPHA_fabs = `204`
	ALPHA_fbeq = `78`
	ALPHA_fbge = `79`
	ALPHA_fbgt = `80`
	ALPHA_fble = `81`
	ALPHA_fblt = `82`
	ALPHA_fbne = `83`
	ALPHA_fclr = `205`
	ALPHA_fcmoveq = `84`
	ALPHA_fcmovge = `85`
	ALPHA_fcmovgt = `86`
	ALPHA_fcmovle = `87`
	ALPHA_fcmovlt = `88`
	ALPHA_fcmovne = `89`
	ALPHA_fetch = `90`
	ALPHA_fetch_m = `91`
	ALPHA_fmov = `206`
	ALPHA_fneg = `207`
	ALPHA_fnop = `202`
	ALPHA_ftois = `92`
	ALPHA_ftoit = `93`
	ALPHA_implver = `94`
	ALPHA_insbl = `95`
	ALPHA_inslh = `96`
	ALPHA_insll = `97`
	ALPHA_insqh = `98`
	ALPHA_insql = `99`
	ALPHA_inswh = `100`
	ALPHA_inswl = `101`
	ALPHA_itoff = `102`
	ALPHA_itofs = `103`
	ALPHA_itoft = `104`
	ALPHA_jmp = `105`
	ALPHA_jsr = `106`
	ALPHA_jsr_coroutine = `107`
	ALPHA_last = `223`
	ALPHA_lda = `108`
	ALPHA_ldah = `109`
	ALPHA_ldbu = `110`
	ALPHA_ldf = `112`
	ALPHA_ldg = `113`
	ALPHA_ldl = `114`
	ALPHA_ldl_l = `115`
	ALPHA_ldq = `116`
	ALPHA_ldq_l = `117`
	ALPHA_ldq_u = `118`
	ALPHA_lds = `119`
	ALPHA_ldt = `120`
	ALPHA_ldwu = `111`
	ALPHA_maxsb8 = `121`
	ALPHA_maxsw4 = `122`
	ALPHA_maxub8 = `123`
	ALPHA_maxuw4 = `124`
	ALPHA_mb = `125`
	ALPHA_mf_fpcr = `126`
	ALPHA_minsb8 = `127`
	ALPHA_minsw4 = `128`
	ALPHA_minub8 = `129`
	ALPHA_minuw4 = `130`
	ALPHA_mov = `208`
	ALPHA_mskbl = `131`
	ALPHA_msklh = `132`
	ALPHA_mskll = `133`
	ALPHA_mskqh = `134`
	ALPHA_mskql = `135`
	ALPHA_mskwh = `136`
	ALPHA_mskwl = `137`
	ALPHA_mt_fpcr = `138`
	ALPHA_mulf = `139`
	ALPHA_mulg = `140`
	ALPHA_mull = `141`
	ALPHA_mull_v = `142`
	ALPHA_mulq = `143`
	ALPHA_mulq_v = `144`
	ALPHA_muls = `145`
	ALPHA_mult = `146`
	ALPHA_negf = `213`
	ALPHA_negg = `214`
	ALPHA_negl = `209`
	ALPHA_negl_v = `210`
	ALPHA_negq = `211`
	ALPHA_negq_v = `212`
	ALPHA_negs = `215`
	ALPHA_negt = `216`
	ALPHA_nop = `201`
	ALPHA_not = `217`
	ALPHA_null = `0`
	ALPHA_or = `219`
	ALPHA_ornot = `147`
	ALPHA_perr = `148`
	ALPHA_pklb = `149`
	ALPHA_pkwb = `150`
	ALPHA_rc = `151`
	ALPHA_ret = `152`
	ALPHA_rpcc = `153`
	ALPHA_rs = `154`
	ALPHA_s4addl = `155`
	ALPHA_s4addq = `156`
	ALPHA_s4subl = `157`
	ALPHA_s4subq = `158`
	ALPHA_s8addl = `159`
	ALPHA_s8addq = `160`
	ALPHA_s8subl = `161`
	ALPHA_s8subq = `162`
	ALPHA_sextb = `163`
	ALPHA_sextl = `218`
	ALPHA_sextw = `164`
	ALPHA_sll = `165`
	ALPHA_sqrtf = `166`
	ALPHA_sqrtg = `167`
	ALPHA_sqrts = `168`
	ALPHA_sqrtt = `169`
	ALPHA_sra = `170`
	ALPHA_srl = `171`
	ALPHA_stb = `172`
	ALPHA_stf = `173`
	ALPHA_stg = `174`
	ALPHA_stl = `176`
	ALPHA_stl_c = `177`
	ALPHA_stq = `178`
	ALPHA_stq_c = `179`
	ALPHA_stq_u = `180`
	ALPHA_sts = `175`
	ALPHA_stt = `181`
	ALPHA_stw = `182`
	ALPHA_subf = `183`
	ALPHA_subg = `184`
	ALPHA_subl = `185`
	ALPHA_subl_v = `186`
	ALPHA_subq = `187`
	ALPHA_subq_v = `188`
	ALPHA_subs = `189`
	ALPHA_subt = `190`
	ALPHA_trapb = `191`
	ALPHA_umulh = `192`
	ALPHA_unop = `200`
	ALPHA_unpkbl = `193`
	ALPHA_unpkbw = `194`
	ALPHA_wh64 = `195`
	ALPHA_wmb = `196`
	ALPHA_xor = `197`
	ALPHA_xornot = `221`
	ALPHA_zap = `198`
	ALPHA_zapnot = `199`
	ARGLOC_REG = `-2147483648`
	ARGLOC_REG2 = `1073741824`
	ARM_adc = `15`
	ARM_add = `14`
	ARM_adr = `44`
	ARM_adrl = `81`
	ARM_and = `10`
	ARM_asr = `5`
	ARM_b = `3`
	ARM_bfc = `273`
	ARM_bfi = `272`
	ARM_bic = `24`
	ARM_bkpt = `45`
	ARM_bl = `4`
	ARM_blx1 = `46`
	ARM_blx2 = `47`
	ARM_bx = `41`
	ARM_bxj = `166`
	ARM_cbnz = `283`
	ARM_cbz = `282`
	ARM_cdp = `83`
	ARM_cdp2 = `84`
	ARM_chka = `292`
	ARM_clrex = `256`
	ARM_clz = `48`
	ARM_cmn = `21`
	ARM_cmp = `20`
	ARM_cps = `169`
	ARM_cpsid = `170`
	ARM_cpsie = `171`
	ARM_dbg = `287`
	ARM_dmb = `285`
	ARM_dsb = `284`
	ARM_enterx = `290`
	ARM_eor = `11`
	ARM_fabsd = `95`
	ARM_fabss = `96`
	ARM_faddd = `97`
	ARM_fadds = `98`
	ARM_fcmpd = `99`
	ARM_fcmped = `101`
	ARM_fcmpes = `102`
	ARM_fcmpezd = `103`
	ARM_fcmpezs = `104`
	ARM_fcmps = `100`
	ARM_fcmpzd = `105`
	ARM_fcmpzs = `106`
	ARM_fcpyd = `107`
	ARM_fcpys = `108`
	ARM_fcvtds = `110`
	ARM_fcvtsd = `109`
	ARM_fdivd = `111`
	ARM_fdivs = `112`
	ARM_fldd = `113`
	ARM_fldmd = `115`
	ARM_fldms = `116`
	ARM_fldmx = `117`
	ARM_flds = `114`
	ARM_fmacd = `118`
	ARM_fmacs = `119`
	ARM_fmdhr = `154`
	ARM_fmdlr = `156`
	ARM_fmdrr = `162`
	ARM_fmrdh = `155`
	ARM_fmrdl = `157`
	ARM_fmrrd = `163`
	ARM_fmrrs = `165`
	ARM_fmrs = `161`
	ARM_fmrx = `159`
	ARM_fmscd = `120`
	ARM_fmscs = `121`
	ARM_fmsr = `160`
	ARM_fmsrr = `164`
	ARM_fmstat = `122`
	ARM_fmuld = `123`
	ARM_fmuls = `124`
	ARM_fmxr = `158`
	ARM_fnegd = `125`
	ARM_fnegs = `126`
	ARM_fnmacd = `127`
	ARM_fnmacs = `128`
	ARM_fnmscd = `129`
	ARM_fnmscs = `130`
	ARM_fnmuld = `131`
	ARM_fnmuls = `132`
	ARM_fsitod = `133`
	ARM_fsitos = `134`
	ARM_fsqrtd = `135`
	ARM_fsqrts = `136`
	ARM_fstd = `137`
	ARM_fstmd = `139`
	ARM_fstms = `140`
	ARM_fstmx = `141`
	ARM_fsts = `138`
	ARM_fsubd = `142`
	ARM_fsubs = `143`
	ARM_ftosid = `144`
	ARM_ftosis = `145`
	ARM_ftosizd = `146`
	ARM_ftosizs = `147`
	ARM_ftouid = `148`
	ARM_ftouis = `149`
	ARM_ftouizd = `150`
	ARM_ftouizs = `151`
	ARM_fuitod = `152`
	ARM_fuitos = `153`
	ARM_hb = `293`
	ARM_hbl = `294`
	ARM_hblp = `295`
	ARM_hbp = `296`
	ARM_isb = `286`
	ARM_it = `278`
	ARM_last = `429`
	ARM_ldc = `85`
	ARM_ldc2 = `86`
	ARM_ldm = `33`
	ARM_ldr = `30`
	ARM_ldrd = `49`
	ARM_ldrex = `172`
	ARM_ldrexb = `257`
	ARM_ldrexd = `258`
	ARM_ldrexh = `259`
	ARM_ldrpc = `31`
	ARM_leavex = `291`
	ARM_lsl = `6`
	ARM_lsr = `7`
	ARM_mcr = `91`
	ARM_mcr2 = `92`
	ARM_mcrr = `93`
	ARM_mcrr2 = `167`
	ARM_mla = `29`
	ARM_mls = `279`
	ARM_mov = `23`
	ARM_movl = `80`
	ARM_movt = `269`
	ARM_mrc = `89`
	ARM_mrc2 = `90`
	ARM_mrrc = `94`
	ARM_mrrc2 = `168`
	ARM_mrs = `26`
	ARM_msr = `27`
	ARM_mul = `28`
	ARM_mvn = `25`
	ARM_neg = `9`
	ARM_nop = `2`
	ARM_null = `0`
	ARM_orn = `268`
	ARM_orr = `22`
	ARM_pkhbt = `173`
	ARM_pkhtb = `174`
	ARM_pld = `50`
	ARM_pli = `276`
	ARM_pop = `42`
	ARM_push = `43`
	ARM_qadd = `51`
	ARM_qadd16 = `175`
	ARM_qadd8 = `176`
	ARM_qaddsubx = `177`
	ARM_qdadd = `52`
	ARM_qdsub = `53`
	ARM_qsub = `54`
	ARM_qsub16 = `178`
	ARM_qsub8 = `179`
	ARM_qsubaddx = `180`
	ARM_rbit = `277`
	ARM_ret = `1`
	ARM_rev = `181`
	ARM_rev16 = `182`
	ARM_revsh = `183`
	ARM_rfe = `184`
	ARM_ror = `8`
	ARM_rrx = `289`
	ARM_rsb = `13`
	ARM_rsc = `17`
	ARM_sadd16 = `185`
	ARM_sadd8 = `186`
	ARM_saddsubx = `187`
	ARM_sbc = `16`
	ARM_sbfx = `270`
	ARM_sdiv = `280`
	ARM_sel = `188`
	ARM_setend = `189`
	ARM_sev = `264`
	ARM_shadd16 = `190`
	ARM_shadd8 = `191`
	ARM_shaddsubx = `192`
	ARM_shsub16 = `193`
	ARM_shsub8 = `194`
	ARM_shsubaddx = `195`
	ARM_smc = `267`
	ARM_smlabb = `55`
	ARM_smlabt = `57`
	ARM_smlad = `196`
	ARM_smladx = `197`
	ARM_smlal = `38`
	ARM_smlalbb = `59`
	ARM_smlalbt = `61`
	ARM_smlald = `200`
	ARM_smlaldx = `201`
	ARM_smlaltb = `60`
	ARM_smlaltt = `62`
	ARM_smlatb = `56`
	ARM_smlatt = `58`
	ARM_smlawb = `63`
	ARM_smlawt = `65`
	ARM_smlsd = `202`
	ARM_smlsdx = `203`
	ARM_smlsld = `206`
	ARM_smlsldx = `207`
	ARM_smmla = `208`
	ARM_smmlar = `209`
	ARM_smmls = `212`
	ARM_smmlsr = `213`
	ARM_smmul = `210`
	ARM_smmulr = `211`
	ARM_smuad = `198`
	ARM_smuadx = `199`
	ARM_smulbb = `67`
	ARM_smulbt = `69`
	ARM_smull = `37`
	ARM_smultb = `68`
	ARM_smultt = `70`
	ARM_smulwb = `64`
	ARM_smulwt = `66`
	ARM_smusd = `204`
	ARM_smusdx = `205`
	ARM_srs = `214`
	ARM_ssat = `215`
	ARM_ssat16 = `216`
	ARM_ssub16 = `217`
	ARM_ssub8 = `218`
	ARM_ssubaddx = `219`
	ARM_stc = `87`
	ARM_stc2 = `88`
	ARM_stm = `34`
	ARM_str = `32`
	ARM_strd = `71`
	ARM_strex = `220`
	ARM_strexb = `260`
	ARM_strexd = `261`
	ARM_strexh = `262`
	ARM_sub = `12`
	ARM_svc = `36`
	ARM_swbkpt = `82`
	ARM_swp = `35`
	ARM_sxtab = `221`
	ARM_sxtab16 = `223`
	ARM_sxtah = `225`
	ARM_sxtb = `222`
	ARM_sxtb16 = `224`
	ARM_sxth = `226`
	ARM_tbb = `274`
	ARM_tbh = `275`
	ARM_teq = `19`
	ARM_tst = `18`
	ARM_uadd16 = `227`
	ARM_uadd8 = `228`
	ARM_uaddsubx = `229`
	ARM_ubfx = `271`
	ARM_udiv = `281`
	ARM_uhadd16 = `230`
	ARM_uhadd8 = `231`
	ARM_uhaddsubx = `232`
	ARM_uhsub16 = `233`
	ARM_uhsub8 = `234`
	ARM_uhsubaddx = `235`
	ARM_umaal = `236`
	ARM_umlal = `40`
	ARM_umull = `39`
	ARM_und = `288`
	ARM_uqadd16 = `237`
	ARM_uqadd8 = `238`
	ARM_uqaddsubx = `239`
	ARM_uqsub16 = `240`
	ARM_uqsub8 = `241`
	ARM_uqsubaddx = `242`
	ARM_usad8 = `244`
	ARM_usada8 = `243`
	ARM_usat = `245`
	ARM_usat16 = `246`
	ARM_usub16 = `247`
	ARM_usub8 = `248`
	ARM_usubaddx = `249`
	ARM_uxtab = `250`
	ARM_uxtab16 = `252`
	ARM_uxtah = `254`
	ARM_uxtb = `251`
	ARM_uxtb16 = `253`
	ARM_uxth = `255`
	ARM_vaba = `297`
	ARM_vabal = `298`
	ARM_vabd = `299`
	ARM_vabdl = `300`
	ARM_vabs = `301`
	ARM_vacge = `302`
	ARM_vacgt = `303`
	ARM_vacle = `304`
	ARM_vaclt = `305`
	ARM_vadd = `306`
	ARM_vaddhn = `307`
	ARM_vaddl = `308`
	ARM_vaddw = `309`
	ARM_vand = `310`
	ARM_vbic = `311`
	ARM_vbif = `312`
	ARM_vbit = `313`
	ARM_vbsl = `314`
	ARM_vceq = `315`
	ARM_vcge = `316`
	ARM_vcgt = `317`
	ARM_vcle = `318`
	ARM_vcls = `319`
	ARM_vclt = `320`
	ARM_vclz = `321`
	ARM_vcmp = `322`
	ARM_vcmpe = `323`
	ARM_vcnt = `324`
	ARM_vcvt = `325`
	ARM_vcvtb = `327`
	ARM_vcvtr = `326`
	ARM_vcvtt = `328`
	ARM_vdiv = `329`
	ARM_vdup = `330`
	ARM_veor = `331`
	ARM_vext = `332`
	ARM_vfma = `333`
	ARM_vfms = `334`
	ARM_vfnma = `335`
	ARM_vfnms = `336`
	ARM_vhadd = `337`
	ARM_vhsub = `338`
	ARM_vld1 = `339`
	ARM_vld2 = `340`
	ARM_vld3 = `341`
	ARM_vld4 = `342`
	ARM_vldm = `343`
	ARM_vldr = `344`
	ARM_vmax = `345`
	ARM_vmin = `346`
	ARM_vmla = `347`
	ARM_vmlal = `348`
	ARM_vmls = `349`
	ARM_vmlsl = `350`
	ARM_vmov = `351`
	ARM_vmovl = `352`
	ARM_vmovn = `353`
	ARM_vmrs = `354`
	ARM_vmsr = `355`
	ARM_vmul = `356`
	ARM_vmull = `357`
	ARM_vmvn = `358`
	ARM_vneg = `359`
	ARM_vnmla = `360`
	ARM_vnmls = `361`
	ARM_vnmul = `362`
	ARM_vorn = `363`
	ARM_vorr = `364`
	ARM_vpadal = `365`
	ARM_vpadd = `366`
	ARM_vpaddl = `367`
	ARM_vpmax = `368`
	ARM_vpmin = `369`
	ARM_vpop = `370`
	ARM_vpush = `371`
	ARM_vqabs = `372`
	ARM_vqadd = `373`
	ARM_vqdmlal = `374`
	ARM_vqdmlsl = `375`
	ARM_vqdmulh = `376`
	ARM_vqdmull = `377`
	ARM_vqmovn = `378`
	ARM_vqmovun = `379`
	ARM_vqneg = `380`
	ARM_vqrdmulh = `381`
	ARM_vqrshl = `382`
	ARM_vqrshrn = `383`
	ARM_vqrshrun = `384`
	ARM_vqshl = `385`
	ARM_vqshlu = `386`
	ARM_vqshrn = `387`
	ARM_vqshrun = `388`
	ARM_vqsub = `389`
	ARM_vraddhn = `390`
	ARM_vrecpe = `391`
	ARM_vrecps = `392`
	ARM_vrev16 = `393`
	ARM_vrev32 = `394`
	ARM_vrev64 = `395`
	ARM_vrhadd = `396`
	ARM_vrshl = `397`
	ARM_vrshr = `398`
	ARM_vrshrn = `399`
	ARM_vrsqrte = `400`
	ARM_vrsqrts = `401`
	ARM_vrsra = `402`
	ARM_vrsubhn = `403`
	ARM_vshl = `404`
	ARM_vshll = `405`
	ARM_vshr = `406`
	ARM_vshrn = `407`
	ARM_vsli = `408`
	ARM_vsqrt = `409`
	ARM_vsra = `410`
	ARM_vsri = `411`
	ARM_vst1 = `412`
	ARM_vst2 = `413`
	ARM_vst3 = `414`
	ARM_vst4 = `415`
	ARM_vstm = `416`
	ARM_vstr = `417`
	ARM_vsub = `418`
	ARM_vsubhn = `419`
	ARM_vsubl = `420`
	ARM_vsubw = `421`
	ARM_vswp = `422`
	ARM_vtbl = `423`
	ARM_vtbx = `424`
	ARM_vtrn = `425`
	ARM_vtst = `426`
	ARM_vuzp = `427`
	ARM_vzip = `428`
	ARM_wfe = `265`
	ARM_wfi = `266`
	ARM_yield = `263`
	AS2_BRACE = `1`
	AS2_BYTE1CHAR = `4`
	AS2_COLONSUF = `32`
	AS2_IDEALDSCR = `8`
	AS2_STRINV = `2`
	AS2_TERSESTR = `16`
	ASB_BINF0 = `0`
	ASB_BINF1 = `131072`
	ASB_BINF2 = `262144`
	ASB_BINF3 = `393216`
	ASB_BINF4 = `524288`
	ASB_BINF5 = `655360`
	ASCF_AUTO = `2`
	ASCF_COMMENT = `16`
	ASCF_GEN = `1`
	ASCF_SAVECASE = `32`
	ASCF_SERIAL = `4`
	ASCF_UNICODE = `8`
	ASCSTR_LAST = `7`
	ASCSTR_LEN2 = `2`
	ASCSTR_LEN4 = `4`
	ASCSTR_PASCAL = `1`
	ASCSTR_TERMCHR = `0`
	ASCSTR_ULEN2 = `5`
	ASCSTR_ULEN4 = `6`
	ASCSTR_UNICODE = `3`
	ASCSTR_UTF16 = `3`
	ASCSTR_UTF32 = `7`
	ASD_DECF0 = `0`
	ASD_DECF1 = `4096`
	ASD_DECF2 = `8192`
	ASD_DECF3 = `12288`
	ASH_HEXF0 = `0`
	ASH_HEXF1 = `512`
	ASH_HEXF2 = `1024`
	ASH_HEXF3 = `1536`
	ASH_HEXF4 = `2048`
	ASH_HEXF5 = `2560`
	ASKBTN_BTN1 = `1`
	ASKBTN_BTN2 = `0`
	ASKBTN_BTN3 = `-1`
	ASKBTN_CANCEL = `-1`
	ASKBTN_NO = `0`
	ASKBTN_YES = `1`
	ASO_OCTF0 = `0`
	ASO_OCTF1 = `16384`
	ASO_OCTF2 = `32768`
	ASO_OCTF3 = `49152`
	ASO_OCTF4 = `65536`
	ASO_OCTF5 = `81920`
	ASO_OCTF6 = `98304`
	AS_1TEXT = `64`
	AS_2CHRE = `8`
	AS_ALIGN2 = `536870912`
	AS_ASCIIC = `1073741824`
	AS_ASCIIZ = `-2147483648`
	AS_BINFM = `917504`
	AS_COLON = `2`
	AS_DECFM = `12288`
	AS_HEXFM = `3584`
	AS_LALIGN = `33554432`
	AS_N2CHR = `32`
	AS_NCHRE = `16`
	AS_NCMAS = `256`
	AS_NHIAS = `128`
	AS_NOCODECLN = `67108864`
	AS_NOSPACE = `268435456`
	AS_NOTAB = `134217728`
	AS_NOXRF = `4194304`
	AS_OCTFM = `114688`
	AS_OFFST = `1`
	AS_ONEDUP = `2097152`
	AS_RELSUP = `16777216`
	AS_UDATA = `4`
	AS_UNEQU = `1048576`
	AS_XTRNTYPE = `8388608`
	AU_CHLB = `90`
	AU_CODE = `20`
	AU_FINAL = `200`
	AU_LBF2 = `70`
	AU_LBF3 = `80`
	AU_LIBF = `60`
	AU_NONE = `0`
	AU_PROC = `30`
	AU_TAIL = `35`
	AU_TRSP = `38`
	AU_TYPE = `50`
	AU_UNK = `10`
	AU_USED = `40`
	AU_WEAK = `25`
	AVR_adc = `2`
	AVR_add = `1`
	AVR_adiw = `3`
	AVR_and = `9`
	AVR_andi = `10`
	AVR_asr = `77`
	AVR_bclr = `80`
	AVR_bld = `84`
	AVR_brbc = `41`
	AVR_brbs = `40`
	AVR_brcc = `45`
	AVR_brcs = `44`
	AVR_breq = `42`
	AVR_brge = `50`
	AVR_brhc = `53`
	AVR_brhs = `52`
	AVR_brid = `59`
	AVR_brie = `58`
	AVR_brlo = `47`
	AVR_brlt = `51`
	AVR_brmi = `48`
	AVR_brne = `43`
	AVR_brpl = `49`
	AVR_brsh = `46`
	AVR_brtc = `55`
	AVR_brts = `54`
	AVR_brvc = `57`
	AVR_brvs = `56`
	AVR_bset = `79`
	AVR_bst = `83`
	AVR_call = `32`
	AVR_cbi = `82`
	AVR_cbr = `17`
	AVR_clc = `86`
	AVR_clh = `100`
	AVR_cli = `92`
	AVR_cln = `88`
	AVR_clr = `21`
	AVR_cls = `94`
	AVR_clt = `98`
	AVR_clv = `96`
	AVR_clz = `90`
	AVR_com = `14`
	AVR_cp = `23`
	AVR_cpc = `24`
	AVR_cpi = `25`
	AVR_cpse = `35`
	AVR_dec = `19`
	AVR_des = `115`
	AVR_eicall = `113`
	AVR_eijmp = `114`
	AVR_elpm = `104`
	AVR_eor = `13`
	AVR_espm = `105`
	AVR_fmul = `106`
	AVR_fmuls = `107`
	AVR_fmulsu = `108`
	AVR_icall = `31`
	AVR_ijmp = `28`
	AVR_in = `69`
	AVR_inc = `18`
	AVR_jmp = `29`
	AVR_lac = `116`
	AVR_las = `117`
	AVR_last = `120`
	AVR_lat = `118`
	AVR_ld = `63`
	AVR_ldd = `64`
	AVR_ldi = `61`
	AVR_lds = `62`
	AVR_lpm = `68`
	AVR_lsl = `73`
	AVR_lsr = `74`
	AVR_mov = `60`
	AVR_movw = `109`
	AVR_mul = `26`
	AVR_muls = `110`
	AVR_mulsu = `111`
	AVR_neg = `15`
	AVR_nop = `101`
	AVR_null = `0`
	AVR_or = `11`
	AVR_ori = `12`
	AVR_out = `70`
	AVR_pop = `72`
	AVR_push = `71`
	AVR_rcall = `30`
	AVR_ret = `33`
	AVR_reti = `34`
	AVR_rjmp = `27`
	AVR_rol = `75`
	AVR_ror = `76`
	AVR_sbc = `6`
	AVR_sbci = `7`
	AVR_sbi = `81`
	AVR_sbic = `38`
	AVR_sbis = `39`
	AVR_sbiw = `8`
	AVR_sbr = `16`
	AVR_sbrc = `36`
	AVR_sbrs = `37`
	AVR_sec = `85`
	AVR_seh = `99`
	AVR_sei = `91`
	AVR_sen = `87`
	AVR_ser = `22`
	AVR_ses = `93`
	AVR_set = `97`
	AVR_sev = `95`
	AVR_sez = `89`
	AVR_sleep = `102`
	AVR_spm = `112`
	AVR_st = `66`
	AVR_std = `67`
	AVR_sts = `65`
	AVR_sub = `4`
	AVR_subi = `5`
	AVR_swap = `78`
	AVR_tst = `20`
	AVR_wdr = `103`
	AVR_xch = `119`
	Appcall = `<idaapi_win32.Appcall__ object at 0x05AA6770>`
	AskUsingForm__ = `<CFunctionType object at 0x05A28F30>`
	BADMEMSIZE = `-559038737`
	BADNODE = `4294967295`
	BADSEL = `4294967295`
	BADSIZE = `4294967295`
	BFI_NOCONST = `1`
	BIN_SEARCH_BACKWARD = `-1`
	BIN_SEARCH_CASE = `1`
	BIN_SEARCH_FORWARD = `1`
	BIN_SEARCH_NOBREAK = `2`
	BIN_SEARCH_NOCASE = `0`
	BKPT_ACTIVE = `8`
	BKPT_BADBPT = `1`
	BKPT_CNDREADY = `32`
	BKPT_FAKEPEND = `64`
	BKPT_LISTBPT = `2`
	BKPT_PAGE = `128`
	BKPT_PARTIAL = `16`
	BKPT_TRACE = `4`
	BPLT_ABS = `0`
	BPLT_REL = `1`
	BPLT_SRC = `3`
	BPLT_SYM = `2`
	BPT_BRK = `1`
	BPT_ENABLED = `8`
	BPT_EXEC = `8`
	BPT_LOWCND = `16`
	BPT_OLD_EXEC = `0`
	BPT_RDWR = `3`
	BPT_READ = `2`
	BPT_SOFT = `4`
	BPT_TRACE = `2`
	BPT_TRACEON = `32`
	BPT_TRACE_BBLK = `256`
	BPT_TRACE_FUNC = `128`
	BPT_TRACE_INSN = `64`
	BPT_TRACE_TYPES = `448`
	BPT_UPDMEM = `4`
	BPT_WRITE = `1`
	BREAKPOINT = `16`
	BTE_ALWAYS = `128`
	BTE_BITFIELD = `16`
	BTE_CHAR = `32`
	BTE_HEX = `0`
	BTE_OUT_MASK = `96`
	BTE_RESERVED = `8`
	BTE_SDEC = `64`
	BTE_SIZE_MASK = `7`
	BTE_UDEC = `96`
	BTF_ENUM = `45`
	BTF_STRUCT = `13`
	BTF_TYPEDEF = `61`
	BTF_UNION = `29`
	BTF_VOID = `1`
	BTMT_ARRESERV = `32`
	BTMT_BFLDI16 = `16`
	BTMT_BFLDI32 = `32`
	BTMT_BFLDI64 = `48`
	BTMT_BFLDI8 = `0`
	BTMT_BOOL1 = `16`
	BTMT_BOOL2 = `32`
	BTMT_BOOL4 = `48`
	BTMT_CHAR = `48`
	BTMT_CLOSURE = `48`
	BTMT_DEFBOOL = `0`
	BTMT_DEFCALL = `0`
	BTMT_DEFPTR = `0`
	BTMT_DOUBLE = `16`
	BTMT_ENUM = `32`
	BTMT_FAR = `32`
	BTMT_FARCALL = `32`
	BTMT_FLOAT = `0`
	BTMT_INTCALL = `48`
	BTMT_LNGDBL = `32`
	BTMT_NEAR = `16`
	BTMT_NEARCALL = `16`
	BTMT_NONBASED = `16`
	BTMT_SIGNED = `16`
	BTMT_SIZE0 = `0`
	BTMT_SIZE12 = `16`
	BTMT_SIZE128 = `48`
	BTMT_SIZE48 = `32`
	BTMT_SPECFLT = `48`
	BTMT_STRUCT = `0`
	BTMT_TYPEDEF = `48`
	BTMT_UNION = `16`
	BTMT_UNKSIGN = `0`
	BTMT_USIGNED = `32`
	BTM_CONST = `64`
	BTM_VOLATILE = `128`
	BTREE_PAGE_SIZE = `8192`
	BT_ARRAY = `11`
	BT_BITFIELD = `14`
	BT_BOOL = `8`
	BT_COMPLEX = `13`
	BT_FLOAT = `9`
	BT_FUNC = `12`
	BT_INT = `7`
	BT_INT128 = `6`
	BT_INT16 = `3`
	BT_INT32 = `4`
	BT_INT64 = `5`
	BT_INT8 = `2`
	BT_PTR = `10`
	BT_RESERVED = `15`
	BT_SEGREG = `55`
	BT_UNK = `0`
	BT_UNKNOWN = `48`
	BT_UNK_BYTE = `17`
	BT_UNK_DWORD = `33`
	BT_UNK_OWORD = `49`
	BT_UNK_QWORD = `32`
	BT_UNK_WORD = `16`
	BT_VOID = `1`
	BWN_BPTS = `13`
	BWN_CALLS = `11`
	BWN_DISASMS = `29`
	BWN_DUMPS = `30`
	BWN_ENUMS = `27`
	BWN_EXPORTS = `0`
	BWN_FRAME = `25`
	BWN_FUNCS = `3`
	BWN_IMPORTS = `1`
	BWN_LOCTYPS = `10`
	BWN_MODULES = `15`
	BWN_NAMES = `2`
	BWN_NAVBAND = `26`
	BWN_NOTEPAD = `31`
	BWN_PROBS = `12`
	BWN_SEARCHS = `19`
	BWN_SEGREGS = `6`
	BWN_SEGS = `5`
	BWN_SELS = `7`
	BWN_SIGNS = `8`
	BWN_STACK = `17`
	BWN_STRINGS = `4`
	BWN_STRUCTS = `28`
	BWN_THREADS = `14`
	BWN_TILS = `9`
	BWN_TRACE = `16`
	BWN_XREFS = `18`
	C166_add = `1`
	C166_addb = `2`
	C166_addc = `3`
	C166_addcb = `4`
	C166_and = `5`
	C166_andb = `6`
	C166_ashr = `7`
	C166_atomic = `8`
	C166_band = `9`
	C166_bclr = `10`
	C166_bcmp = `11`
	C166_bfldh = `12`
	C166_bfldl = `13`
	C166_bmov = `14`
	C166_bmovn = `15`
	C166_bor = `16`
	C166_bset = `17`
	C166_bxor = `18`
	C166_calla = `19`
	C166_calli = `20`
	C166_callr = `21`
	C166_calls = `22`
	C166_cmp = `23`
	C166_cmpb = `24`
	C166_cmpd1 = `25`
	C166_cmpd2 = `26`
	C166_cmpi1 = `27`
	C166_cmpi2 = `28`
	C166_cpl = `29`
	C166_cplb = `30`
	C166_diswdt = `31`
	C166_div = `32`
	C166_divl = `33`
	C166_divlu = `34`
	C166_divu = `35`
	C166_einit = `36`
	C166_enwdt = `103`
	C166_extp = `38`
	C166_extpr = `39`
	C166_extr = `37`
	C166_exts = `40`
	C166_extsr = `41`
	C166_idle = `42`
	C166_jb = `43`
	C166_jbc = `44`
	C166_jmpa = `45`
	C166_jmpi = `46`
	C166_jmpr = `47`
	C166_jmps = `48`
	C166_jnb = `49`
	C166_jnbs = `50`
	C166_last = `105`
	C166_mov = `51`
	C166_movb = `52`
	C166_movbs = `53`
	C166_movbz = `54`
	C166_mul = `55`
	C166_mulu = `56`
	C166_neg = `57`
	C166_negb = `58`
	C166_nop = `59`
	C166_null = `0`
	C166_or = `60`
	C166_orb = `61`
	C166_pcall = `62`
	C166_pop = `63`
	C166_prior = `64`
	C166_push = `65`
	C166_pwrdn = `66`
	C166_ret = `67`
	C166_reti = `68`
	C166_retp = `69`
	C166_rets = `70`
	C166_rol = `71`
	C166_ror = `72`
	C166_sbrk = `104`
	C166_scxt = `73`
	C166_shl = `74`
	C166_shr = `75`
	C166_srst = `76`
	C166_srvwdt = `77`
	C166_sub = `78`
	C166_subb = `79`
	C166_subc = `80`
	C166_subcb = `81`
	C166_trap = `82`
	C166_xor = `83`
	C166_xorb = `84`
	C39_adc = `1`
	C39_add = `2`
	C39_anc = `3`
	C39_and = `4`
	C39_ane = `5`
	C39_arr = `6`
	C39_asl = `7`
	C39_asr = `8`
	C39_bar = `9`
	C39_bas = `10`
	C39_bbr = `11`
	C39_bbs = `12`
	C39_bcc = `13`
	C39_bcs = `14`
	C39_beq = `15`
	C39_bit = `16`
	C39_bmi = `17`
	C39_bne = `18`
	C39_bpl = `19`
	C39_bra = `20`
	C39_brk = `21`
	C39_bvc = `22`
	C39_bvs = `23`
	C39_clc = `24`
	C39_cld = `25`
	C39_cli = `26`
	C39_clv = `27`
	C39_clw = `28`
	C39_cmp = `29`
	C39_cpx = `30`
	C39_cpy = `31`
	C39_dcp = `32`
	C39_dec = `33`
	C39_dex = `34`
	C39_dey = `35`
	C39_eor = `36`
	C39_exc = `37`
	C39_inc = `38`
	C39_ini = `39`
	C39_inx = `40`
	C39_iny = `41`
	C39_isb = `42`
	C39_jmp = `43`
	C39_jpi = `44`
	C39_jsb = `45`
	C39_jsr = `46`
	C39_lab = `47`
	C39_lae = `48`
	C39_lai = `49`
	C39_lan = `50`
	C39_last = `115`
	C39_lax = `51`
	C39_lda = `52`
	C39_ldx = `53`
	C39_ldy = `54`
	C39_lii = `55`
	C39_lsr = `56`
	C39_lxa = `57`
	C39_mpa = `58`
	C39_mpy = `59`
	C39_neg = `60`
	C39_nop = `61`
	C39_null = `0`
	C39_nxt = `62`
	C39_ora = `63`
	C39_pha = `64`
	C39_phi = `65`
	C39_php = `66`
	C39_phw = `67`
	C39_phx = `68`
	C39_phy = `69`
	C39_pia = `70`
	C39_pla = `71`
	C39_pli = `72`
	C39_plp = `73`
	C39_plw = `74`
	C39_plx = `75`
	C39_ply = `76`
	C39_psh = `77`
	C39_pul = `78`
	C39_rba = `79`
	C39_rla = `80`
	C39_rmb = `81`
	C39_rnd = `82`
	C39_rol = `83`
	C39_ror = `84`
	C39_rra = `85`
	C39_rti = `86`
	C39_rts = `87`
	C39_sax = `88`
	C39_sba = `89`
	C39_sbc = `90`
	C39_sbx = `91`
	C39_sec = `92`
	C39_sed = `93`
	C39_sei = `94`
	C39_sha = `95`
	C39_shs = `96`
	C39_shx = `97`
	C39_shy = `98`
	C39_slo = `99`
	C39_smb = `100`
	C39_sre = `101`
	C39_sta = `102`
	C39_sti = `103`
	C39_stx = `104`
	C39_sty = `105`
	C39_taw = `108`
	C39_tax = `106`
	C39_tay = `107`
	C39_tip = `109`
	C39_tsx = `110`
	C39_twa = `111`
	C39_txa = `112`
	C39_txs = `113`
	C39_tya = `114`
	CDVH_LINES_ALIGNMENT = `1009`
	CDVH_LINES_CLICK = `1002`
	CDVH_LINES_DBLCLICK = `1003`
	CDVH_LINES_DRAWICON = `1005`
	CDVH_LINES_ICONMARGIN = `1007`
	CDVH_LINES_LINENUM = `1006`
	CDVH_LINES_POPUP = `1004`
	CDVH_LINES_RADIX = `1008`
	CDVH_SRCVIEW = `1001`
	CDVH_USERDATA = `1000`
	CFG_SUBDIR = `'cfg'`
	CF_CALL = `2`
	CF_CHG1 = `4`
	CF_CHG2 = `8`
	CF_CHG3 = `16`
	CF_CHG4 = `32`
	CF_CHG5 = `64`
	CF_CHG6 = `128`
	CF_HLL = `65536`
	CF_JUMP = `16384`
	CF_SHFT = `32768`
	CF_STOP = `1`
	CF_USE1 = `256`
	CF_USE2 = `512`
	CF_USE3 = `1024`
	CF_USE4 = `2048`
	CF_USE5 = `4096`
	CF_USE6 = `8192`
	CHART_FOLLOW_DIRECTION = `8`
	CHART_GEN_DOT = `8192`
	CHART_GEN_GDL = `16384`
	CHART_IGNORE_DATA_BSS = `32`
	CHART_IGNORE_LIB_FROM = `128`
	CHART_IGNORE_LIB_TO = `64`
	CHART_IGNORE_XTRN = `16`
	CHART_NOLIBFUNCS = `1024`
	CHART_PRINT_COMMENTS = `256`
	CHART_PRINT_DOTS = `512`
	CHART_PRINT_NAMES = `4096`
	CHART_RECURSIVE = `4`
	CHART_REFERENCED = `2`
	CHART_REFERENCING = `1`
	CHART_WINGRAPH = `32768`
	CHOOSER_HOTKEY = `8`
	CHOOSER_MENU_EDIT = `0`
	CHOOSER_MENU_JUMP = `1`
	CHOOSER_MENU_SEARCH = `2`
	CHOOSER_MULTI_SELECTION = `2`
	CHOOSER_NO_SELECTION = `1`
	CHOOSER_POPUP_MENU = `4`
	CM_CC_CDECL = `48`
	CM_CC_ELLIPSIS = `64`
	CM_CC_FASTCALL = `112`
	CM_CC_INVALID = `0`
	CM_CC_MANUAL = `144`
	CM_CC_MASK = `240`
	CM_CC_PASCAL = `96`
	CM_CC_RESERVE3 = `192`
	CM_CC_RESERVE4 = `176`
	CM_CC_SPECIAL = `240`
	CM_CC_SPECIALE = `208`
	CM_CC_SPECIALP = `224`
	CM_CC_SPOILED = `160`
	CM_CC_STDCALL = `80`
	CM_CC_THISCALL = `128`
	CM_CC_UNKNOWN = `16`
	CM_CC_VOIDARG = `32`
	CM_MASK = `3`
	CM_M_FF = `4`
	CM_M_FN = `12`
	CM_M_MASK = `12`
	CM_M_NF = `8`
	CM_M_NN = `0`
	CM_N16_F32 = `2`
	CM_N32_F48 = `3`
	CM_N64 = `1`
	CM_N8_F16 = `1`
	CM_UNKNOWN = `0`
	COLOR_ADDR = `40`
	COLOR_ADDR_SIZE = `8`
	COLOR_ALTOP = `22`
	COLOR_ASMDIR = `27`
	COLOR_AUTOCMT = `4`
	COLOR_BG_MAX = `12`
	COLOR_BINPREF = `20`
	COLOR_CHAR = `10`
	COLOR_CNAME = `37`
	COLOR_CODE = `5`
	COLOR_CODNAME = `26`
	COLOR_COLLAPSED = `39`
	COLOR_CREF = `14`
	COLOR_CREFTAIL = `16`
	COLOR_CURITEM = `9`
	COLOR_CURLINE = `10`
	COLOR_DATA = `6`
	COLOR_DATNAME = `6`
	COLOR_DCHAR = `30`
	COLOR_DEFAULT = `1`
	COLOR_DEMNAME = `8`
	COLOR_DNAME = `7`
	COLOR_DNUM = `31`
	COLOR_DREF = `15`
	COLOR_DREFTAIL = `17`
	COLOR_DSTR = `29`
	COLOR_ERROR = `18`
	COLOR_ESC = `'\x03'`
	COLOR_EXTERN = `8`
	COLOR_EXTRA = `21`
	COLOR_FG_MAX = `40`
	COLOR_HIDLINE = `11`
	COLOR_HIDNAME = `23`
	COLOR_IMPNAME = `34`
	COLOR_INSN = `5`
	COLOR_INV = `'\x04'`
	COLOR_KEYWORD = `32`
	COLOR_LIBFUNC = `3`
	COLOR_LIBNAME = `24`
	COLOR_LOCNAME = `25`
	COLOR_MACRO = `28`
	COLOR_NUMBER = `12`
	COLOR_OFF = `'\x02'`
	COLOR_ON = `'\x01'`
	COLOR_OPND1 = `41`
	COLOR_OPND2 = `42`
	COLOR_OPND3 = `43`
	COLOR_OPND4 = `44`
	COLOR_OPND5 = `45`
	COLOR_OPND6 = `46`
	COLOR_PREFIX = `19`
	COLOR_REG = `33`
	COLOR_REGCMT = `2`
	COLOR_REGFUNC = `4`
	COLOR_RPTCMT = `3`
	COLOR_SEGNAME = `35`
	COLOR_SELECTED = `2`
	COLOR_STRING = `11`
	COLOR_SYMBOL = `9`
	COLOR_UNAME = `38`
	COLOR_UNKNAME = `36`
	COLOR_UNKNOWN = `7`
	COLOR_UTF8 = `50`
	COLOR_VOIDOP = `13`
	COMP_BC = `2`
	COMP_BP = `8`
	COMP_GNU = `6`
	COMP_MASK = `15`
	COMP_MS = `1`
	COMP_UNK = `0`
	COMP_UNSURE = `128`
	COMP_VISAGE = `7`
	COMP_WATCOM = `3`
	CPL_DEL_MACROS = `1`
	CPL_ONLY_SAFE = `4`
	CPL_USE_LABELS = `2`
	CP_UTF16 = `1200`
	CP_UTF8 = `65001`
	CR16_addb = `1`
	CR16_addcb = `5`
	CR16_addcw = `6`
	CR16_addub = `3`
	CR16_adduw = `4`
	CR16_addw = `2`
	CR16_andb = `7`
	CR16_andw = `8`
	CR16_ashub = `9`
	CR16_ashuw = `10`
	CR16_bal = `26`
	CR16_bcc = `14`
	CR16_bcs = `13`
	CR16_beq = `11`
	CR16_beq0b = `31`
	CR16_beq0w = `32`
	CR16_beq1b = `29`
	CR16_beq1w = `30`
	CR16_bfc = `20`
	CR16_bfs = `19`
	CR16_bge = `24`
	CR16_bgt = `17`
	CR16_bhi = `15`
	CR16_bhs = `22`
	CR16_ble = `18`
	CR16_blo = `21`
	CR16_bls = `16`
	CR16_blt = `23`
	CR16_bne = `12`
	CR16_bne0b = `35`
	CR16_bne0w = `36`
	CR16_bne1b = `33`
	CR16_bne1w = `34`
	CR16_br = `25`
	CR16_cbitb = `106`
	CR16_cbitw = `107`
	CR16_cmpb = `27`
	CR16_cmpw = `28`
	CR16_di = `37`
	CR16_ei = `38`
	CR16_eiwait = `109`
	CR16_excp = `39`
	CR16_jal = `55`
	CR16_jcc = `43`
	CR16_jcs = `42`
	CR16_jeq = `40`
	CR16_jfc = `49`
	CR16_jfs = `48`
	CR16_jge = `53`
	CR16_jgt = `46`
	CR16_jhi = `44`
	CR16_jhs = `51`
	CR16_jle = `47`
	CR16_jlo = `50`
	CR16_jls = `45`
	CR16_jlt = `52`
	CR16_jne = `41`
	CR16_jump = `54`
	CR16_last = `112`
	CR16_loadb = `56`
	CR16_loadm = `58`
	CR16_loadw = `57`
	CR16_lpr = `59`
	CR16_lshb = `60`
	CR16_lshw = `61`
	CR16_movb = `62`
	CR16_movd = `66`
	CR16_movw = `63`
	CR16_movxb = `64`
	CR16_movzb = `65`
	CR16_mulb = `67`
	CR16_mulsb = `69`
	CR16_mulsw = `70`
	CR16_muluw = `71`
	CR16_mulw = `68`
	CR16_nop = `72`
	CR16_null = `0`
	CR16_orb = `73`
	CR16_orw = `74`
	CR16_pop = `76`
	CR16_popret = `77`
	CR16_push = `75`
	CR16_retx = `78`
	CR16_sbitb = `104`
	CR16_sbitw = `105`
	CR16_scc = `82`
	CR16_scs = `81`
	CR16_seq = `79`
	CR16_sfc = `88`
	CR16_sfs = `87`
	CR16_sge = `92`
	CR16_sgt = `85`
	CR16_shi = `83`
	CR16_shs = `90`
	CR16_sle = `86`
	CR16_slo = `89`
	CR16_sls = `84`
	CR16_slt = `91`
	CR16_sne = `80`
	CR16_spr = `93`
	CR16_storb = `94`
	CR16_storm = `96`
	CR16_storw = `95`
	CR16_subb = `97`
	CR16_subcb = `99`
	CR16_subcw = `100`
	CR16_subw = `98`
	CR16_tbit = `101`
	CR16_tbitb = `102`
	CR16_tbitw = `103`
	CR16_wait = `108`
	CR16_xorb = `110`
	CR16_xorw = `111`
	CSS_NOAREA = `-2`
	CSS_NODBG = `-1`
	CSS_NOMEM = `-3`
	CSS_OK = `0`
	CURLOC_SISTACK_ITEMS = `4`
	CUSTOM_CMD_ITYPE = `32768`
	CVH_CLICK = `6`
	CVH_CLOSE = `5`
	CVH_CURPOS = `4`
	CVH_DBLCLICK = `3`
	CVH_KEYDOWN = `1`
	CVH_POPUP = `2`
	CVH_QT_AWARE = `7`
	CVH_USERDATA = `0`
	C_PC_COMPACT = `10`
	C_PC_FLAT = `3`
	C_PC_HUGE = `6`
	C_PC_LARGE = `6`
	C_PC_MEDIUM = `14`
	C_PC_SMALL = `2`
	C_PC_TINY = `2`
	DEBNAME_EXACT = `0`
	DEBNAME_LOWER = `1`
	DEBNAME_NICE = `3`
	DEBNAME_UPPER = `2`
	DEC_ERROR = `-1`
	DEC_NOTASK = `-2`
	DEC_TIMEOUT = `0`
	DEFAULT_LNNUM = `65535`
	DEFAULT_MODE = `0`
	DEMNAM_CMNT = `0`
	DEMNAM_GCC3 = `4`
	DEMNAM_MASK = `3`
	DEMNAM_NAME = `1`
	DEMNAM_NONE = `2`
	DOPT_BPT_MSGS = `16`
	DOPT_ENTRY_BPT = `4096`
	DOPT_EXCDLG = `24576`
	DOPT_INFO_BPT = `512`
	DOPT_INFO_MSGS = `256`
	DOPT_LIB_BPT = `128`
	DOPT_LIB_MSGS = `64`
	DOPT_LOAD_DINFO = `32768`
	DOPT_REAL_MEMORY = `1024`
	DOPT_REDO_STACK = `2048`
	DOPT_SEGM_MSGS = `1`
	DOPT_START_BPT = `2`
	DOPT_THREAD_BPT = `8`
	DOPT_THREAD_MSGS = `4`
	DOUNK_DELNAMES = `2`
	DOUNK_EXPAND = `1`
	DOUNK_SIMPLE = `0`
	DP_BEFORE = `32`
	DP_BOTTOM = `8`
	DP_FLOATING = `128`
	DP_INSIDE = `16`
	DP_LEFT = `1`
	DP_RAW = `64`
	DP_RIGHT = `4`
	DP_TOP = `2`
	DSP56_abs = `1`
	DSP56_adc = `2`
	DSP56_add = `3`
	DSP56_addl = `4`
	DSP56_addr = `5`
	DSP56_and = `6`
	DSP56_andi = `7`
	DSP56_asl = `8`
	DSP56_asl4 = `9`
	DSP56_asr = `10`
	DSP56_asr16 = `12`
	DSP56_asr4 = `11`
	DSP56_bcc = `18`
	DSP56_bchg = `19`
	DSP56_bclr = `20`
	DSP56_bfchg = `13`
	DSP56_bfclr = `14`
	DSP56_bfset = `15`
	DSP56_bftsth = `16`
	DSP56_bftstl = `17`
	DSP56_bra = `21`
	DSP56_brclr = `22`
	DSP56_brkcc = `23`
	DSP56_brset = `24`
	DSP56_bscc = `25`
	DSP56_bsclr = `26`
	DSP56_bset = `27`
	DSP56_bsr = `28`
	DSP56_bsset = `29`
	DSP56_btst = `30`
	DSP56_chkaau = `31`
	DSP56_clb = `32`
	DSP56_clr = `33`
	DSP56_clr24 = `34`
	DSP56_cmp = `35`
	DSP56_cmpm = `36`
	DSP56_cmpu = `37`
	DSP56_debug = `38`
	DSP56_debugcc = `39`
	DSP56_dec = `40`
	DSP56_dec24 = `41`
	DSP56_div = `42`
	DSP56_dmac = `43`
	DSP56_do = `44`
	DSP56_do_f = `45`
	DSP56_dor = `46`
	DSP56_dor_f = `47`
	DSP56_enddo = `48`
	DSP56_eor = `49`
	DSP56_ext = `52`
	DSP56_extract = `50`
	DSP56_extractu = `51`
	DSP56_ill = `53`
	DSP56_imac = `54`
	DSP56_impy = `55`
	DSP56_inc = `56`
	DSP56_inc24 = `57`
	DSP56_insert = `58`
	DSP56_jcc = `59`
	DSP56_jclr = `60`
	DSP56_jmp = `61`
	DSP56_jscc = `62`
	DSP56_jsclr = `63`
	DSP56_jset = `64`
	DSP56_jsr = `65`
	DSP56_jsset = `66`
	DSP56_last = `133`
	DSP56_lea = `71`
	DSP56_lra = `67`
	DSP56_lsl = `68`
	DSP56_lsr = `69`
	DSP56_lua = `70`
	DSP56_mac = `72`
	DSP56_mac_s_u = `74`
	DSP56_maci = `73`
	DSP56_macr = `75`
	DSP56_macri = `76`
	DSP56_max = `77`
	DSP56_maxm = `78`
	DSP56_merge = `79`
	DSP56_move = `80`
	DSP56_movec = `81`
	DSP56_movei = `82`
	DSP56_movem = `83`
	DSP56_movep = `84`
	DSP56_moves = `85`
	DSP56_mpy = `86`
	DSP56_mpy_s_u = `88`
	DSP56_mpyi = `87`
	DSP56_mpyr = `89`
	DSP56_mpyri = `90`
	DSP56_neg = `91`
	DSP56_negc = `92`
	DSP56_nop = `93`
	DSP56_norm = `94`
	DSP56_normf = `95`
	DSP56_not = `96`
	DSP56_null = `0`
	DSP56_or = `97`
	DSP56_ori = `98`
	DSP56_pflush = `99`
	DSP56_pflushun = `100`
	DSP56_pfree = `101`
	DSP56_plock = `102`
	DSP56_plockr = `103`
	DSP56_pmov = `132`
	DSP56_punlock = `104`
	DSP56_punlockr = `105`
	DSP56_rep = `106`
	DSP56_repcc = `107`
	DSP56_reset = `108`
	DSP56_rnd = `109`
	DSP56_rol = `110`
	DSP56_ror = `111`
	DSP56_rti = `112`
	DSP56_rts = `113`
	DSP56_sbc = `114`
	DSP56_stop = `115`
	DSP56_sub = `116`
	DSP56_subl = `117`
	DSP56_subr = `118`
	DSP56_swap = `119`
	DSP56_swi = `131`
	DSP56_tcc = `120`
	DSP56_tfr = `121`
	DSP56_tfr2 = `122`
	DSP56_tfr3 = `123`
	DSP56_trap = `124`
	DSP56_trapcc = `125`
	DSP56_tst = `126`
	DSP56_tst2 = `127`
	DSP56_vsl = `128`
	DSP56_wait = `129`
	DSP56_zero = `130`
	DTP_NODUP = `1`
	DT_TYPE = `-268435456`
	ENUM_FLAGS_FROMTIL = `4`
	ENUM_FLAGS_WIDTH = `56`
	ENUM_MEMBER_ERROR_ENUM = `3`
	ENUM_MEMBER_ERROR_ILLV = `5`
	ENUM_MEMBER_ERROR_MASK = `4`
	ENUM_MEMBER_ERROR_NAME = `1`
	ENUM_MEMBER_ERROR_VALUE = `2`
	EXCDLG_ALWAYS = `24576`
	EXCDLG_NEVER = `0`
	EXCDLG_UNKNOWN = `8192`
	EXCEPTION = `64`
	EXC_BREAK = `1`
	EXC_HANDLE = `2`
	EXTFUN_BASE = `1`
	EXTFUN_NORET = `2`
	EXTFUN_SAFE = `4`
	E_NEXT = `2000`
	E_PREV = `1000`
	F2MC_adb = `120`
	F2MC_add = `8`
	F2MC_addc1 = `9`
	F2MC_addc2 = `10`
	F2MC_addcw = `18`
	F2MC_adddc = `11`
	F2MC_addl = `22`
	F2MC_addsp = `118`
	F2MC_addw1 = `16`
	F2MC_addw2 = `17`
	F2MC_and = `49`
	F2MC_andl = `60`
	F2MC_andw1 = `53`
	F2MC_andw2 = `54`
	F2MC_asr = `68`
	F2MC_asrl = `77`
	F2MC_asrw1 = `71`
	F2MC_asrw2 = `72`
	F2MC_bbc = `129`
	F2MC_bbc16 = `170`
	F2MC_bbs = `130`
	F2MC_bbs16 = `171`
	F2MC_bc = `82`
	F2MC_bc16 = `152`
	F2MC_bge = `91`
	F2MC_bge16 = `161`
	F2MC_bgt = `93`
	F2MC_bgt16 = `163`
	F2MC_bhi = `95`
	F2MC_bhi16 = `165`
	F2MC_ble = `92`
	F2MC_ble16 = `162`
	F2MC_bls = `94`
	F2MC_bls16 = `164`
	F2MC_blt = `90`
	F2MC_blt16 = `160`
	F2MC_bn = `84`
	F2MC_bn16 = `154`
	F2MC_bnc = `83`
	F2MC_bnc16 = `153`
	F2MC_bnt = `89`
	F2MC_bnt16 = `159`
	F2MC_bnv = `87`
	F2MC_bnv16 = `157`
	F2MC_bnz = `81`
	F2MC_bnz16 = `151`
	F2MC_bp = `85`
	F2MC_bp16 = `155`
	F2MC_bra = `96`
	F2MC_bt = `88`
	F2MC_bt16 = `158`
	F2MC_bv = `86`
	F2MC_bv16 = `156`
	F2MC_bz = `80`
	F2MC_bz16 = `150`
	F2MC_call = `99`
	F2MC_callp = `101`
	F2MC_callv = `100`
	F2MC_cbne = `102`
	F2MC_cbne16 = `166`
	F2MC_clrb = `128`
	F2MC_cmp1 = `30`
	F2MC_cmp2 = `31`
	F2MC_cmpl = `34`
	F2MC_cmpw1 = `32`
	F2MC_cmpw2 = `33`
	F2MC_cmr = `125`
	F2MC_cwbne = `103`
	F2MC_cwbne16 = `167`
	F2MC_dbnz = `104`
	F2MC_dbnz16 = `168`
	F2MC_dec = `25`
	F2MC_decl = `29`
	F2MC_decw = `27`
	F2MC_div1 = `42`
	F2MC_div2 = `43`
	F2MC_divu1 = `35`
	F2MC_divu2 = `36`
	F2MC_divuw = `37`
	F2MC_divw = `44`
	F2MC_dtb = `121`
	F2MC_dwbnz = `105`
	F2MC_dwbnz16 = `169`
	F2MC_ext = `136`
	F2MC_extw = `137`
	F2MC_filsi = `144`
	F2MC_filswi = `149`
	F2MC_inc = `24`
	F2MC_incl = `28`
	F2MC_incw = `26`
	F2MC_int = `106`
	F2MC_int9 = `108`
	F2MC_intp = `107`
	F2MC_jctx = `116`
	F2MC_jmp = `97`
	F2MC_jmpp = `98`
	F2MC_last = `173`
	F2MC_link = `110`
	F2MC_lsl = `70`
	F2MC_lsll = `79`
	F2MC_lslw1 = `75`
	F2MC_lslw2 = `76`
	F2MC_lsr = `69`
	F2MC_lsrl = `78`
	F2MC_lsrw1 = `73`
	F2MC_lsrw2 = `74`
	F2MC_mov = `1`
	F2MC_movb = `126`
	F2MC_movea = `117`
	F2MC_movl = `7`
	F2MC_movn = `2`
	F2MC_movsd = `141`
	F2MC_movsi = `140`
	F2MC_movswd = `146`
	F2MC_movswi = `145`
	F2MC_movw = `5`
	F2MC_movx = `3`
	F2MC_mul1 = `45`
	F2MC_mul2 = `46`
	F2MC_mulu1 = `38`
	F2MC_mulu2 = `39`
	F2MC_muluw1 = `40`
	F2MC_muluw2 = `41`
	F2MC_mulw1 = `47`
	F2MC_mulw2 = `48`
	F2MC_ncc = `124`
	F2MC_neg = `63`
	F2MC_negw = `64`
	F2MC_nop = `119`
	F2MC_not = `52`
	F2MC_notw = `59`
	F2MC_nrml = `65`
	F2MC_null = `0`
	F2MC_or = `50`
	F2MC_orl = `61`
	F2MC_orw1 = `55`
	F2MC_orw2 = `56`
	F2MC_pcb = `122`
	F2MC_popw = `115`
	F2MC_pushw = `114`
	F2MC_ret = `112`
	F2MC_reti = `109`
	F2MC_retp = `113`
	F2MC_rolc = `67`
	F2MC_rorc = `66`
	F2MC_sbbs = `131`
	F2MC_sbbs16 = `172`
	F2MC_sceqd = `143`
	F2MC_sceqi = `142`
	F2MC_scweqd = `148`
	F2MC_scweqi = `147`
	F2MC_setb = `127`
	F2MC_spb = `123`
	F2MC_sub = `12`
	F2MC_subc1 = `13`
	F2MC_subc2 = `14`
	F2MC_subcw = `21`
	F2MC_subdc = `15`
	F2MC_subl = `23`
	F2MC_subw1 = `19`
	F2MC_subw2 = `20`
	F2MC_swap = `134`
	F2MC_swapw = `135`
	F2MC_unlink = `111`
	F2MC_wbtc = `133`
	F2MC_wbts = `132`
	F2MC_xch = `4`
	F2MC_xchw = `6`
	F2MC_xor = `51`
	F2MC_xorl = `62`
	F2MC_xorw1 = `57`
	F2MC_xorw2 = `58`
	F2MC_zext = `138`
	F2MC_zextw = `139`
	FC_APPND = `8`
	FC_NOEXT = `2`
	FC_PREDS = `4`
	FC_PRINT = `1`
	FF_0CHAR = `3145728`
	FF_0CUST = `13631488`
	FF_0ENUM = `8388608`
	FF_0FLT = `12582912`
	FF_0FOP = `9437184`
	FF_0NUMB = `6291456`
	FF_0NUMD = `2097152`
	FF_0NUMH = `1048576`
	FF_0NUMO = `7340032`
	FF_0OFF = `5242880`
	FF_0SEG = `4194304`
	FF_0STK = `11534336`
	FF_0STRO = `10485760`
	FF_0VOID = `0`
	FF_1CHAR = `50331648`
	FF_1CUST = `218103808`
	FF_1ENUM = `134217728`
	FF_1FLT = `201326592`
	FF_1FOP = `150994944`
	FF_1NUMB = `100663296`
	FF_1NUMD = `33554432`
	FF_1NUMH = `16777216`
	FF_1NUMO = `117440512`
	FF_1OFF = `83886080`
	FF_1SEG = `67108864`
	FF_1STK = `184549376`
	FF_1STRO = `167772160`
	FF_1VOID = `0`
	FF_3BYTE = `-1073741824`
	FF_ALIGN = `-1342177280`
	FF_ANYNAME = `49152`
	FF_ASCI = `1342177280`
	FF_BNOT = `262144`
	FF_BYTE = `0`
	FF_CODE = `1536`
	FF_COMM = `2048`
	FF_CUSTOM = `-805306368`
	FF_DATA = `1024`
	FF_DOUBLE = `-1879048192`
	FF_DWRD = `536870912`
	FF_FLOAT = `-2147483648`
	FF_FLOW = `65536`
	FF_FUNC = `268435456`
	FF_IMMD = `1073741824`
	FF_IVL = `256`
	FF_JUMP = `-2147483648`
	FF_LABL = `32768`
	FF_LINE = `8192`
	FF_NAME = `16384`
	FF_OWRD = `1879048192`
	FF_PACKREAL = `-1610612736`
	FF_QWRD = `805306368`
	FF_REF = `4096`
	FF_SIGN = `131072`
	FF_STRU = `1610612736`
	FF_TAIL = `512`
	FF_TBYT = `1073741824`
	FF_UNK = `0`
	FF_VAR = `524288`
	FF_WORD = `268435456`
	FILEREG_NOTPATCHABLE = `0`
	FILEREG_PATCHABLE = `1`
	FIND_FUNC_DEFINE = `1`
	FIND_FUNC_EXIST = `2`
	FIND_FUNC_IGNOREFN = `2`
	FIND_FUNC_NORMAL = `0`
	FIND_FUNC_OK = `1`
	FIND_FUNC_UNDEF = `0`
	FIXUP_CREATED = `128`
	FIXUP_CUSTOM = `15`
	FIXUP_EXTDEF = `32`
	FIXUP_HI16 = `7`
	FIXUP_HI8 = `6`
	FIXUP_LOW16 = `9`
	FIXUP_LOW8 = `8`
	FIXUP_MASK = `15`
	FIXUP_OFF16 = `1`
	FIXUP_OFF32 = `4`
	FIXUP_OFF64 = `12`
	FIXUP_OFF8 = `0`
	FIXUP_PTR16 = `3`
	FIXUP_PTR32 = `5`
	FIXUP_REL = `16`
	FIXUP_SEG16 = `2`
	FIXUP_SELFREL = `0`
	FIXUP_UNUSED = `64`
	FIXUP_VHIGH = `10`
	FIXUP_VLOW = `11`
	FMT_64 = `'ll'`
	FMT_EA = `''`
	FMT_Z = `'zu'`
	FMT_ZS = `'zd'`
	FTI_SPOILED = `1`
	FUNC_BOTTOMBP = `256`
	FUNC_FAR = `2`
	FUNC_FRAME = `16`
	FUNC_HIDDEN = `64`
	FUNC_IMPORT_PREFIX = `'__imp_'`
	FUNC_LIB = `4`
	FUNC_NORET = `1`
	FUNC_NORET_PENDING = `512`
	FUNC_PURGED_OK = `16384`
	FUNC_SP_READY = `1024`
	FUNC_STATICDEF = `8`
	FUNC_TAIL = `32768`
	FUNC_THUNK = `128`
	FUNC_USERFAR = `32`
	GB_ldh = `250`
	GB_stop = `251`
	GENDSM_FORCE_CODE = `1`
	GENDSM_MULTI_LINE = `2`
	GENFLG_ASMINC = `64`
	GENFLG_ASMTYPE = `16`
	GENFLG_GENHTML = `32`
	GENFLG_IDCTYPE = `8`
	GENFLG_MAPDMNG = `4`
	GENFLG_MAPLOC = `8`
	GENFLG_MAPNAME = `2`
	GENFLG_MAPSEG = `1`
	GETN_APPZERO = `1`
	GETN_NODUMMY = `4`
	GETN_NOFIXUP = `2`
	GFE_NOVALUE = `1`
	GNCN_NOCOLOR = `2`
	GNCN_NODBGNM = `256`
	GNCN_NOFUNC = `8`
	GNCN_NOLABEL = `4`
	GNCN_NOSEG = `1`
	GNCN_REQFUNC = `64`
	GNCN_REQNAME = `128`
	GNCN_SEGNUM = `32`
	GNCN_SEG_FUNC = `16`
	GUESS_FUNC_FAILED = `0`
	GUESS_FUNC_OK = `2`
	GUESS_FUNC_TRIVIAL = `1`
	GetLastError = `<_FuncPtr object at 0x05A28BE8>`
	H8500_add_g = `13`
	H8500_add_q = `14`
	H8500_adds = `16`
	H8500_addx = `18`
	H8500_and = `33`
	H8500_andc = `83`
	H8500_bcc = `53`
	H8500_bclr = `46`
	H8500_bcs = `54`
	H8500_beq = `56`
	H8500_bge = `61`
	H8500_bgt = `63`
	H8500_bhi = `51`
	H8500_ble = `64`
	H8500_bls = `52`
	H8500_blt = `62`
	H8500_bmi = `60`
	H8500_bne = `55`
	H8500_bnot = `47`
	H8500_bpl = `59`
	H8500_bpt = `87`
	H8500_bra = `49`
	H8500_brn = `50`
	H8500_bset = `45`
	H8500_bsr = `67`
	H8500_btst = `48`
	H8500_bvc = `57`
	H8500_bvs = `58`
	H8500_clr = `31`
	H8500_cmp_e = `25`
	H8500_cmp_g = `24`
	H8500_cmp_i = `26`
	H8500_dadd = `20`
	H8500_divxu = `23`
	H8500_dsub = `21`
	H8500_exts = `27`
	H8500_extu = `28`
	H8500_jmp = `65`
	H8500_jsr = `68`
	H8500_last = `88`
	H8500_ldc = `81`
	H8500_ldm = `7`
	H8500_link = `78`
	H8500_mov_e = `2`
	H8500_mov_f = `4`
	H8500_mov_g = `1`
	H8500_mov_i = `3`
	H8500_mov_l = `5`
	H8500_mov_s = `6`
	H8500_movfpe = `12`
	H8500_movtpe = `11`
	H8500_mulxu = `22`
	H8500_neg = `30`
	H8500_nop = `86`
	H8500_not = `36`
	H8500_null = `0`
	H8500_or = `34`
	H8500_orc = `84`
	H8500_pjmp = `66`
	H8500_pjsr = `69`
	H8500_prtd = `73`
	H8500_prts = `71`
	H8500_rotl = `41`
	H8500_rotr = `42`
	H8500_rotxl = `43`
	H8500_rotxr = `44`
	H8500_rtd = `72`
	H8500_rte = `77`
	H8500_rts = `70`
	H8500_scb = `74`
	H8500_shal = `37`
	H8500_shar = `38`
	H8500_shll = `39`
	H8500_shlr = `40`
	H8500_sleep = `80`
	H8500_stc = `82`
	H8500_stm = `8`
	H8500_sub = `15`
	H8500_subs = `17`
	H8500_subx = `19`
	H8500_swap = `10`
	H8500_tas = `32`
	H8500_trap_vs = `76`
	H8500_trapa = `75`
	H8500_tst = `29`
	H8500_unlk = `79`
	H8500_xch = `9`
	H8500_xor = `35`
	H8500_xorc = `85`
	H8_add = `1`
	H8_adds = `2`
	H8_addx = `3`
	H8_and = `4`
	H8_andc = `5`
	H8_band = `6`
	H8_bcc = `11`
	H8_bclr = `23`
	H8_bcs = `12`
	H8_beq = `14`
	H8_bge = `19`
	H8_bgt = `21`
	H8_bhi = `9`
	H8_biand = `24`
	H8_bild = `25`
	H8_bior = `26`
	H8_bist = `27`
	H8_bixor = `28`
	H8_bld = `29`
	H8_ble = `22`
	H8_bls = `10`
	H8_blt = `20`
	H8_bmi = `18`
	H8_bne = `13`
	H8_bnot = `30`
	H8_bor = `31`
	H8_bpl = `17`
	H8_bra = `7`
	H8_brn = `8`
	H8_bset = `32`
	H8_bsr = `33`
	H8_bst = `34`
	H8_btst = `35`
	H8_bvc = `15`
	H8_bvs = `16`
	H8_bxor = `36`
	H8_clrmac = `37`
	H8_cmp = `38`
	H8_daa = `39`
	H8_das = `40`
	H8_dec = `41`
	H8_divxs = `42`
	H8_divxu = `43`
	H8_eepmov = `44`
	H8_exts = `45`
	H8_extu = `46`
	H8_inc = `47`
	H8_jmp = `48`
	H8_jsr = `49`
	H8_last = `87`
	H8_ldc = `50`
	H8_ldm = `51`
	H8_ldmac = `52`
	H8_mac = `53`
	H8_mov = `54`
	H8_movfpe = `55`
	H8_movtpe = `56`
	H8_mulxs = `57`
	H8_mulxu = `58`
	H8_neg = `59`
	H8_nop = `60`
	H8_not = `61`
	H8_null = `0`
	H8_or = `62`
	H8_orc = `63`
	H8_pop = `64`
	H8_push = `65`
	H8_rotl = `66`
	H8_rotr = `67`
	H8_rotxl = `68`
	H8_rotxr = `69`
	H8_rte = `70`
	H8_rts = `71`
	H8_shal = `72`
	H8_shar = `73`
	H8_shll = `74`
	H8_shlr = `75`
	H8_sleep = `76`
	H8_stc = `77`
	H8_stm = `78`
	H8_stmac = `79`
	H8_sub = `80`
	H8_subs = `81`
	H8_subx = `82`
	H8_tas = `83`
	H8_trapa = `84`
	H8_xor = `85`
	H8_xorc = `86`
	HD_in0 = `139`
	HD_mlt = `140`
	HD_otdm = `143`
	HD_otdmr = `144`
	HD_otim = `141`
	HD_otimr = `142`
	HD_out0 = `145`
	HD_slp = `146`
	HD_tst = `147`
	HD_tstio = `148`
	HIST_ADDR = `4`
	HIST_CMD = `9`
	HIST_CMT = `2`
	HIST_DIR = `10`
	HIST_FILE = `7`
	HIST_IDENT = `5`
	HIST_NUM = `6`
	HIST_SEG = `1`
	HIST_SRCH = `3`
	HIST_TYPE = `8`
	HPPA_add = `1`
	HPPA_addb = `2`
	HPPA_addi = `3`
	HPPA_addib = `4`
	HPPA_addil = `5`
	HPPA_and = `6`
	HPPA_andcm = `7`
	HPPA_b = `8`
	HPPA_bb = `9`
	HPPA_be = `10`
	HPPA_blr = `11`
	HPPA_break = `12`
	HPPA_bv = `13`
	HPPA_bve = `14`
	HPPA_call = `134`
	HPPA_cldd = `15`
	HPPA_cldw = `16`
	HPPA_clrbts = `17`
	HPPA_cmpb = `18`
	HPPA_cmpclr = `19`
	HPPA_cmpib = `20`
	HPPA_cmpiclr = `21`
	HPPA_copr = `22`
	HPPA_copy = `141`
	HPPA_cstd = `23`
	HPPA_cstw = `24`
	HPPA_dcor = `25`
	HPPA_depd = `26`
	HPPA_depdi = `27`
	HPPA_depw = `28`
	HPPA_depwi = `29`
	HPPA_diag = `30`
	HPPA_ds = `31`
	HPPA_extrd = `32`
	HPPA_extrw = `33`
	HPPA_fabs = `108`
	HPPA_fadd = `109`
	HPPA_fcmp = `110`
	HPPA_fcnv = `111`
	HPPA_fcpy = `112`
	HPPA_fdc = `34`
	HPPA_fdce = `35`
	HPPA_fdiv = `113`
	HPPA_fic = `36`
	HPPA_fice = `37`
	HPPA_fid = `114`
	HPPA_fldd = `115`
	HPPA_fldw = `116`
	HPPA_fmpy = `117`
	HPPA_fmpyadd = `118`
	HPPA_fmpyfadd = `119`
	HPPA_fmpynfadd = `120`
	HPPA_fmpysub = `121`
	HPPA_fneg = `122`
	HPPA_fnegabs = `123`
	HPPA_frem = `124`
	HPPA_frnd = `125`
	HPPA_fsqrt = `126`
	HPPA_fstd = `127`
	HPPA_fstw = `128`
	HPPA_fsub = `129`
	HPPA_ftest = `130`
	HPPA_hadd = `38`
	HPPA_havg = `39`
	HPPA_hshl = `40`
	HPPA_hshladd = `41`
	HPPA_hshr = `42`
	HPPA_hshradd = `43`
	HPPA_hsub = `44`
	HPPA_idtlbt = `45`
	HPPA_iitlbt = `46`
	HPPA_last = `144`
	HPPA_lci = `47`
	HPPA_ldb = `48`
	HPPA_ldcd = `49`
	HPPA_ldcw = `50`
	HPPA_ldd = `51`
	HPPA_ldda = `52`
	HPPA_ldh = `53`
	HPPA_ldi = `140`
	HPPA_ldil = `54`
	HPPA_ldo = `55`
	HPPA_ldsid = `56`
	HPPA_ldw = `57`
	HPPA_ldwa = `58`
	HPPA_lpa = `59`
	HPPA_mfctl = `60`
	HPPA_mfia = `61`
	HPPA_mfsp = `62`
	HPPA_mixh = `63`
	HPPA_mixw = `64`
	HPPA_movb = `65`
	HPPA_movib = `66`
	HPPA_mtctl = `67`
	HPPA_mtsar = `142`
	HPPA_mtsarcm = `68`
	HPPA_mtsm = `69`
	HPPA_mtsp = `70`
	HPPA_nop = `143`
	HPPA_null = `0`
	HPPA_or = `71`
	HPPA_pdc = `72`
	HPPA_pdtlb = `73`
	HPPA_pdtlbe = `74`
	HPPA_permh = `75`
	HPPA_pitlb = `76`
	HPPA_pitlbe = `77`
	HPPA_pmdis = `132`
	HPPA_pmenb = `133`
	HPPA_popbts = `78`
	HPPA_probe = `79`
	HPPA_probei = `80`
	HPPA_pushbts = `81`
	HPPA_pushnom = `82`
	HPPA_ret = `135`
	HPPA_rfi = `83`
	HPPA_rsm = `84`
	HPPA_shladd = `85`
	HPPA_shld = `136`
	HPPA_shlw = `137`
	HPPA_shrd = `138`
	HPPA_shrpd = `86`
	HPPA_shrpw = `87`
	HPPA_shrw = `139`
	HPPA_spop0 = `88`
	HPPA_spop1 = `89`
	HPPA_spop2 = `90`
	HPPA_spop3 = `91`
	HPPA_ssm = `92`
	HPPA_stb = `93`
	HPPA_stby = `94`
	HPPA_std = `95`
	HPPA_stda = `96`
	HPPA_stdby = `97`
	HPPA_sth = `98`
	HPPA_stw = `99`
	HPPA_stwa = `100`
	HPPA_sub = `101`
	HPPA_subi = `102`
	HPPA_sync = `103`
	HPPA_syncdma = `104`
	HPPA_uaddcm = `105`
	HPPA_uxor = `106`
	HPPA_xmpyu = `131`
	HPPA_xor = `107`
	HTI_ANON = `32768`
	HTI_CPP = `1`
	HTI_DCL = `1024`
	HTI_EXT = `4`
	HTI_FIL = `64`
	HTI_INT = `2`
	HTI_LEX = `8`
	HTI_MAC = `128`
	HTI_NDC = `2048`
	HTI_NER = `512`
	HTI_NWR = `256`
	HTI_PAK = `28672`
	HTI_PAK1 = `4096`
	HTI_PAK16 = `20480`
	HTI_PAK2 = `8192`
	HTI_PAK4 = `12288`
	HTI_PAK8 = `16384`
	HTI_PAKDEF = `0`
	HTI_PAK_SHIFT = `12`
	HTI_TST = `32`
	HTI_UNP = `16`
	I196_add2 = `1`
	I196_add3 = `2`
	I196_addb2 = `3`
	I196_addb3 = `4`
	I196_addc = `5`
	I196_addcb = `6`
	I196_and2 = `7`
	I196_and3 = `8`
	I196_andb2 = `9`
	I196_andb3 = `10`
	I196_bmov = `11`
	I196_bmovi = `12`
	I196_br = `13`
	I196_clr = `14`
	I196_clrb = `15`
	I196_clrc = `16`
	I196_clrvt = `17`
	I196_cmp = `18`
	I196_cmpb = `19`
	I196_cmpl = `20`
	I196_dec = `21`
	I196_decb = `22`
	I196_di = `23`
	I196_div = `24`
	I196_divb = `25`
	I196_divu = `26`
	I196_divub = `27`
	I196_djnz = `28`
	I196_djnzw = `29`
	I196_dpts = `30`
	I196_ebmovi = `113`
	I196_ebr = `114`
	I196_ecall = `115`
	I196_ei = `31`
	I196_ejmp = `116`
	I196_eld = `117`
	I196_eldb = `118`
	I196_epts = `32`
	I196_est = `119`
	I196_estb = `120`
	I196_ext = `33`
	I196_extb = `34`
	I196_idlpd = `35`
	I196_inc = `36`
	I196_incb = `37`
	I196_jbc = `38`
	I196_jbs = `39`
	I196_jc = `40`
	I196_je = `41`
	I196_jge = `42`
	I196_jgt = `43`
	I196_jh = `44`
	I196_jle = `45`
	I196_jlt = `46`
	I196_jnc = `47`
	I196_jne = `48`
	I196_jnh = `49`
	I196_jnst = `50`
	I196_jnv = `51`
	I196_jnvt = `52`
	I196_jst = `53`
	I196_jv = `54`
	I196_jvt = `55`
	I196_last = `121`
	I196_lcall = `56`
	I196_ld = `57`
	I196_ldb = `58`
	I196_ldbse = `59`
	I196_ldbze = `60`
	I196_ljmp = `61`
	I196_mul2 = `62`
	I196_mul3 = `63`
	I196_mulb2 = `64`
	I196_mulb3 = `65`
	I196_mulu2 = `66`
	I196_mulu3 = `67`
	I196_mulub2 = `68`
	I196_mulub3 = `69`
	I196_neg = `70`
	I196_negb = `71`
	I196_nop = `72`
	I196_norml = `73`
	I196_not = `74`
	I196_notb = `75`
	I196_null = `0`
	I196_or = `76`
	I196_orb = `77`
	I196_pop = `78`
	I196_popa = `79`
	I196_popf = `80`
	I196_push = `81`
	I196_pusha = `82`
	I196_pushf = `83`
	I196_ret = `84`
	I196_rst = `85`
	I196_scall = `86`
	I196_setc = `87`
	I196_shl = `88`
	I196_shlb = `89`
	I196_shll = `90`
	I196_shr = `91`
	I196_shra = `92`
	I196_shrab = `93`
	I196_shral = `94`
	I196_shrb = `95`
	I196_shrl = `96`
	I196_sjmp = `97`
	I196_skip = `98`
	I196_st = `99`
	I196_stb = `100`
	I196_sub2 = `101`
	I196_sub3 = `102`
	I196_subb2 = `103`
	I196_subb3 = `104`
	I196_subc = `105`
	I196_subcb = `106`
	I196_tijmp = `107`
	I196_trap = `108`
	I196_xch = `109`
	I196_xchb = `110`
	I196_xor = `111`
	I196_xorb = `112`
	I51_acall = `1`
	I51_add = `2`
	I51_addc = `3`
	I51_ajmp = `4`
	I51_anl = `5`
	I51_cjne = `6`
	I51_clr = `7`
	I51_cmp = `64`
	I51_cpl = `8`
	I51_da = `9`
	I51_dec = `10`
	I51_div = `11`
	I51_djnz = `12`
	I51_ecall = `55`
	I51_ejmp = `54`
	I51_eret = `56`
	I51_inc = `13`
	I51_jb = `14`
	I51_jbc = `15`
	I51_jc = `16`
	I51_je = `51`
	I51_jg = `48`
	I51_jle = `47`
	I51_jmp = `17`
	I51_jnb = `18`
	I51_jnc = `19`
	I51_jne = `52`
	I51_jnz = `20`
	I51_jsg = `46`
	I51_jsge = `50`
	I51_jsl = `49`
	I51_jsle = `45`
	I51_jz = `21`
	I51_last = `65`
	I51_lcall = `22`
	I51_ljmp = `23`
	I51_mov = `24`
	I51_movc = `25`
	I51_movh = `57`
	I51_movs = `59`
	I51_movx = `26`
	I51_movz = `58`
	I51_mul = `27`
	I51_nop = `28`
	I51_null = `0`
	I51_orl = `29`
	I51_pop = `30`
	I51_push = `31`
	I51_ret = `32`
	I51_reti = `33`
	I51_rl = `34`
	I51_rlc = `35`
	I51_rr = `36`
	I51_rrc = `37`
	I51_setb = `38`
	I51_sjmp = `39`
	I51_sll = `62`
	I51_sra = `61`
	I51_srl = `60`
	I51_sub = `63`
	I51_subb = `40`
	I51_swap = `41`
	I51_trap = `53`
	I51_xch = `42`
	I51_xchd = `43`
	I51_xrl = `44`
	I5_aci = `1`
	I5_adc = `2`
	I5_add = `3`
	I5_adi = `4`
	I5_ana = `5`
	I5_ani = `6`
	I5_arhl = `189`
	I5_call = `7`
	I5_cc = `11`
	I5_cm = `15`
	I5_cma = `19`
	I5_cmc = `16`
	I5_cmp = `17`
	I5_cnc = `10`
	I5_cnz = `8`
	I5_cp = `14`
	I5_cpe = `13`
	I5_cpi = `18`
	I5_cpo = `12`
	I5_cz = `9`
	I5_daa = `20`
	I5_dad = `21`
	I5_dcr = `22`
	I5_dcx = `23`
	I5_di = `24`
	I5_dsub = `188`
	I5_ei = `25`
	I5_halt = `26`
	I5_in = `27`
	I5_inr = `28`
	I5_inx = `29`
	I5_jc = `34`
	I5_jm = `38`
	I5_jmp = `30`
	I5_jnc = `33`
	I5_jnx5 = `197`
	I5_jnz = `31`
	I5_jp = `37`
	I5_jpe = `36`
	I5_jpo = `35`
	I5_jx5 = `196`
	I5_jz = `32`
	I5_last = `252`
	I5_lda = `39`
	I5_ldax = `40`
	I5_ldhi = `191`
	I5_ldsi = `192`
	I5_lhld = `41`
	I5_lhlx = `194`
	I5_lxi = `42`
	I5_mov = `43`
	I5_mvi = `44`
	I5_nop = `45`
	I5_null = `0`
	I5_ora = `46`
	I5_ori = `47`
	I5_out = `48`
	I5_pchl = `49`
	I5_pop = `50`
	I5_push = `51`
	I5_ral = `61`
	I5_rar = `63`
	I5_rc = `56`
	I5_rdel = `190`
	I5_ret = `52`
	I5_rim = `79`
	I5_rlc = `62`
	I5_rm = `60`
	I5_rnc = `55`
	I5_rnz = `53`
	I5_rp = `59`
	I5_rpe = `58`
	I5_rpo = `57`
	I5_rrc = `64`
	I5_rst = `65`
	I5_rstv = `195`
	I5_rz = `54`
	I5_sbb = `66`
	I5_sbi = `67`
	I5_shld = `72`
	I5_shlx = `193`
	I5_sim = `80`
	I5_sphl = `69`
	I5_sta = `70`
	I5_stax = `71`
	I5_stc = `68`
	I5_sub = `74`
	I5_sui = `73`
	I5_xchg = `77`
	I5_xra = `75`
	I5_xri = `76`
	I5_xthl = `78`
	I860_adds = `1`
	I860_addu = `2`
	I860_and = `3`
	I860_andh = `4`
	I860_andnot = `5`
	I860_andnoth = `6`
	I860_bc = `7`
	I860_bc_t = `8`
	I860_bla = `9`
	I860_bnc = `10`
	I860_bnc_t = `11`
	I860_br = `12`
	I860_bri = `13`
	I860_bte = `14`
	I860_btne = `15`
	I860_call = `16`
	I860_calli = `17`
	I860_fadd = `18`
	I860_faddp = `19`
	I860_faddz = `20`
	I860_famov = `21`
	I860_fiadd = `22`
	I860_fisub = `23`
	I860_fix = `24`
	I860_fld = `25`
	I860_flush = `26`
	I860_fmlow_dd = `27`
	I860_fmul = `28`
	I860_form = `29`
	I860_frcp = `30`
	I860_frsqr = `31`
	I860_fst = `32`
	I860_fsub = `33`
	I860_ftrunc = `34`
	I860_fxfr = `35`
	I860_fzchkl = `36`
	I860_fzchks = `37`
	I860_i2ap1 = `86`
	I860_i2apt = `87`
	I860_i2as1 = `102`
	I860_i2ast = `103`
	I860_i2p1 = `84`
	I860_i2pt = `85`
	I860_i2s1 = `100`
	I860_i2st = `101`
	I860_ia1p2 = `94`
	I860_ia1s2 = `110`
	I860_iat1p2 = `92`
	I860_iat1s2 = `108`
	I860_introvr = `38`
	I860_ixfr = `39`
	I860_last = `142`
	I860_ld = `41`
	I860_ld_c = `40`
	I860_ldint = `42`
	I860_ldio = `43`
	I860_lock = `44`
	I860_m12apm = `89`
	I860_m12asm = `105`
	I860_m12tpa = `95`
	I860_m12tpm = `93`
	I860_m12tsa = `111`
	I860_m12tsm = `109`
	I860_m12ttpa = `91`
	I860_m12ttsa = `107`
	I860_mi2mp1 = `118`
	I860_mi2mpt = `119`
	I860_mi2ms1 = `133`
	I860_mi2mst = `134`
	I860_mi2p1 = `116`
	I860_mi2pt = `117`
	I860_mi2s1 = `131`
	I860_mi2st = `132`
	I860_mim1p2 = `126`
	I860_mim1s2 = `141`
	I860_mimt1p2 = `124`
	I860_mimt1s2 = `139`
	I860_mm12mpm = `121`
	I860_mm12msm = `136`
	I860_mm12tpm = `125`
	I860_mm12tsm = `140`
	I860_mm12ttpm = `123`
	I860_mm12ttsm = `138`
	I860_mr2mp1 = `114`
	I860_mr2mpt = `115`
	I860_mr2ms1 = `129`
	I860_mr2mst = `130`
	I860_mr2p1 = `112`
	I860_mr2pt = `113`
	I860_mr2s1 = `127`
	I860_mr2st = `128`
	I860_mrm1p2 = `122`
	I860_mrm1s2 = `137`
	I860_mrmt1p2 = `120`
	I860_mrmt1s2 = `135`
	I860_null = `0`
	I860_or = `45`
	I860_orh = `46`
	I860_pfadd = `47`
	I860_pfaddp = `48`
	I860_pfaddz = `49`
	I860_pfamov = `50`
	I860_pfeq = `51`
	I860_pfgt = `52`
	I860_pfiadd = `53`
	I860_pfisub = `54`
	I860_pfix = `55`
	I860_pfld = `56`
	I860_pfle = `57`
	I860_pfmul = `58`
	I860_pfmul3_dd = `59`
	I860_pform = `60`
	I860_pfsub = `61`
	I860_pftrunc = `62`
	I860_pfzchkl = `63`
	I860_pfzchks = `64`
	I860_pst_d = `65`
	I860_r2ap1 = `82`
	I860_r2apt = `83`
	I860_r2as1 = `98`
	I860_r2ast = `99`
	I860_r2p1 = `80`
	I860_r2pt = `81`
	I860_r2s1 = `96`
	I860_r2st = `97`
	I860_ra1p2 = `90`
	I860_ra1s2 = `106`
	I860_rat1p2 = `88`
	I860_rat1s2 = `104`
	I860_scyc = `66`
	I860_shl = `67`
	I860_shr = `68`
	I860_shra = `69`
	I860_shrd = `70`
	I860_st = `72`
	I860_st_c = `71`
	I860_stio = `73`
	I860_subs = `74`
	I860_subu = `75`
	I860_trap = `76`
	I860_unlock = `77`
	I860_xor = `78`
	I860_xorh = `79`
	I960_addc = `1`
	I960_addi = `2`
	I960_addie = `180`
	I960_addig = `175`
	I960_addige = `185`
	I960_addil = `190`
	I960_addile = `200`
	I960_addine = `195`
	I960_addino = `170`
	I960_addio = `205`
	I960_addo = `3`
	I960_addoe = `179`
	I960_addog = `174`
	I960_addoge = `184`
	I960_addol = `189`
	I960_addole = `199`
	I960_addone = `194`
	I960_addono = `169`
	I960_addoo = `204`
	I960_alterbit = `4`
	I960_and = `5`
	I960_andnot = `6`
	I960_atadd = `7`
	I960_atmod = `8`
	I960_b = `9`
	I960_bal = `10`
	I960_balx = `11`
	I960_bbc = `12`
	I960_bbs = `13`
	I960_be = `16`
	I960_bg = `15`
	I960_bge = `17`
	I960_bl = `18`
	I960_ble = `20`
	I960_bne = `19`
	I960_bno = `14`
	I960_bo = `21`
	I960_bswap = `138`
	I960_bx = `22`
	I960_call = `23`
	I960_calls = `24`
	I960_callx = `25`
	I960_chkbit = `26`
	I960_clrbit = `27`
	I960_cmpdeci = `28`
	I960_cmpdeco = `29`
	I960_cmpi = `30`
	I960_cmpib = `135`
	I960_cmpibe = `33`
	I960_cmpibg = `32`
	I960_cmpibge = `34`
	I960_cmpibl = `35`
	I960_cmpible = `37`
	I960_cmpibne = `36`
	I960_cmpibno = `31`
	I960_cmpibo = `38`
	I960_cmpinci = `39`
	I960_cmpinco = `40`
	I960_cmpis = `137`
	I960_cmpo = `41`
	I960_cmpob = `134`
	I960_cmpobe = `43`
	I960_cmpobg = `42`
	I960_cmpobge = `44`
	I960_cmpobl = `45`
	I960_cmpoble = `47`
	I960_cmpobne = `46`
	I960_cmpos = `136`
	I960_cmpstr = `144`
	I960_concmpi = `48`
	I960_concmpo = `49`
	I960_condrec = `154`
	I960_condwait = `165`
	I960_daddc = `151`
	I960_dcctl = `158`
	I960_dcinva = `133`
	I960_divi = `50`
	I960_divo = `51`
	I960_dmovt = `153`
	I960_dsubc = `152`
	I960_ediv = `52`
	I960_emul = `53`
	I960_eshro = `54`
	I960_extract = `55`
	I960_faddr = `209`
	I960_faddrl = `210`
	I960_fatanr = `211`
	I960_fatanrl = `212`
	I960_faulte = `58`
	I960_faultg = `57`
	I960_faultge = `59`
	I960_faultl = `60`
	I960_faultle = `62`
	I960_faultne = `61`
	I960_faultno = `56`
	I960_faulto = `63`
	I960_fclassr = `213`
	I960_fclassrl = `214`
	I960_fcmpor = `215`
	I960_fcmporl = `216`
	I960_fcmpr = `217`
	I960_fcmprl = `218`
	I960_fcosr = `219`
	I960_fcosrl = `220`
	I960_fcpyrsre = `221`
	I960_fcpysre = `222`
	I960_fcvtilr = `223`
	I960_fcvtir = `224`
	I960_fcvtri = `225`
	I960_fcvtril = `226`
	I960_fcvtzri = `227`
	I960_fcvtzril = `228`
	I960_fdivr = `229`
	I960_fdivrl = `230`
	I960_fexpr = `231`
	I960_fexprl = `232`
	I960_fill = `150`
	I960_flogbnr = `233`
	I960_flogbnrl = `234`
	I960_flogepr = `235`
	I960_flogeprl = `236`
	I960_flogr = `237`
	I960_flogrl = `238`
	I960_flushreg = `64`
	I960_fmark = `65`
	I960_fmovr = `239`
	I960_fmovre = `240`
	I960_fmovrl = `241`
	I960_fmulr = `242`
	I960_fmulrl = `243`
	I960_fp_first = `209`
	I960_fp_last = `257`
	I960_fremr = `244`
	I960_fremrl = `245`
	I960_froundr = `246`
	I960_froundrl = `247`
	I960_fscaler = `248`
	I960_fscalerl = `249`
	I960_fsinr = `250`
	I960_fsinrl = `251`
	I960_fsqrtr = `252`
	I960_fsqrtrl = `253`
	I960_fsubr = `254`
	I960_fsubrl = `255`
	I960_ftanr = `256`
	I960_ftanrl = `257`
	I960_halt = `159`
	I960_icctl = `157`
	I960_inspacc = `147`
	I960_intctl = `156`
	I960_intdis = `139`
	I960_inten = `140`
	I960_last = `258`
	I960_ld = `66`
	I960_lda = `67`
	I960_ldib = `68`
	I960_ldis = `69`
	I960_ldl = `70`
	I960_ldob = `71`
	I960_ldos = `72`
	I960_ldphy = `148`
	I960_ldq = `73`
	I960_ldt = `74`
	I960_ldtime = `168`
	I960_mark = `75`
	I960_modac = `76`
	I960_modi = `77`
	I960_modify = `78`
	I960_modpc = `79`
	I960_modtc = `80`
	I960_mov = `81`
	I960_movl = `82`
	I960_movq = `83`
	I960_movqstr = `145`
	I960_movstr = `146`
	I960_movt = `84`
	I960_muli = `85`
	I960_mulo = `86`
	I960_nand = `87`
	I960_nor = `88`
	I960_not = `89`
	I960_notand = `90`
	I960_notbit = `91`
	I960_notor = `92`
	I960_null = `0`
	I960_or = `93`
	I960_ornot = `94`
	I960_receive = `155`
	I960_remi = `95`
	I960_remo = `96`
	I960_resumprcs = `162`
	I960_ret = `97`
	I960_rotate = `98`
	I960_saveprcs = `164`
	I960_scanbit = `99`
	I960_scanbyte = `100`
	I960_schedprcs = `163`
	I960_sdma = `130`
	I960_sele = `183`
	I960_selg = `178`
	I960_selge = `188`
	I960_sell = `193`
	I960_selle = `203`
	I960_selne = `198`
	I960_selno = `173`
	I960_selo = `208`
	I960_send = `160`
	I960_sendserv = `161`
	I960_setbit = `101`
	I960_shli = `102`
	I960_shlo = `103`
	I960_shrdi = `104`
	I960_shri = `105`
	I960_shro = `106`
	I960_signal = `167`
	I960_spanbit = `107`
	I960_st = `108`
	I960_stib = `109`
	I960_stis = `110`
	I960_stl = `111`
	I960_stob = `112`
	I960_stos = `113`
	I960_stq = `114`
	I960_stt = `115`
	I960_subc = `116`
	I960_subi = `117`
	I960_subie = `182`
	I960_subig = `177`
	I960_subige = `187`
	I960_subil = `192`
	I960_subile = `202`
	I960_subine = `197`
	I960_subino = `172`
	I960_subio = `207`
	I960_subo = `118`
	I960_suboe = `181`
	I960_subog = `176`
	I960_suboge = `186`
	I960_subol = `191`
	I960_subole = `201`
	I960_subone = `196`
	I960_subono = `171`
	I960_suboo = `206`
	I960_syncf = `119`
	I960_synld = `149`
	I960_synmov = `141`
	I960_synmovl = `142`
	I960_synmovq = `143`
	I960_sysctl = `131`
	I960_teste = `122`
	I960_testg = `121`
	I960_testge = `123`
	I960_testl = `124`
	I960_testle = `126`
	I960_testne = `125`
	I960_testno = `120`
	I960_testo = `127`
	I960_udma = `132`
	I960_wait = `166`
	I960_xnor = `128`
	I960_xor = `129`
	IA64_0 = `1`
	IA64_1 = `2`
	IA64_a = `3`
	IA64_acq = `4`
	IA64_add = `5`
	IA64_addl = `6`
	IA64_addp4 = `7`
	IA64_adds = `8`
	IA64_alloc = `9`
	IA64_and = `10`
	IA64_andcm = `11`
	IA64_b = `12`
	IA64_bias = `13`
	IA64_br = `14`
	IA64_break = `15`
	IA64_brl = `16`
	IA64_brp = `17`
	IA64_bsw = `18`
	IA64_c = `19`
	IA64_call = `20`
	IA64_cexit = `21`
	IA64_chk = `22`
	IA64_cloop = `23`
	IA64_clr = `24`
	IA64_clrrrb = `25`
	IA64_cmp = `26`
	IA64_cmp4 = `27`
	IA64_cmpxchg1 = `28`
	IA64_cmpxchg2 = `29`
	IA64_cmpxchg4 = `30`
	IA64_cmpxchg8 = `31`
	IA64_cond = `32`
	IA64_cover = `33`
	IA64_ctop = `34`
	IA64_czx1 = `35`
	IA64_czx2 = `36`
	IA64_d = `37`
	IA64_dep = `38`
	IA64_dpnt = `39`
	IA64_dptk = `40`
	IA64_e = `41`
	IA64_epc = `42`
	IA64_eq = `43`
	IA64_excl = `44`
	IA64_exit = `45`
	IA64_exp = `46`
	IA64_extr = `47`
	IA64_f = `48`
	IA64_fabs = `49`
	IA64_fadd = `50`
	IA64_famax = `51`
	IA64_famin = `52`
	IA64_fand = `53`
	IA64_fandcm = `54`
	IA64_fault = `55`
	IA64_fc = `56`
	IA64_fchkf = `57`
	IA64_fclass = `58`
	IA64_fclrf = `59`
	IA64_fcmp = `60`
	IA64_fcvt = `61`
	IA64_fetchadd4 = `62`
	IA64_fetchadd8 = `63`
	IA64_few = `64`
	IA64_fill = `65`
	IA64_flushrs = `66`
	IA64_fma = `67`
	IA64_fmax = `68`
	IA64_fmerge = `69`
	IA64_fmin = `70`
	IA64_fmix = `71`
	IA64_fmpy = `72`
	IA64_fms = `73`
	IA64_fneg = `74`
	IA64_fnegabs = `75`
	IA64_fnma = `76`
	IA64_fnmpy = `77`
	IA64_fnorm = `78`
	IA64_for = `79`
	IA64_fpabs = `80`
	IA64_fpack = `81`
	IA64_fpamax = `82`
	IA64_fpamin = `83`
	IA64_fpcmp = `84`
	IA64_fpcvt = `85`
	IA64_fpma = `86`
	IA64_fpmax = `87`
	IA64_fpmerge = `88`
	IA64_fpmin = `89`
	IA64_fpmpy = `90`
	IA64_fpms = `91`
	IA64_fpneg = `92`
	IA64_fpnegabs = `93`
	IA64_fpnma = `94`
	IA64_fpnmpy = `95`
	IA64_fprcpa = `96`
	IA64_fprsqrta = `97`
	IA64_frcpa = `98`
	IA64_frsqrta = `99`
	IA64_fselect = `100`
	IA64_fsetc = `101`
	IA64_fsub = `102`
	IA64_fswap = `103`
	IA64_fsxt = `104`
	IA64_fwb = `105`
	IA64_fx = `106`
	IA64_fxor = `107`
	IA64_fxu = `108`
	IA64_g = `109`
	IA64_ga = `110`
	IA64_ge = `111`
	IA64_getf = `112`
	IA64_geu = `113`
	IA64_gt = `114`
	IA64_gtu = `115`
	IA64_h = `116`
	IA64_hu = `117`
	IA64_i = `118`
	IA64_ia = `119`
	IA64_imp = `120`
	IA64_invala = `121`
	IA64_itc = `122`
	IA64_itr = `123`
	IA64_l = `124`
	IA64_last = `284`
	IA64_ld1 = `125`
	IA64_ld2 = `126`
	IA64_ld4 = `127`
	IA64_ld8 = `128`
	IA64_ldf = `129`
	IA64_ldf8 = `130`
	IA64_ldfd = `131`
	IA64_ldfe = `132`
	IA64_ldfp8 = `133`
	IA64_ldfpd = `134`
	IA64_ldfps = `135`
	IA64_ldfs = `136`
	IA64_le = `137`
	IA64_leu = `138`
	IA64_lfetch = `139`
	IA64_loadrs = `140`
	IA64_loop = `141`
	IA64_lr = `142`
	IA64_lt = `143`
	IA64_ltu = `144`
	IA64_lu = `145`
	IA64_m = `146`
	IA64_many = `147`
	IA64_mf = `148`
	IA64_mix1 = `149`
	IA64_mix2 = `150`
	IA64_mix4 = `151`
	IA64_mov = `152`
	IA64_movl = `153`
	IA64_mux1 = `154`
	IA64_mux2 = `155`
	IA64_nc = `156`
	IA64_ne = `157`
	IA64_neq = `158`
	IA64_nge = `159`
	IA64_ngt = `160`
	IA64_nl = `161`
	IA64_nle = `162`
	IA64_nlt = `163`
	IA64_nm = `164`
	IA64_nop = `165`
	IA64_nr = `166`
	IA64_ns = `167`
	IA64_nt1 = `168`
	IA64_nt2 = `169`
	IA64_nta = `170`
	IA64_null = `0`
	IA64_nz = `171`
	IA64_or = `172`
	IA64_orcm = `173`
	IA64_ord = `174`
	IA64_pack2 = `175`
	IA64_pack4 = `176`
	IA64_padd1 = `177`
	IA64_padd2 = `178`
	IA64_padd4 = `179`
	IA64_pavg1 = `180`
	IA64_pavg2 = `181`
	IA64_pavgsub1 = `182`
	IA64_pavgsub2 = `183`
	IA64_pcmp1 = `184`
	IA64_pcmp2 = `185`
	IA64_pcmp4 = `186`
	IA64_pmax1 = `187`
	IA64_pmax2 = `188`
	IA64_pmin1 = `189`
	IA64_pmin2 = `190`
	IA64_pmpy2 = `191`
	IA64_pmpyshr2 = `192`
	IA64_popcnt = `193`
	IA64_pr = `194`
	IA64_probe = `195`
	IA64_psad1 = `196`
	IA64_pshl2 = `197`
	IA64_pshl4 = `198`
	IA64_pshladd2 = `199`
	IA64_pshr2 = `200`
	IA64_pshr4 = `201`
	IA64_pshradd2 = `202`
	IA64_psub1 = `203`
	IA64_psub2 = `204`
	IA64_psub4 = `205`
	IA64_ptc = `206`
	IA64_ptr = `207`
	IA64_r = `208`
	IA64_raz = `209`
	IA64_rel = `210`
	IA64_ret = `211`
	IA64_rfi = `212`
	IA64_rsm = `213`
	IA64_rum = `214`
	IA64_rw = `215`
	IA64_s = `216`
	IA64_s0 = `217`
	IA64_s1 = `218`
	IA64_s2 = `219`
	IA64_s3 = `220`
	IA64_sa = `221`
	IA64_se = `222`
	IA64_setf = `223`
	IA64_shl = `224`
	IA64_shladd = `225`
	IA64_shladdp4 = `226`
	IA64_shr = `227`
	IA64_shrp = `228`
	IA64_sig = `229`
	IA64_spill = `230`
	IA64_spnt = `231`
	IA64_sptk = `232`
	IA64_srlz = `233`
	IA64_ssm = `234`
	IA64_sss = `235`
	IA64_st1 = `236`
	IA64_st2 = `237`
	IA64_st4 = `238`
	IA64_st8 = `239`
	IA64_stf = `240`
	IA64_stf8 = `241`
	IA64_stfd = `242`
	IA64_stfe = `243`
	IA64_stfs = `244`
	IA64_sub = `245`
	IA64_sum = `246`
	IA64_sxt1 = `247`
	IA64_sxt2 = `248`
	IA64_sxt4 = `249`
	IA64_sync = `250`
	IA64_tak = `251`
	IA64_tbit = `252`
	IA64_thash = `253`
	IA64_tnat = `254`
	IA64_tpa = `255`
	IA64_trunc = `256`
	IA64_ttag = `257`
	IA64_u = `258`
	IA64_unc = `259`
	IA64_unord = `260`
	IA64_unpack1 = `261`
	IA64_unpack2 = `262`
	IA64_unpack4 = `263`
	IA64_uss = `264`
	IA64_uus = `265`
	IA64_uuu = `266`
	IA64_w = `267`
	IA64_wexit = `268`
	IA64_wtop = `269`
	IA64_x = `270`
	IA64_xchg1 = `271`
	IA64_xchg2 = `272`
	IA64_xchg4 = `273`
	IA64_xchg8 = `274`
	IA64_xf = `275`
	IA64_xma = `276`
	IA64_xmpy = `277`
	IA64_xor = `278`
	IA64_xuf = `279`
	IA64_z = `280`
	IA64_zxt1 = `281`
	IA64_zxt2 = `282`
	IA64_zxt4 = `283`
	IDAPLACE_HEXDUMP = `15`
	IDAPLACE_SEGADDR = `64`
	IDAPLACE_STACK = `16`
	IDAPython_Completion = `<idaapi_win32.__IDAPython_Completion_Ut...`
	IDASGN_APPLIED = `2`
	IDASGN_BADARG = `1`
	IDASGN_CURRENT = `3`
	IDASGN_OK = `0`
	IDASGN_PLANNED = `4`
	IDA_SDK_VERSION = `620`
	IDB_EXT = `'idb'`
	IDB_EXT32 = `'idb'`
	IDB_EXT64 = `'i64'`
	IDC_LANG_EXT = `'idc'`
	IDC_SUBDIR = `'idc'`
	IDD_INTERFACE_VERSION = `14`
	IDPOPT_BADKEY = `1`
	IDPOPT_BADTYPE = `2`
	IDPOPT_BADVALUE = `3`
	IDPOPT_BIT = `3`
	IDPOPT_FLT = `4`
	IDPOPT_I64 = `5`
	IDPOPT_NUM = `2`
	IDPOPT_OK = `0`
	IDPOPT_STR = `1`
	IDP_DLL = `'*.w32'`
	IDP_EXT = `'w32'`
	IDP_INTERFACE_VERSION = `76`
	IDP_SUBDIR = `'procs'`
	IDS_SUBDIR = `'ids'`
	IK_ADD = `107`
	IK_APPS = `93`
	IK_BACK = `8`
	IK_BROWSER_BACK = `166`
	IK_BROWSER_FAVORITES = `171`
	IK_BROWSER_FORWARD = `167`
	IK_BROWSER_HOME = `172`
	IK_BROWSER_REFRESH = `168`
	IK_BROWSER_SEARCH = `170`
	IK_BROWSER_STOP = `169`
	IK_CANCEL = `3`
	IK_CAPITAL = `20`
	IK_CLEAR = `12`
	IK_CONTROL = `17`
	IK_DECIMAL = `110`
	IK_DELETE = `46`
	IK_DIVIDE = `111`
	IK_DOWN = `40`
	IK_END = `35`
	IK_ESCAPE = `27`
	IK_EXECUTE = `43`
	IK_F1 = `112`
	IK_F10 = `121`
	IK_F11 = `122`
	IK_F12 = `123`
	IK_F13 = `124`
	IK_F14 = `125`
	IK_F15 = `126`
	IK_F16 = `127`
	IK_F17 = `128`
	IK_F18 = `129`
	IK_F19 = `130`
	IK_F2 = `113`
	IK_F20 = `131`
	IK_F21 = `132`
	IK_F22 = `133`
	IK_F23 = `134`
	IK_F24 = `135`
	IK_F3 = `114`
	IK_F4 = `115`
	IK_F5 = `116`
	IK_F6 = `117`
	IK_F7 = `118`
	IK_F8 = `119`
	IK_F9 = `120`
	IK_HELP = `47`
	IK_HOME = `36`
	IK_INSERT = `45`
	IK_KANA = `21`
	IK_LAUNCH_APP1 = `182`
	IK_LAUNCH_APP2 = `183`
	IK_LAUNCH_MAIL = `180`
	IK_LAUNCH_MEDIA_SELECT = `181`
	IK_LCONTROL = `162`
	IK_LEFT = `37`
	IK_LMENU = `164`
	IK_LSHIFT = `160`
	IK_LWIN = `91`
	IK_MEDIA_NEXT_TRACK = `176`
	IK_MEDIA_PLAY_PAUSE = `179`
	IK_MEDIA_PREV_TRACK = `177`
	IK_MEDIA_STOP = `178`
	IK_MENU = `18`
	IK_MODECHANGE = `31`
	IK_MULTIPLY = `106`
	IK_NEXT = `34`
	IK_NUMLOCK = `144`
	IK_NUMPAD0 = `96`
	IK_NUMPAD1 = `97`
	IK_NUMPAD2 = `98`
	IK_NUMPAD3 = `99`
	IK_NUMPAD4 = `100`
	IK_NUMPAD5 = `101`
	IK_NUMPAD6 = `102`
	IK_NUMPAD7 = `103`
	IK_NUMPAD8 = `104`
	IK_NUMPAD9 = `105`
	IK_OEM_1 = `186`
	IK_OEM_102 = `226`
	IK_OEM_2 = `191`
	IK_OEM_3 = `192`
	IK_OEM_4 = `219`
	IK_OEM_5 = `220`
	IK_OEM_6 = `221`
	IK_OEM_7 = `222`
	IK_OEM_CLEAR = `254`
	IK_OEM_COMMA = `188`
	IK_OEM_FJ_MASSHOU = `147`
	IK_OEM_FJ_TOUROKU = `148`
	IK_OEM_MINUS = `189`
	IK_OEM_PERIOD = `190`
	IK_OEM_PLUS = `187`
	IK_PAUSE = `19`