# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
IDA Plugin SDK API wrapper
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_idaapi', [dirname(__file__)])
        except ImportError:
            import _idaapi
            return _idaapi
        if fp is not None:
            try:
                _mod = imp.load_module('_idaapi', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _idaapi = swig_import_helper()
    del swig_import_helper
else:
    import _idaapi
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


SIZE_MAX = _idaapi.SIZE_MAX
BADADDR = _idaapi.BADADDR
BADSEL = _idaapi.BADSEL
BADNODE = _idaapi.BADNODE
#<pycode(py_idaapi)>

import struct
import traceback
import os
import sys
import bisect
import __builtin__
import imp

def require(modulename, package=None):
    """
    Load, or reload a module.

    When under heavy development, a user's tool might consist of multiple
    modules. If those are imported using the standard 'import' mechanism,
    there is no guarantee that the Python implementation will re-read
    and re-evaluate the module's Python code. In fact, it usually doesn't.
    What should be done instead is 'reload()'-ing that module.

    This is a simple helper function that will do just that: In case the
    module doesn't exist, it 'import's it, and if it does exist,
    'reload()'s it.

    For more information, see: <http://www.hexblog.com/?p=749>.
    """
    if modulename in sys.modules.keys():
        reload(sys.modules[modulename])
    else:
        import importlib
        import inspect
        m = importlib.import_module(modulename, package)
        frame_obj, filename, line_number, function_name, lines, index = inspect.stack()[1]
        importer_module = inspect.getmodule(frame_obj)
        if importer_module is None: # No importer module; called from command line
            importer_module = sys.modules['__main__']
        setattr(importer_module, modulename, m)
        sys.modules[modulename] = m

# -----------------------------------------------------------------------

# Seek constants
SEEK_SET = 0 # from the file start
SEEK_CUR = 1 # from the current position
SEEK_END = 2 # from the file end

# Plugin constants
PLUGIN_MOD  = 0x0001
PLUGIN_DRAW = 0x0002
PLUGIN_SEG  = 0x0004
PLUGIN_UNL  = 0x0008
PLUGIN_HIDE = 0x0010
PLUGIN_DBG  = 0x0020
PLUGIN_PROC = 0x0040
PLUGIN_FIX  = 0x0080
PLUGIN_SKIP = 0
PLUGIN_OK   = 1
PLUGIN_KEEP = 2

# PyIdc conversion object IDs
PY_ICID_INT64  = 0
"""
int64 object
"""
PY_ICID_BYREF  = 1
"""
byref object
"""
PY_ICID_OPAQUE = 2
"""
opaque object
"""

# Step trace options (used with set_step_trace_options())
ST_OVER_DEBUG_SEG  = 0x01
"""
step tracing will be disabled when IP is in a debugger segment
"""

ST_OVER_LIB_FUNC    = 0x02
"""
step tracing will be disabled when IP is in a library function
"""

# -----------------------------------------------------------------------
class pyidc_opaque_object_t(object):
    """
    This is the base class for all Python<->IDC opaque objects
    """
    __idc_cvt_id__ = PY_ICID_OPAQUE

# -----------------------------------------------------------------------
class py_clinked_object_t(pyidc_opaque_object_t):
    """
    This is a utility and base class for C linked objects
    """
    def __init__(self, lnk = None):
        # static link: if a link was provided
        self.__static_clink__ = True if lnk else False

        # Create link if it was not provided
        self.__clink__ = lnk if lnk else self._create_clink()

    def __del__(self):
        """
        Delete the link upon object destruction (only if not static)
        """
        self._free()

    def _free(self):
        """
        Explicitly delete the link (only if not static)
        """
        if not self.__static_clink__ and self.__clink__ is not None:
            self._del_clink(self.__clink__)
            self.__clink__ = None

    def copy(self):
        """
        Returns a new copy of this class
        """

        # Create an unlinked instance
        inst = self.__class__()

        # Assign self to the new instance
        inst.assign(self)

        return inst

    #
    # Methods to be overwritten
    #
    def _create_clink(self):
        """
        Overwrite me.
        Creates a new clink
        @return: PyCObject representing the C link
        """
        pass

    def _del_clink(self, lnk):
        """
        Overwrite me.
        This method deletes the link
        """
        pass

    def _get_clink_ptr(self):
        """
        Overwrite me.
        Returns the C link pointer as a 64bit number
        """
        pass

    def assign(self, other):
        """
        Overwrite me.
        This method allows you to assign an instance contents to anothers
        @return: Boolean
        """
        pass

    clink = property(lambda self: self.__clink__)
    """
    Returns the C link as a PyObject
    """

    clink_ptr = property(lambda self: self._get_clink_ptr())
    """
    Returns the C link pointer as a number
    """

# -----------------------------------------------------------------------
class object_t(object):
    """
    Helper class used to initialize empty objects
    """
    def __init__(self, **kwds):
        self.__dict__ = kwds

    def __getitem__(self, idx):
        """
        Allow access to object attributes by index (like dictionaries)
        """
        return getattr(self, idx)

# -----------------------------------------------------------------------
def _bounded_getitem_iterator(self):
    """
    Helper function, to be set as __iter__ method for qvector-, or array-based classes.
    """
    for i in range(len(self)):
        yield self[i]

# -----------------------------------------------------------------------
class plugin_t(pyidc_opaque_object_t):
    """
    Base class for all scripted plugins.
    """
    pass

# -----------------------------------------------------------------------
class pyidc_cvt_helper__(object):
    """
    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.
    This object is characterized by its special attribute and its value
    """
    def __init__(self, cvt_id, value):
        self.__idc_cvt_id__ = cvt_id
        self.value = value

    def __set_value(self, v):
        self.__idc_cvt_value__ = v
    def __get_value(self):
        return self.__idc_cvt_value__
    value = property(__get_value, __set_value)

# -----------------------------------------------------------------------
class PyIdc_cvt_int64__(pyidc_cvt_helper__):
    """
    Helper class for explicitly representing VT_INT64 values
    """

    def __init__(self, v):
        # id = 0 = int64 object
        super(self.__class__, self).__init__(PY_ICID_INT64, v)

    # operation table
    __op_table = \
    {
        0: lambda a, b: a + b,
        1: lambda a, b: a - b,
        2: lambda a, b: a * b,
        3: lambda a, b: a / b
    }
    # carries the operation given its number
    def __op(self, op_n, other, rev=False):
        a = self.value
        # other operand of same type? then take its value field
        if type(other) == type(self):
            b = other.value
        else:
            b = other
        if rev:
            t = a
            a = b
            b = t
        # construct a new object and return as the result
        return self.__class__(self.__op_table[op_n](a, b))

    # overloaded operators
    def __add__(self, other):  return self.__op(0, other)
    def __sub__(self, other):  return self.__op(1, other)
    def __mul__(self, other):  return self.__op(2, other)
    def __div__(self, other):  return self.__op(3, other)
    def __radd__(self, other): return self.__op(0, other, True)
    def __rsub__(self, other): return self.__op(1, other, True)
    def __rmul__(self, other): return self.__op(2, other, True)
    def __rdiv__(self, other): return self.__op(3, other, True)

# -----------------------------------------------------------------------
# qstrvec_t clinked object
class _qstrvec_t(py_clinked_object_t):
    """
    WARNING: It is very unlikely an IDAPython user should ever, ever
    have to use this type. It should only be used for IDAPython internals.

    For example, in py_askusingform.py, we ctypes-expose to the IDA
    kernel & UI a qstrvec instance, in case a DropdownListControl is
    constructed.
    That's because that's what AskUsingForm expects, and we have no
    choice but to make a DropdownListControl hold a qstrvec_t.
    This is, afaict, the only situation where a Python
    _qstrvec_t is required.
    """

    def __init__(self, items=None):
        py_clinked_object_t.__init__(self)
        # Populate the list if needed
        if items:
            self.from_list(items)

    def _create_clink(self):
        return _idaapi.qstrvec_t_create()

    def _del_clink(self, lnk):
        return _idaapi.qstrvec_t_destroy(lnk)

    def _get_clink_ptr(self):
        return _idaapi.qstrvec_t_get_clink_ptr(self)

    def assign(self, other):
        """
        Copies the contents of 'other' to 'self'
        """
        return _idaapi.qstrvec_t_assign(self, other)

    def __setitem__(self, idx, s):
        """
        Sets string at the given index
        """
        return _idaapi.qstrvec_t_set(self, idx, s)

    def __getitem__(self, idx):
        """
        Gets the string at the given index
        """
        return _idaapi.qstrvec_t_get(self, idx)

    def __get_size(self):
        return _idaapi.qstrvec_t_size(self)

    size = property(__get_size)
    """
    Returns the count of elements
    """

    def addressof(self, idx):
        """
        Returns the address (as number) of the qstring at the given index
        """
        return _idaapi.qstrvec_t_addressof(self, idx)

    def add(self, s):
        """
        Add a string to the vector
        """
        return _idaapi.qstrvec_t_add(self, s)

    def from_list(self, lst):
        """
        Populates the vector from a Python string list
        """
        return _idaapi.qstrvec_t_from_list(self, lst)

    def clear(self, qclear=False):
        """
        Clears all strings from the vector.
        @param qclear: Just reset the size but do not actually free the memory
        """
        return _idaapi.qstrvec_t_clear(self, qclear)

    def insert(self, idx, s):
        """
        Insert a string into the vector
        """
        return _idaapi.qstrvec_t_insert(self, idx, s)

    def remove(self, idx):
        """
        Removes a string from the vector
        """
        return _idaapi.qstrvec_t_remove(self, idx)

# -----------------------------------------------------------------------
class PyIdc_cvt_refclass__(pyidc_cvt_helper__):
    """
    Helper class for representing references to immutable objects
    """
    def __init__(self, v):
        # id = one = byref object
        super(self.__class__, self).__init__(PY_ICID_BYREF, v)

    def cstr(self):
        """
        Returns the string as a C string (up to the zero termination)
        """
        return as_cstr(self.value)

# -----------------------------------------------------------------------
def as_cstr(val):
    """
    Returns a C str from the passed value. The passed value can be of type refclass (returned by a call to buffer() or byref())
    It scans for the first \x00 and returns the string value up to that point.
    """
    if isinstance(val, PyIdc_cvt_refclass__):
        val = val.value

    n = val.find('\x00')
    return val if n == -1 else val[:n]

# -----------------------------------------------------------------------
def as_unicode(s):
    """
    Convenience function to convert a string into appropriate unicode format
    """
    # use UTF16 big/little endian, depending on the environment?
    return unicode(s).encode("UTF-16" + ("BE" if _idaapi.cvar.inf.mf else "LE"))

# -----------------------------------------------------------------------
def as_uint32(v):
    """
    Returns a number as an unsigned int32 number
    """
    return v & 0xffffffff

# -----------------------------------------------------------------------
def as_int32(v):
    """
    Returns a number as a signed int32 number
    """
    return -((~v & 0xffffffff)+1)

# -----------------------------------------------------------------------
def as_signed(v, nbits = 32):
    """
    Returns a number as signed. The number of bits are specified by the user.
    The MSB holds the sign.
    """
    return -(( ~v & ((1 << nbits)-1) ) + 1) if v & (1 << nbits-1) else v

# ----------------------------------------------------------------------
def copy_bits(v, s, e=-1):
    """
    Copy bits from a value
    @param v: the value
    @param s: starting bit (0-based)
    @param e: ending bit
    """
    # end-bit not specified? use start bit (thus extract one bit)
    if e == -1:
        e = s
    # swap start and end if start > end
    if s > e:
        e, s = s, e

    mask = ~(((1 << (e-s+1))-1) << s)

    return (v & mask) >> s

# ----------------------------------------------------------------------
__struct_unpack_table = {
  1: ('b', 'B'),
  2: ('h', 'H'),
  4: ('l', 'L'),
  8: ('q', 'Q')
}

# ----------------------------------------------------------------------
def struct_unpack(buffer, signed = False, offs = 0):
    """
    Unpack a buffer given its length and offset using struct.unpack_from().
    This function will know how to unpack the given buffer by using the lookup table '__struct_unpack_table'
    If the buffer is of unknown length then None is returned. Otherwise the unpacked value is returned.
    """
    # Supported length?
    n = len(buffer)
    if n not in __struct_unpack_table:
        return None
    # Conver to number
    signed = 1 if signed else 0

    # Unpack
    return struct.unpack_from(__struct_unpack_table[n][signed], buffer, offs)[0]


# ------------------------------------------------------------
def IDAPython_ExecSystem(cmd):
    """
    Executes a command with popen().
    """
    try:
        f = os.popen(cmd, "r")
        s = ''.join(f.readlines())
        f.close()
        return s
    except Exception as e:
        return "%s\n%s" % (str(e), traceback.format_exc())

# ------------------------------------------------------------
def IDAPython_FormatExc(etype, value, tb, limit=None):
    """
    This function is used to format an exception given the
    values returned by a PyErr_Fetch()
    """
    try:
        return ''.join(traceback.format_exception(etype, value, tb, limit))
    except:
        return str(value)


# ------------------------------------------------------------
def IDAPython_ExecScript(script, g):
    """
    Run the specified script.
    It also addresses http://code.google.com/p/idapython/issues/detail?id=42

    This function is used by the low-level plugin code.
    """
    scriptpath = os.path.dirname(script)
    if len(scriptpath) and scriptpath not in sys.path:
        sys.path.append(scriptpath)

    argv = sys.argv
    sys.argv = [ script ]

    # Adjust the __file__ path in the globals we pass to the script
    old__file__ = g['__file__'] if '__file__' in g else ''
    g['__file__'] = script

    try:
        execfile(script, g)
        PY_COMPILE_ERR = None
    except Exception as e:
        PY_COMPILE_ERR = "%s\n%s" % (str(e), traceback.format_exc())
        print(PY_COMPILE_ERR)
    finally:
        # Restore state
        g['__file__'] = old__file__
        sys.argv = argv

    return PY_COMPILE_ERR

# ------------------------------------------------------------
def IDAPython_LoadProcMod(script, g):
    """
    Load processor module.
    """
    pname = g['__name__'] if g and g.has_key("__name__") else '__main__'
    parent = sys.modules[pname]

    scriptpath, scriptname = os.path.split(script)
    if len(scriptpath) and scriptpath not in sys.path:
        sys.path.append(scriptpath)

    procmod_name = os.path.splitext(scriptname)[0]
    procobj = None
    fp = None
    try:
        fp, pathname, description = imp.find_module(procmod_name)
        procmod = imp.load_module(procmod_name, fp, pathname, description)
        if parent:
            setattr(parent, procmod_name, procmod)
            # export attrs from parent to processor module
            parent_attrs = getattr(parent, '__all__',
                                   (attr for attr in dir(parent) if not attr.startswith('_')))
            for pa in parent_attrs:
                setattr(procmod, pa, getattr(parent, pa))
            # instantiate processor object
            if getattr(procmod, 'PROCESSOR_ENTRY', None):
                procobj = procmod.PROCESSOR_ENTRY()
        PY_COMPILE_ERR = None
    except Exception as e:
        PY_COMPILE_ERR = "%s\n%s" % (str(e), traceback.format_exc())
        print(PY_COMPILE_ERR)
    finally:
        if fp: fp.close()

    sys.path.remove(scriptpath)

    return (PY_COMPILE_ERR, procobj)

# ------------------------------------------------------------
def IDAPython_UnLoadProcMod(script, g):
    """
    Unload processor module.
    """
    pname = g['__name__'] if g and g.has_key("__name__") else '__main__'
    parent = sys.modules[pname]

    scriptname = os.path.split(script)[1]
    procmod_name = os.path.splitext(scriptname)[0]
    if getattr(parent, procmod_name, None):
        delattr(parent, procmod_name)
        del sys.modules[procmod_name]
    PY_COMPILE_ERR = None
    return PY_COMPILE_ERR

# ----------------------------------------------------------------------
class __IDAPython_Completion_Util(object):
    """
    Internal utility class for auto-completion support
    """
    def __init__(self):
        self.n = 0
        self.completion = None
        self.lastmodule = None

    @staticmethod
    def parse_identifier(line, prefix, prefix_start):
        """
        Parse a line and extracts identifier
        """
        id_start = prefix_start
        while id_start > 0:
            ch = line[id_start]
            if not ch.isalpha() and ch != '.' and ch != '_':
                id_start += 1
                break
            id_start -= 1

        return line[id_start:prefix_start + len(prefix)]

    @staticmethod
    def dir_of(m, prefix):
        return [x for x in dir(m) if x.startswith(prefix)]

    @classmethod
    def get_completion(cls, id, prefix):
        try:
            m = sys.modules['__main__']

            parts = id.split('.')
            c = len(parts)

            for i in xrange(0, c-1):
                m = getattr(m, parts[i])
        except Exception as e:
            return (None, None)
        else:
            # search in the module
            completion = cls.dir_of(m, prefix)

            # no completion found? looking from the global scope? then try the builtins
            if not completion and c == 1:
                completion = cls.dir_of(__builtin__, prefix)

            return (m, completion) if completion else (None, None)

    def __call__(self, prefix, n, line, prefix_start):
        if n == 0:
            self.n = n
            id = self.parse_identifier(line, prefix, prefix_start)
            self.lastmodule, self.completion = self.get_completion(id, prefix)

        if self.completion is None or n >= len(self.completion):
            return None

        s = self.completion[n]
        try:
            attr = getattr(self.lastmodule, s)
            # Is it callable?
            if callable(attr):
                return s + ("" if line.startswith("?") else "(")
            # Is it iterable?
            elif isinstance(attr, basestring) or getattr(attr, '__iter__', False):
                return s + "["
        except:
            pass

        return s

# Instantiate an IDAPython command completion object (for use with IDA's CLI bar)
IDAPython_Completion = __IDAPython_Completion_Util()

def _listify_types(*classes):
    for cls in classes:
        cls.__getitem__ = cls.at
        cls.__len__ = cls.size
        cls.__iter__ = _bounded_getitem_iterator



# The general callback format of notify_when() is:
#    def notify_when_callback(nw_code)
# In the case of NW_OPENIDB, the callback is:
#    def notify_when_callback(nw_code, is_old_database)
NW_OPENIDB    = 0x0001
"""
Notify when the database is opened. Its callback is of the form: def notify_when_callback(nw_code, is_old_database)
"""
NW_CLOSEIDB   = 0x0002
"""
Notify when the database is closed. Its callback is of the form: def notify_when_callback(nw_code)
"""
NW_INITIDA    = 0x0004
"""
Notify when the IDA starts. Its callback is of the form: def notify_when_callback(nw_code)
"""
NW_TERMIDA    = 0x0008
"""
Notify when the IDA terminates. Its callback is of the form: def notify_when_callback(nw_code)
"""
NW_REMOVE     = 0x0010
"""
Use this flag with other flags to uninstall a notifywhen callback
"""

#</pycode(py_idaapi)>

IDA_SDK_VERSION = _idaapi.IDA_SDK_VERSION
BADMEMSIZE = _idaapi.BADMEMSIZE
MAXSTR = _idaapi.MAXSTR
__MF__ = _idaapi.__MF__

def qatoll(*args):
  """
  qatoll(nptr) -> int64
  """
  return _idaapi.qatoll(*args)
FMT_64 = _idaapi.FMT_64
FMT_Z = _idaapi.FMT_Z
FMT_ZS = _idaapi.FMT_ZS
FMT_EA = _idaapi.FMT_EA

def qexit(*args):
  """
  qexit(code)
  """
  return _idaapi.qexit(*args)

def extend_sign(*args):
  """
  extend_sign(v, nbytes, sign_extend) -> uint64
  """
  return _idaapi.extend_sign(*args)

def readbytes(*args):
  """
  readbytes(h, res, size, mf) -> int
  """
  return _idaapi.readbytes(*args)

def writebytes(*args):
  """
  writebytes(h, l, size, mf) -> int
  """
  return _idaapi.writebytes(*args)

def reloc_value(*args):
  """
  reloc_value(value, size, delta, mf)
  """
  return _idaapi.reloc_value(*args)

def qvector_reserve(*args):
  """
  qvector_reserve(vec, old, cnt, elsize) -> void *
  """
  return _idaapi.qvector_reserve(*args)
class ida_true_type(object):
    """
    Proxy of C++ ida_true_type class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> ida_true_type
        """
        this = _idaapi.new_ida_true_type(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ida_true_type
    __del__ = lambda self : None;
ida_true_type_swigregister = _idaapi.ida_true_type_swigregister
ida_true_type_swigregister(ida_true_type)

class ida_false_type(object):
    """
    Proxy of C++ ida_false_type class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> ida_false_type
        """
        this = _idaapi.new_ida_false_type(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ida_false_type
    __del__ = lambda self : None;
ida_false_type_swigregister = _idaapi.ida_false_type_swigregister
ida_false_type_swigregister(ida_false_type)


def check_type_trait(*args):
  """
    check_type_trait(arg1) -> bool
    check_type_trait(arg1) -> bool
    """
  return _idaapi.check_type_trait(*args)
class qrefcnt_obj_t(object):
    """
    Proxy of C++ qrefcnt_obj_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    refcnt = _swig_property(_idaapi.qrefcnt_obj_t_refcnt_get, _idaapi.qrefcnt_obj_t_refcnt_set)
    def release(self, *args):
        """
        release(self)
        """
        return _idaapi.qrefcnt_obj_t_release(self, *args)

    __swig_destroy__ = _idaapi.delete_qrefcnt_obj_t
    __del__ = lambda self : None;
qrefcnt_obj_t_swigregister = _idaapi.qrefcnt_obj_t_swigregister
qrefcnt_obj_t_swigregister(qrefcnt_obj_t)


def relocate_relobj(*args):
  """
  relocate_relobj(_relobj, ea, mf) -> bool
  """
  return _idaapi.relocate_relobj(*args)

def replace_tabs(*args):
  """
  replace_tabs(str, tabsize) -> bool
  """
  return _idaapi.replace_tabs(*args)

def get_utf8_char(*args):
  """
  get_utf8_char(pptr) -> wchar32_t
  """
  return _idaapi.get_utf8_char(*args)

def convert_encoding(*args):
  """
  convert_encoding(fromcode, tocode, indata, out, flags=0) -> int
  """
  return _idaapi.convert_encoding(*args)
CP_UTF8 = _idaapi.CP_UTF8
CP_UTF16 = _idaapi.CP_UTF16
class channel_redir_t(object):
    """
    Proxy of C++ channel_redir_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    fd = _swig_property(_idaapi.channel_redir_t_fd_get, _idaapi.channel_redir_t_fd_set)
    file = _swig_property(_idaapi.channel_redir_t_file_get, _idaapi.channel_redir_t_file_set)
    flags = _swig_property(_idaapi.channel_redir_t_flags_get, _idaapi.channel_redir_t_flags_set)
    def is_input(self, *args):
        """
        is_input(self) -> bool
        """
        return _idaapi.channel_redir_t_is_input(self, *args)

    def is_output(self, *args):
        """
        is_output(self) -> bool
        """
        return _idaapi.channel_redir_t_is_output(self, *args)

    def is_append(self, *args):
        """
        is_append(self) -> bool
        """
        return _idaapi.channel_redir_t_is_append(self, *args)

    def is_quoted(self, *args):
        """
        is_quoted(self) -> bool
        """
        return _idaapi.channel_redir_t_is_quoted(self, *args)

    start = _swig_property(_idaapi.channel_redir_t_start_get, _idaapi.channel_redir_t_start_set)
    length = _swig_property(_idaapi.channel_redir_t_length_get, _idaapi.channel_redir_t_length_set)
    def __init__(self, *args):
        """
        __init__(self) -> channel_redir_t
        """
        this = _idaapi.new_channel_redir_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_channel_redir_t
    __del__ = lambda self : None;
channel_redir_t_swigregister = _idaapi.channel_redir_t_swigregister
channel_redir_t_swigregister(channel_redir_t)
cvar = _idaapi.cvar
IOREDIR_INPUT = _idaapi.IOREDIR_INPUT
IOREDIR_OUTPUT = _idaapi.IOREDIR_OUTPUT
IOREDIR_APPEND = _idaapi.IOREDIR_APPEND
IOREDIR_QUOTED = _idaapi.IOREDIR_QUOTED


def expand_argv(*args):
  """
  expand_argv(p_argc, argc, argv) -> char **
  """
  return _idaapi.expand_argv(*args)

def free_argv(*args):
  """
  free_argv(argc, argv)
  """
  return _idaapi.free_argv(*args)

def quote_cmdline_arg(*args):
  """
  quote_cmdline_arg(arg) -> bool
  """
  return _idaapi.quote_cmdline_arg(*args)

def parse_dbgopts(*args):
  """
  parse_dbgopts(ido, r_switch) -> bool
  """
  return _idaapi.parse_dbgopts(*args)
class instant_dbgopts_t(object):
    """
    Proxy of C++ instant_dbgopts_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    debmod = _swig_property(_idaapi.instant_dbgopts_t_debmod_get, _idaapi.instant_dbgopts_t_debmod_set)
    env = _swig_property(_idaapi.instant_dbgopts_t_env_get, _idaapi.instant_dbgopts_t_env_set)
    host = _swig_property(_idaapi.instant_dbgopts_t_host_get, _idaapi.instant_dbgopts_t_host_set)
    _pass = _swig_property(_idaapi.instant_dbgopts_t__pass_get, _idaapi.instant_dbgopts_t__pass_set)
    port = _swig_property(_idaapi.instant_dbgopts_t_port_get, _idaapi.instant_dbgopts_t_port_set)
    pid = _swig_property(_idaapi.instant_dbgopts_t_pid_get, _idaapi.instant_dbgopts_t_pid_set)
    event_id = _swig_property(_idaapi.instant_dbgopts_t_event_id_get, _idaapi.instant_dbgopts_t_event_id_set)
    attach = _swig_property(_idaapi.instant_dbgopts_t_attach_get, _idaapi.instant_dbgopts_t_attach_set)
    def __init__(self, *args):
        """
        __init__(self) -> instant_dbgopts_t
        """
        this = _idaapi.new_instant_dbgopts_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_instant_dbgopts_t
    __del__ = lambda self : None;
instant_dbgopts_t_swigregister = _idaapi.instant_dbgopts_t_swigregister
instant_dbgopts_t_swigregister(instant_dbgopts_t)


def qwait_timed(*args):
  """
  qwait_timed(child, status, flags, timeout_ms) -> int
  """
  return _idaapi.qwait_timed(*args)

def check_process_exit(*args):
  """
  check_process_exit(handle, exit_code, msecs=-1) -> int
  """
  return _idaapi.check_process_exit(*args)
TCT_UNKNOWN = _idaapi.TCT_UNKNOWN
TCT_OWNER = _idaapi.TCT_OWNER
TCT_NOT_OWNER = _idaapi.TCT_NOT_OWNER

def is_control_tty(*args):
  """
  is_control_tty(fd) -> tty_control_t
  """
  return _idaapi.is_control_tty(*args)

def qdetach_tty(*args):
  """
  qdetach_tty()
  """
  return _idaapi.qdetach_tty(*args)

def qcontrol_tty(*args):
  """
  qcontrol_tty()
  """
  return _idaapi.qcontrol_tty(*args)
class __qthread_t(object):
    """
    Proxy of C++ __qthread_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> __qthread_t
        """
        this = _idaapi.new___qthread_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete___qthread_t
    __del__ = lambda self : None;
__qthread_t_swigregister = _idaapi.__qthread_t_swigregister
__qthread_t_swigregister(__qthread_t)


def is_main_thread(*args):
  """
  is_main_thread() -> bool
  """
  return _idaapi.is_main_thread(*args)
class __qsemaphore_t(object):
    """
    Proxy of C++ __qsemaphore_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> __qsemaphore_t
        """
        this = _idaapi.new___qsemaphore_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete___qsemaphore_t
    __del__ = lambda self : None;
__qsemaphore_t_swigregister = _idaapi.__qsemaphore_t_swigregister
__qsemaphore_t_swigregister(__qsemaphore_t)

class __qmutex_t(object):
    """
    Proxy of C++ __qmutex_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> __qmutex_t
        """
        this = _idaapi.new___qmutex_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete___qmutex_t
    __del__ = lambda self : None;
__qmutex_t_swigregister = _idaapi.__qmutex_t_swigregister
__qmutex_t_swigregister(__qmutex_t)

class qmutex_locker_t(object):
    """
    Proxy of C++ qmutex_locker_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _lock) -> qmutex_locker_t
        """
        this = _idaapi.new_qmutex_locker_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qmutex_locker_t
    __del__ = lambda self : None;
qmutex_locker_t_swigregister = _idaapi.qmutex_locker_t_swigregister
qmutex_locker_t_swigregister(qmutex_locker_t)

INTERR_MSG_FMT = _idaapi.INTERR_MSG_FMT

def qsplitpath(*args):
  """
  qsplitpath(path, dir, file) -> char *
  """
  return _idaapi.qsplitpath(*args)

def init_process(*args):
  """
  init_process(lpi, errbuf) -> void *
  """
  return _idaapi.init_process(*args)

def vinterr(*args):
  """
  vinterr(file, line, format, va)
  """
  return _idaapi.vinterr(*args)

def strlwr(*args):
  """
  strlwr(s) -> char *
  """
  return _idaapi.strlwr(*args)

def strupr(*args):
  """
  strupr(s) -> char *
  """
  return _idaapi.strupr(*args)
class uvalvec_t(object):
    """
    Proxy of C++ qvector<(uval_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> uvalvec_t
        __init__(self, x) -> uvalvec_t
        """
        this = _idaapi.new_uvalvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_uvalvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> unsigned int &
        """
        return _idaapi.uvalvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.uvalvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.uvalvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.uvalvec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> unsigned int const &
        """
        return _idaapi.uvalvec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> unsigned int const
        front(self) -> unsigned int &
        """
        return _idaapi.uvalvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> unsigned int const
        back(self) -> unsigned int &
        """
        return _idaapi.uvalvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.uvalvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.uvalvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.uvalvec_t_resize(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.uvalvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.uvalvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.uvalvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.uvalvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> unsigned int *
        """
        return _idaapi.uvalvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.uvalvec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.uvalvec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.uvalvec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qvector< unsigned int >::iterator
        begin(self) -> qvector< unsigned int >::const_iterator
        """
        return _idaapi.uvalvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qvector< unsigned int >::iterator
        end(self) -> qvector< unsigned int >::const_iterator
        """
        return _idaapi.uvalvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> qvector< unsigned int >::iterator
        """
        return _idaapi.uvalvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> qvector< unsigned int >::iterator
        erase(self, first, last) -> qvector< unsigned int >::iterator
        """
        return _idaapi.uvalvec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> qvector< unsigned int >::iterator
        find(self, x) -> qvector< unsigned int >::const_iterator
        """
        return _idaapi.uvalvec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.uvalvec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.uvalvec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.uvalvec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.uvalvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> unsigned int const &
        """
        return _idaapi.uvalvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.uvalvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

uvalvec_t_swigregister = _idaapi.uvalvec_t_swigregister
uvalvec_t_swigregister(uvalvec_t)

class intvec_t(object):
    """
    Proxy of C++ qvector<(int)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> intvec_t
        __init__(self, x) -> intvec_t
        """
        this = _idaapi.new_intvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_intvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> int &
        """
        return _idaapi.intvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.intvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.intvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.intvec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> int const &
        """
        return _idaapi.intvec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> int const
        front(self) -> int &
        """
        return _idaapi.intvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> int const
        back(self) -> int &
        """
        return _idaapi.intvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.intvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.intvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.intvec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=int())
        """
        return _idaapi.intvec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.intvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.intvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.intvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.intvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> int *
        """
        return _idaapi.intvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.intvec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.intvec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.intvec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qvector< int >::iterator
        begin(self) -> qvector< int >::const_iterator
        """
        return _idaapi.intvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qvector< int >::iterator
        end(self) -> qvector< int >::const_iterator
        """
        return _idaapi.intvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> qvector< int >::iterator
        """
        return _idaapi.intvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> qvector< int >::iterator
        erase(self, first, last) -> qvector< int >::iterator
        """
        return _idaapi.intvec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> qvector< int >::iterator
        find(self, x) -> qvector< int >::const_iterator
        """
        return _idaapi.intvec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.intvec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.intvec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.intvec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.intvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> int const &
        """
        return _idaapi.intvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.intvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

intvec_t_swigregister = _idaapi.intvec_t_swigregister
intvec_t_swigregister(intvec_t)

class boolvec_t(object):
    """
    Proxy of C++ qvector<(bool)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> boolvec_t
        __init__(self, x) -> boolvec_t
        """
        this = _idaapi.new_boolvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_boolvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> bool &
        """
        return _idaapi.boolvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.boolvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.boolvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.boolvec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> bool const &
        """
        return _idaapi.boolvec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> bool const
        front(self) -> bool &
        """
        return _idaapi.boolvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> bool const
        back(self) -> bool &
        """
        return _idaapi.boolvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.boolvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.boolvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.boolvec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=bool())
        """
        return _idaapi.boolvec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.boolvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.boolvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.boolvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.boolvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> bool *
        """
        return _idaapi.boolvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.boolvec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.boolvec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.boolvec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qvector< bool >::iterator
        begin(self) -> qvector< bool >::const_iterator
        """
        return _idaapi.boolvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qvector< bool >::iterator
        end(self) -> qvector< bool >::const_iterator
        """
        return _idaapi.boolvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> qvector< bool >::iterator
        """
        return _idaapi.boolvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> qvector< bool >::iterator
        erase(self, first, last) -> qvector< bool >::iterator
        """
        return _idaapi.boolvec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> qvector< bool >::iterator
        find(self, x) -> qvector< bool >::const_iterator
        """
        return _idaapi.boolvec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.boolvec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.boolvec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.boolvec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.boolvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> bool const &
        """
        return _idaapi.boolvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.boolvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

boolvec_t_swigregister = _idaapi.boolvec_t_swigregister
boolvec_t_swigregister(boolvec_t)

class casevec_t(object):
    """
    Proxy of C++ qvector<(qvector<(sval_t)>)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> casevec_t
        __init__(self, x) -> casevec_t
        """
        this = _idaapi.new_casevec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_casevec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> intvec_t
        """
        return _idaapi.casevec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.casevec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.casevec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.casevec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> intvec_t
        """
        return _idaapi.casevec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> intvec_t
        front(self) -> intvec_t
        """
        return _idaapi.casevec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> intvec_t
        back(self) -> intvec_t
        """
        return _idaapi.casevec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.casevec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.casevec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.casevec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=qvector< int >())
        """
        return _idaapi.casevec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.casevec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.casevec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.casevec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.casevec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> intvec_t
        """
        return _idaapi.casevec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.casevec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.casevec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.casevec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> intvec_t
        begin(self) -> intvec_t
        """
        return _idaapi.casevec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> intvec_t
        end(self) -> intvec_t
        """
        return _idaapi.casevec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> intvec_t
        """
        return _idaapi.casevec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> intvec_t
        erase(self, first, last) -> intvec_t
        """
        return _idaapi.casevec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> intvec_t
        find(self, x) -> intvec_t
        """
        return _idaapi.casevec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.casevec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.casevec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.casevec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.casevec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> intvec_t
        """
        return _idaapi.casevec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.casevec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

casevec_t_swigregister = _idaapi.casevec_t_swigregister
casevec_t_swigregister(casevec_t)

class strvec_t(object):
    """
    Proxy of C++ qvector<(simpleline_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> strvec_t
        __init__(self, x) -> strvec_t
        """
        this = _idaapi.new_strvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_strvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> simpleline_t
        """
        return _idaapi.strvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.strvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.strvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.strvec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> simpleline_t
        """
        return _idaapi.strvec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> simpleline_t
        front(self) -> simpleline_t
        """
        return _idaapi.strvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> simpleline_t
        back(self) -> simpleline_t
        """
        return _idaapi.strvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.strvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.strvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.strvec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=simpleline_t())
        """
        return _idaapi.strvec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.strvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.strvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.strvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.strvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> simpleline_t
        """
        return _idaapi.strvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.strvec_t_inject(self, *args)

    def begin(self, *args):
        """
        begin(self) -> simpleline_t
        begin(self) -> simpleline_t
        """
        return _idaapi.strvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> simpleline_t
        end(self) -> simpleline_t
        """
        return _idaapi.strvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> simpleline_t
        """
        return _idaapi.strvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> simpleline_t
        erase(self, first, last) -> simpleline_t
        """
        return _idaapi.strvec_t_erase(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.strvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> simpleline_t
        """
        return _idaapi.strvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.strvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

strvec_t_swigregister = _idaapi.strvec_t_swigregister
strvec_t_swigregister(strvec_t)

_listify_types(uvalvec_t,
               intvec_t,
               boolvec_t,
               casevec_t,
               strvec_t)

class uchar_array(object):
    """
    Proxy of C++ uchar_array class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, nelements) -> uchar_array
        """
        this = _idaapi.new_uchar_array(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_uchar_array
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(self, index) -> uchar
        """
        return _idaapi.uchar_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, index, value)
        """
        return _idaapi.uchar_array___setitem__(self, *args)

    def cast(self, *args):
        """
        cast(self) -> uchar *
        """
        return _idaapi.uchar_array_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> uchar_array
        """
        return _idaapi.uchar_array_frompointer(*args)

    frompointer = staticmethod(frompointer)
uchar_array_swigregister = _idaapi.uchar_array_swigregister
uchar_array_swigregister(uchar_array)

def uchar_array_frompointer(*args):
  """
  uchar_array_frompointer(t) -> uchar_array
  """
  return _idaapi.uchar_array_frompointer(*args)

class tid_array(object):
    """
    Proxy of C++ tid_array class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, nelements) -> tid_array
        """
        this = _idaapi.new_tid_array(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_tid_array
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(self, index) -> tid_t
        """
        return _idaapi.tid_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, index, value)
        """
        return _idaapi.tid_array___setitem__(self, *args)

    def cast(self, *args):
        """
        cast(self) -> tid_t *
        """
        return _idaapi.tid_array_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> tid_array
        """
        return _idaapi.tid_array_frompointer(*args)

    frompointer = staticmethod(frompointer)
tid_array_swigregister = _idaapi.tid_array_swigregister
tid_array_swigregister(tid_array)

def tid_array_frompointer(*args):
  """
  tid_array_frompointer(t) -> tid_array
  """
  return _idaapi.tid_array_frompointer(*args)

class ea_array(object):
    """
    Proxy of C++ ea_array class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, nelements) -> ea_array
        """
        this = _idaapi.new_ea_array(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ea_array
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(self, index) -> ea_t
        """
        return _idaapi.ea_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, index, value)
        """
        return _idaapi.ea_array___setitem__(self, *args)

    def cast(self, *args):
        """
        cast(self) -> ea_t *
        """
        return _idaapi.ea_array_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> ea_array
        """
        return _idaapi.ea_array_frompointer(*args)

    frompointer = staticmethod(frompointer)
ea_array_swigregister = _idaapi.ea_array_swigregister
ea_array_swigregister(ea_array)

def ea_array_frompointer(*args):
  """
  ea_array_frompointer(t) -> ea_array
  """
  return _idaapi.ea_array_frompointer(*args)

class sel_array(object):
    """
    Proxy of C++ sel_array class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, nelements) -> sel_array
        """
        this = _idaapi.new_sel_array(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_sel_array
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(self, index) -> sel_t
        """
        return _idaapi.sel_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, index, value)
        """
        return _idaapi.sel_array___setitem__(self, *args)

    def cast(self, *args):
        """
        cast(self) -> sel_t *
        """
        return _idaapi.sel_array_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> sel_array
        """
        return _idaapi.sel_array_frompointer(*args)

    frompointer = staticmethod(frompointer)
sel_array_swigregister = _idaapi.sel_array_swigregister
sel_array_swigregister(sel_array)

def sel_array_frompointer(*args):
  """
  sel_array_frompointer(t) -> sel_array
  """
  return _idaapi.sel_array_frompointer(*args)

class uval_array(object):
    """
    Proxy of C++ uval_array class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, nelements) -> uval_array
        """
        this = _idaapi.new_uval_array(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_uval_array
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(self, index) -> uval_t
        """
        return _idaapi.uval_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, index, value)
        """
        return _idaapi.uval_array___setitem__(self, *args)

    def cast(self, *args):
        """
        cast(self) -> uval_t *
        """
        return _idaapi.uval_array_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> uval_array
        """
        return _idaapi.uval_array_frompointer(*args)

    frompointer = staticmethod(frompointer)
uval_array_swigregister = _idaapi.uval_array_swigregister
uval_array_swigregister(uval_array)

def uval_array_frompointer(*args):
  """
  uval_array_frompointer(t) -> uval_array
  """
  return _idaapi.uval_array_frompointer(*args)

class int_pointer(object):
    """
    Proxy of C++ int_pointer class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> int_pointer
        """
        this = _idaapi.new_int_pointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_int_pointer
    __del__ = lambda self : None;
    def assign(self, *args):
        """
        assign(self, value)
        """
        return _idaapi.int_pointer_assign(self, *args)

    def value(self, *args):
        """
        value(self) -> int
        """
        return _idaapi.int_pointer_value(self, *args)

    def cast(self, *args):
        """
        cast(self) -> int *
        """
        return _idaapi.int_pointer_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> int_pointer
        """
        return _idaapi.int_pointer_frompointer(*args)

    frompointer = staticmethod(frompointer)
int_pointer_swigregister = _idaapi.int_pointer_swigregister
int_pointer_swigregister(int_pointer)

def int_pointer_frompointer(*args):
  """
  int_pointer_frompointer(t) -> int_pointer
  """
  return _idaapi.int_pointer_frompointer(*args)

class ea_pointer(object):
    """
    Proxy of C++ ea_pointer class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> ea_pointer
        """
        this = _idaapi.new_ea_pointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ea_pointer
    __del__ = lambda self : None;
    def assign(self, *args):
        """
        assign(self, value)
        """
        return _idaapi.ea_pointer_assign(self, *args)

    def value(self, *args):
        """
        value(self) -> ea_t
        """
        return _idaapi.ea_pointer_value(self, *args)

    def cast(self, *args):
        """
        cast(self) -> ea_t *
        """
        return _idaapi.ea_pointer_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> ea_pointer
        """
        return _idaapi.ea_pointer_frompointer(*args)

    frompointer = staticmethod(frompointer)
ea_pointer_swigregister = _idaapi.ea_pointer_swigregister
ea_pointer_swigregister(ea_pointer)

def ea_pointer_frompointer(*args):
  """
  ea_pointer_frompointer(t) -> ea_pointer
  """
  return _idaapi.ea_pointer_frompointer(*args)

class sval_pointer(object):
    """
    Proxy of C++ sval_pointer class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> sval_pointer
        """
        this = _idaapi.new_sval_pointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_sval_pointer
    __del__ = lambda self : None;
    def assign(self, *args):
        """
        assign(self, value)
        """
        return _idaapi.sval_pointer_assign(self, *args)

    def value(self, *args):
        """
        value(self) -> sval_t
        """
        return _idaapi.sval_pointer_value(self, *args)

    def cast(self, *args):
        """
        cast(self) -> sval_t *
        """
        return _idaapi.sval_pointer_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> sval_pointer
        """
        return _idaapi.sval_pointer_frompointer(*args)

    frompointer = staticmethod(frompointer)
sval_pointer_swigregister = _idaapi.sval_pointer_swigregister
sval_pointer_swigregister(sval_pointer)

def sval_pointer_frompointer(*args):
  """
  sval_pointer_frompointer(t) -> sval_pointer
  """
  return _idaapi.sval_pointer_frompointer(*args)

class sel_pointer(object):
    """
    Proxy of C++ sel_pointer class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> sel_pointer
        """
        this = _idaapi.new_sel_pointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_sel_pointer
    __del__ = lambda self : None;
    def assign(self, *args):
        """
        assign(self, value)
        """
        return _idaapi.sel_pointer_assign(self, *args)

    def value(self, *args):
        """
        value(self) -> sel_t
        """
        return _idaapi.sel_pointer_value(self, *args)

    def cast(self, *args):
        """
        cast(self) -> sel_t *
        """
        return _idaapi.sel_pointer_cast(self, *args)

    def frompointer(*args):
        """
        frompointer(t) -> sel_pointer
        """
        return _idaapi.sel_pointer_frompointer(*args)

    frompointer = staticmethod(frompointer)
sel_pointer_swigregister = _idaapi.sel_pointer_swigregister
sel_pointer_swigregister(sel_pointer)

def sel_pointer_frompointer(*args):
  """
  sel_pointer_frompointer(t) -> sel_pointer
  """
  return _idaapi.sel_pointer_frompointer(*args)

f_EXE_old = _idaapi.f_EXE_old
f_COM_old = _idaapi.f_COM_old
f_BIN = _idaapi.f_BIN
f_DRV = _idaapi.f_DRV
f_WIN = _idaapi.f_WIN
f_HEX = _idaapi.f_HEX
f_MEX = _idaapi.f_MEX
f_LX = _idaapi.f_LX
f_LE = _idaapi.f_LE
f_NLM = _idaapi.f_NLM
f_COFF = _idaapi.f_COFF
f_PE = _idaapi.f_PE
f_OMF = _idaapi.f_OMF
f_SREC = _idaapi.f_SREC
f_ZIP = _idaapi.f_ZIP
f_OMFLIB = _idaapi.f_OMFLIB
f_AR = _idaapi.f_AR
f_LOADER = _idaapi.f_LOADER
f_ELF = _idaapi.f_ELF
f_W32RUN = _idaapi.f_W32RUN
f_AOUT = _idaapi.f_AOUT
f_PRC = _idaapi.f_PRC
f_EXE = _idaapi.f_EXE
f_COM = _idaapi.f_COM
f_AIXAR = _idaapi.f_AIXAR
f_MACHO = _idaapi.f_MACHO
class compiler_info_t(object):
    """
    Proxy of C++ compiler_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    id = _swig_property(_idaapi.compiler_info_t_id_get, _idaapi.compiler_info_t_id_set)
    cm = _swig_property(_idaapi.compiler_info_t_cm_get, _idaapi.compiler_info_t_cm_set)
    size_i = _swig_property(_idaapi.compiler_info_t_size_i_get, _idaapi.compiler_info_t_size_i_set)
    size_b = _swig_property(_idaapi.compiler_info_t_size_b_get, _idaapi.compiler_info_t_size_b_set)
    size_e = _swig_property(_idaapi.compiler_info_t_size_e_get, _idaapi.compiler_info_t_size_e_set)
    defalign = _swig_property(_idaapi.compiler_info_t_defalign_get, _idaapi.compiler_info_t_defalign_set)
    size_s = _swig_property(_idaapi.compiler_info_t_size_s_get, _idaapi.compiler_info_t_size_s_set)
    size_l = _swig_property(_idaapi.compiler_info_t_size_l_get, _idaapi.compiler_info_t_size_l_set)
    size_ll = _swig_property(_idaapi.compiler_info_t_size_ll_get, _idaapi.compiler_info_t_size_ll_set)
    def __init__(self, *args):
        """
        __init__(self) -> compiler_info_t
        """
        this = _idaapi.new_compiler_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_compiler_info_t
    __del__ = lambda self : None;
compiler_info_t_swigregister = _idaapi.compiler_info_t_swigregister
compiler_info_t_swigregister(compiler_info_t)

STT_CUR = _idaapi.STT_CUR
STT_VA = _idaapi.STT_VA
STT_MM = _idaapi.STT_MM
STT_DBG = _idaapi.STT_DBG
class idainfo(object):
    """
    Proxy of C++ idainfo class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    tag = _swig_property(_idaapi.idainfo_tag_get, _idaapi.idainfo_tag_set)
    version = _swig_property(_idaapi.idainfo_version_get, _idaapi.idainfo_version_set)
    procName = _swig_property(_idaapi.idainfo_procName_get, _idaapi.idainfo_procName_set)
    def set_proc_name(self, *args):
        """
        set_proc_name(self, name)
        """
        return _idaapi.idainfo_set_proc_name(self, *args)

    def get_proc_name(self, *args):
        """
        get_proc_name(self) -> char *
        """
        return _idaapi.idainfo_get_proc_name(self, *args)

    lflags = _swig_property(_idaapi.idainfo_lflags_get, _idaapi.idainfo_lflags_set)
    def is_32bit(self, *args):
        """
        is_32bit(self) -> bool
        """
        return _idaapi.idainfo_is_32bit(self, *args)

    def is_64bit(self, *args):
        """
        is_64bit(self) -> bool
        """
        return _idaapi.idainfo_is_64bit(self, *args)

    def is_snapshot(self, *args):
        """
        is_snapshot(self) -> bool
        """
        return _idaapi.idainfo_is_snapshot(self, *args)

    def is_dll(self, *args):
        """
        is_dll(self) -> bool
        """
        return _idaapi.idainfo_is_dll(self, *args)

    demnames = _swig_property(_idaapi.idainfo_demnames_get, _idaapi.idainfo_demnames_set)
    def get_demname_form(self, *args):
        """
        get_demname_form(self) -> uchar
        """
        return _idaapi.idainfo_get_demname_form(self, *args)

    filetype = _swig_property(_idaapi.idainfo_filetype_get, _idaapi.idainfo_filetype_set)
    def like_binary(self, *args):
        """
        like_binary(self) -> bool
        """
        return _idaapi.idainfo_like_binary(self, *args)

    fcoresiz = _swig_property(_idaapi.idainfo_fcoresiz_get, _idaapi.idainfo_fcoresiz_set)
    corestart = _swig_property(_idaapi.idainfo_corestart_get, _idaapi.idainfo_corestart_set)
    ostype = _swig_property(_idaapi.idainfo_ostype_get, _idaapi.idainfo_ostype_set)
    apptype = _swig_property(_idaapi.idainfo_apptype_get, _idaapi.idainfo_apptype_set)
    startSP = _swig_property(_idaapi.idainfo_startSP_get, _idaapi.idainfo_startSP_set)
    af = _swig_property(_idaapi.idainfo_af_get, _idaapi.idainfo_af_set)
    startIP = _swig_property(_idaapi.idainfo_startIP_get, _idaapi.idainfo_startIP_set)
    beginEA = _swig_property(_idaapi.idainfo_beginEA_get, _idaapi.idainfo_beginEA_set)
    minEA = _swig_property(_idaapi.idainfo_minEA_get, _idaapi.idainfo_minEA_set)
    maxEA = _swig_property(_idaapi.idainfo_maxEA_get, _idaapi.idainfo_maxEA_set)
    ominEA = _swig_property(_idaapi.idainfo_ominEA_get, _idaapi.idainfo_ominEA_set)
    omaxEA = _swig_property(_idaapi.idainfo_omaxEA_get, _idaapi.idainfo_omaxEA_set)
    lowoff = _swig_property(_idaapi.idainfo_lowoff_get, _idaapi.idainfo_lowoff_set)
    highoff = _swig_property(_idaapi.idainfo_highoff_get, _idaapi.idainfo_highoff_set)
    maxref = _swig_property(_idaapi.idainfo_maxref_get, _idaapi.idainfo_maxref_set)
    ASCIIbreak = _swig_property(_idaapi.idainfo_ASCIIbreak_get, _idaapi.idainfo_ASCIIbreak_set)
    wide_high_byte_first = _swig_property(_idaapi.idainfo_wide_high_byte_first_get, _idaapi.idainfo_wide_high_byte_first_set)
    indent = _swig_property(_idaapi.idainfo_indent_get, _idaapi.idainfo_indent_set)
    comment = _swig_property(_idaapi.idainfo_comment_get, _idaapi.idainfo_comment_set)
    xrefnum = _swig_property(_idaapi.idainfo_xrefnum_get, _idaapi.idainfo_xrefnum_set)
    s_entab = _swig_property(_idaapi.idainfo_s_entab_get, _idaapi.idainfo_s_entab_set)
    specsegs = _swig_property(_idaapi.idainfo_specsegs_get, _idaapi.idainfo_specsegs_set)
    s_void = _swig_property(_idaapi.idainfo_s_void_get, _idaapi.idainfo_s_void_set)
    type_xrefnum = _swig_property(_idaapi.idainfo_type_xrefnum_get, _idaapi.idainfo_type_xrefnum_set)
    s_showauto = _swig_property(_idaapi.idainfo_s_showauto_get, _idaapi.idainfo_s_showauto_set)
    s_auto = _swig_property(_idaapi.idainfo_s_auto_get, _idaapi.idainfo_s_auto_set)
    s_limiter = _swig_property(_idaapi.idainfo_s_limiter_get, _idaapi.idainfo_s_limiter_set)
    s_null = _swig_property(_idaapi.idainfo_s_null_get, _idaapi.idainfo_s_null_set)
    s_genflags = _swig_property(_idaapi.idainfo_s_genflags_get, _idaapi.idainfo_s_genflags_set)
    def use_allasm(self, *args):
        """
        use_allasm(self) -> bool
        """
        return _idaapi.idainfo_use_allasm(self, *args)

    def loading_idc(self, *args):
        """
        loading_idc(self) -> bool
        """
        return _idaapi.idainfo_loading_idc(self, *args)

    s_showpref = _swig_property(_idaapi.idainfo_s_showpref_get, _idaapi.idainfo_s_showpref_set)
    s_prefseg = _swig_property(_idaapi.idainfo_s_prefseg_get, _idaapi.idainfo_s_prefseg_set)
    asmtype = _swig_property(_idaapi.idainfo_asmtype_get, _idaapi.idainfo_asmtype_set)
    baseaddr = _swig_property(_idaapi.idainfo_baseaddr_get, _idaapi.idainfo_baseaddr_set)
    s_xrefflag = _swig_property(_idaapi.idainfo_s_xrefflag_get, _idaapi.idainfo_s_xrefflag_set)
    binSize = _swig_property(_idaapi.idainfo_binSize_get, _idaapi.idainfo_binSize_set)
    s_cmtflg = _swig_property(_idaapi.idainfo_s_cmtflg_get, _idaapi.idainfo_s_cmtflg_set)
    nametype = _swig_property(_idaapi.idainfo_nametype_get, _idaapi.idainfo_nametype_set)
    s_showbads = _swig_property(_idaapi.idainfo_s_showbads_get, _idaapi.idainfo_s_showbads_set)
    s_prefflag = _swig_property(_idaapi.idainfo_s_prefflag_get, _idaapi.idainfo_s_prefflag_set)
    s_packbase = _swig_property(_idaapi.idainfo_s_packbase_get, _idaapi.idainfo_s_packbase_set)
    asciiflags = _swig_property(_idaapi.idainfo_asciiflags_get, _idaapi.idainfo_asciiflags_set)
    listnames = _swig_property(_idaapi.idainfo_listnames_get, _idaapi.idainfo_listnames_set)
    ASCIIpref = _swig_property(_idaapi.idainfo_ASCIIpref_get, _idaapi.idainfo_ASCIIpref_set)
    ASCIIsernum = _swig_property(_idaapi.idainfo_ASCIIsernum_get, _idaapi.idainfo_ASCIIsernum_set)
    ASCIIzeroes = _swig_property(_idaapi.idainfo_ASCIIzeroes_get, _idaapi.idainfo_ASCIIzeroes_set)
    graph_view = _swig_property(_idaapi.idainfo_graph_view_get, _idaapi.idainfo_graph_view_set)
    s_reserved5 = _swig_property(_idaapi.idainfo_s_reserved5_get, _idaapi.idainfo_s_reserved5_set)
    tribyte_order = _swig_property(_idaapi.idainfo_tribyte_order_get, _idaapi.idainfo_tribyte_order_set)
    mf = _swig_property(_idaapi.idainfo_mf_get, _idaapi.idainfo_mf_set)
    s_org = _swig_property(_idaapi.idainfo_s_org_get, _idaapi.idainfo_s_org_set)
    s_assume = _swig_property(_idaapi.idainfo_s_assume_get, _idaapi.idainfo_s_assume_set)
    s_checkarg = _swig_property(_idaapi.idainfo_s_checkarg_get, _idaapi.idainfo_s_checkarg_set)
    start_ss = _swig_property(_idaapi.idainfo_start_ss_get, _idaapi.idainfo_start_ss_set)
    start_cs = _swig_property(_idaapi.idainfo_start_cs_get, _idaapi.idainfo_start_cs_set)
    main = _swig_property(_idaapi.idainfo_main_get, _idaapi.idainfo_main_set)
    short_demnames = _swig_property(_idaapi.idainfo_short_demnames_get, _idaapi.idainfo_short_demnames_set)
    long_demnames = _swig_property(_idaapi.idainfo_long_demnames_get, _idaapi.idainfo_long_demnames_set)
    datatypes = _swig_property(_idaapi.idainfo_datatypes_get, _idaapi.idainfo_datatypes_set)
    strtype = _swig_property(_idaapi.idainfo_strtype_get, _idaapi.idainfo_strtype_set)
    af2 = _swig_property(_idaapi.idainfo_af2_get, _idaapi.idainfo_af2_set)
    namelen = _swig_property(_idaapi.idainfo_namelen_get, _idaapi.idainfo_namelen_set)
    margin = _swig_property(_idaapi.idainfo_margin_get, _idaapi.idainfo_margin_set)
    lenxref = _swig_property(_idaapi.idainfo_lenxref_get, _idaapi.idainfo_lenxref_set)
    lprefix = _swig_property(_idaapi.idainfo_lprefix_get, _idaapi.idainfo_lprefix_set)
    lprefixlen = _swig_property(_idaapi.idainfo_lprefixlen_get, _idaapi.idainfo_lprefixlen_set)
    cc = _swig_property(_idaapi.idainfo_cc_get, _idaapi.idainfo_cc_set)
    database_change_count = _swig_property(_idaapi.idainfo_database_change_count_get, _idaapi.idainfo_database_change_count_set)
    size_ldbl = _swig_property(_idaapi.idainfo_size_ldbl_get, _idaapi.idainfo_size_ldbl_set)
    appcall_options = _swig_property(_idaapi.idainfo_appcall_options_get, _idaapi.idainfo_appcall_options_set)
    reserved = _swig_property(_idaapi.idainfo_reserved_get, _idaapi.idainfo_reserved_set)
    def __init__(self, *args):
        """
        __init__(self) -> idainfo
        """
        this = _idaapi.new_idainfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idainfo
    __del__ = lambda self : None;
idainfo_swigregister = _idaapi.idainfo_swigregister
idainfo_swigregister(idainfo)
LFLG_PC_FPP = _idaapi.LFLG_PC_FPP
LFLG_PC_FLAT = _idaapi.LFLG_PC_FLAT
LFLG_64BIT = _idaapi.LFLG_64BIT
LFLG_DBG_NOPATH = _idaapi.LFLG_DBG_NOPATH
LFLG_SNAPSHOT = _idaapi.LFLG_SNAPSHOT
LFLG_IS_DLL = _idaapi.LFLG_IS_DLL
DEMNAM_MASK = _idaapi.DEMNAM_MASK
DEMNAM_CMNT = _idaapi.DEMNAM_CMNT
DEMNAM_NAME = _idaapi.DEMNAM_NAME
DEMNAM_NONE = _idaapi.DEMNAM_NONE
DEMNAM_GCC3 = _idaapi.DEMNAM_GCC3
AF_FIXUP = _idaapi.AF_FIXUP
AF_MARKCODE = _idaapi.AF_MARKCODE
AF_UNK = _idaapi.AF_UNK
AF_CODE = _idaapi.AF_CODE
AF_PROC = _idaapi.AF_PROC
AF_USED = _idaapi.AF_USED
AF_FLIRT = _idaapi.AF_FLIRT
AF_PROCPTR = _idaapi.AF_PROCPTR
AF_JFUNC = _idaapi.AF_JFUNC
AF_NULLSUB = _idaapi.AF_NULLSUB
AF_LVAR = _idaapi.AF_LVAR
AF_TRACE = _idaapi.AF_TRACE
AF_ASCII = _idaapi.AF_ASCII
AF_IMMOFF = _idaapi.AF_IMMOFF
AF_DREFOFF = _idaapi.AF_DREFOFF
AF_FINAL = _idaapi.AF_FINAL
LMT_THIN = _idaapi.LMT_THIN
LMT_THICK = _idaapi.LMT_THICK
LMT_EMPTY = _idaapi.LMT_EMPTY
INFFL_LZERO = _idaapi.INFFL_LZERO
INFFL_ALLASM = _idaapi.INFFL_ALLASM
INFFL_LOADIDC = _idaapi.INFFL_LOADIDC
SW_SEGXRF = _idaapi.SW_SEGXRF
SW_XRFMRK = _idaapi.SW_XRFMRK
SW_XRFFNC = _idaapi.SW_XRFFNC
SW_XRFVAL = _idaapi.SW_XRFVAL
SW_RPTCMT = _idaapi.SW_RPTCMT
SW_ALLCMT = _idaapi.SW_ALLCMT
SW_NOCMT = _idaapi.SW_NOCMT
SW_LINNUM = _idaapi.SW_LINNUM
SW_TESTMODE = _idaapi.SW_TESTMODE
SW_SHHID_ITEM = _idaapi.SW_SHHID_ITEM
SW_SHHID_FUNC = _idaapi.SW_SHHID_FUNC
SW_SHHID_SEGM = _idaapi.SW_SHHID_SEGM
NM_REL_OFF = _idaapi.NM_REL_OFF
NM_PTR_OFF = _idaapi.NM_PTR_OFF
NM_NAM_OFF = _idaapi.NM_NAM_OFF
NM_REL_EA = _idaapi.NM_REL_EA
NM_PTR_EA = _idaapi.NM_PTR_EA
NM_NAM_EA = _idaapi.NM_NAM_EA
NM_EA = _idaapi.NM_EA
NM_EA4 = _idaapi.NM_EA4
NM_EA8 = _idaapi.NM_EA8
NM_SHORT = _idaapi.NM_SHORT
NM_SERIAL = _idaapi.NM_SERIAL
PREF_SEGADR = _idaapi.PREF_SEGADR
PREF_FNCOFF = _idaapi.PREF_FNCOFF
PREF_STACK = _idaapi.PREF_STACK
PREF_VARMARK = _idaapi.PREF_VARMARK
ASCF_GEN = _idaapi.ASCF_GEN
ASCF_AUTO = _idaapi.ASCF_AUTO
ASCF_SERIAL = _idaapi.ASCF_SERIAL
ASCF_UNICODE = _idaapi.ASCF_UNICODE
ASCF_COMMENT = _idaapi.ASCF_COMMENT
ASCF_SAVECASE = _idaapi.ASCF_SAVECASE
LN_NORMAL = _idaapi.LN_NORMAL
LN_PUBLIC = _idaapi.LN_PUBLIC
LN_AUTO = _idaapi.LN_AUTO
LN_WEAK = _idaapi.LN_WEAK
AF2_JUMPTBL = _idaapi.AF2_JUMPTBL
AF2_DODATA = _idaapi.AF2_DODATA
AF2_HFLIRT = _idaapi.AF2_HFLIRT
AF2_STKARG = _idaapi.AF2_STKARG
AF2_REGARG = _idaapi.AF2_REGARG
AF2_CHKUNI = _idaapi.AF2_CHKUNI
AF2_SIGCMT = _idaapi.AF2_SIGCMT
AF2_SIGMLT = _idaapi.AF2_SIGMLT
AF2_FTAIL = _idaapi.AF2_FTAIL
AF2_DATOFF = _idaapi.AF2_DATOFF
AF2_ANORET = _idaapi.AF2_ANORET
AF2_VERSP = _idaapi.AF2_VERSP
AF2_DOCODE = _idaapi.AF2_DOCODE
AF2_TRFUNC = _idaapi.AF2_TRFUNC
AF2_PURDAT = _idaapi.AF2_PURDAT
AF2_MEMFUNC = _idaapi.AF2_MEMFUNC

class text_options_t(object):
    """
    Proxy of C++ text_options_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    text = _swig_property(_idaapi.text_options_t_text_get, _idaapi.text_options_t_text_set)
    graph = _swig_property(_idaapi.text_options_t_graph_get, _idaapi.text_options_t_graph_set)
    def __init__(self, *args):
        """
        __init__(self) -> text_options_t
        """
        this = _idaapi.new_text_options_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy_to_inf(self, *args):
        """
        copy_to_inf(self, gv, _inf)
        """
        return _idaapi.text_options_t_copy_to_inf(self, *args)

    def copy_from_inf(self, *args):
        """
        copy_from_inf(self, _inf)
        """
        return _idaapi.text_options_t_copy_from_inf(self, *args)

    __swig_destroy__ = _idaapi.delete_text_options_t
    __del__ = lambda self : None;
text_options_t_swigregister = _idaapi.text_options_t_swigregister
text_options_t_swigregister(text_options_t)


def showRepeatables(*args):
  """
  showRepeatables() -> bool
  """
  return _idaapi.showRepeatables(*args)

def showAllComments(*args):
  """
  showAllComments() -> bool
  """
  return _idaapi.showAllComments(*args)

def showComments(*args):
  """
  showComments() -> bool
  """
  return _idaapi.showComments(*args)

def should_trace_sp(*args):
  """
  should_trace_sp() -> bool
  """
  return _idaapi.should_trace_sp(*args)

def should_create_stkvars(*args):
  """
  should_create_stkvars() -> bool
  """
  return _idaapi.should_create_stkvars(*args)
IDAPLACE_HEXDUMP = _idaapi.IDAPLACE_HEXDUMP
IDAPLACE_STACK = _idaapi.IDAPLACE_STACK
IDAPLACE_SEGADDR = _idaapi.IDAPLACE_SEGADDR

def calc_default_idaplace_flags(*args):
  """
  calc_default_idaplace_flags() -> int
  """
  return _idaapi.calc_default_idaplace_flags(*args)
MAXADDR = _idaapi.MAXADDR

def toEA(*args):
  """
  toEA(reg_cs, reg_ip) -> ea_t
  """
  return _idaapi.toEA(*args)

def idb2scr(*args):
  """
  idb2scr(name) -> char *
  """
  return _idaapi.idb2scr(*args)

def scr2idb(*args):
  """
  scr2idb(name) -> char *
  """
  return _idaapi.scr2idb(*args)

def ansi2idb(*args):
  """
  ansi2idb(name) -> char *
  """
  return _idaapi.ansi2idb(*args)
IDB_EXT32 = _idaapi.IDB_EXT32
IDB_EXT64 = _idaapi.IDB_EXT64
IDB_EXT = _idaapi.IDB_EXT

def dto_copy_to_inf(*args):
  """
  dto_copy_to_inf(arg1, inf)
  """
  return _idaapi.dto_copy_to_inf(*args)

def dto_copy_from_inf(*args):
  """
  dto_copy_from_inf(arg1, inf)
  """
  return _idaapi.dto_copy_from_inf(*args)

def dto_init(*args):
  """
  dto_init(dt, for_graph)
  """
  return _idaapi.dto_init(*args)
IDD_INTERFACE_VERSION = _idaapi.IDD_INTERFACE_VERSION
NO_THREAD = _idaapi.NO_THREAD
class process_info_t(object):
    """
    Proxy of C++ process_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pid = _swig_property(_idaapi.process_info_t_pid_get, _idaapi.process_info_t_pid_set)
    name = _swig_property(_idaapi.process_info_t_name_get, _idaapi.process_info_t_name_set)
    def __init__(self, *args):
        """
        __init__(self) -> process_info_t
        """
        this = _idaapi.new_process_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_process_info_t
    __del__ = lambda self : None;
process_info_t_swigregister = _idaapi.process_info_t_swigregister
process_info_t_swigregister(process_info_t)

class debapp_attrs_t(object):
    """
    Proxy of C++ debapp_attrs_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cbsize = _swig_property(_idaapi.debapp_attrs_t_cbsize_get, _idaapi.debapp_attrs_t_cbsize_set)
    addrsize = _swig_property(_idaapi.debapp_attrs_t_addrsize_get, _idaapi.debapp_attrs_t_addrsize_set)
    platform = _swig_property(_idaapi.debapp_attrs_t_platform_get, _idaapi.debapp_attrs_t_platform_set)
    def __init__(self, *args):
        """
        __init__(self) -> debapp_attrs_t
        """
        this = _idaapi.new_debapp_attrs_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_debapp_attrs_t
    __del__ = lambda self : None;
debapp_attrs_t_swigregister = _idaapi.debapp_attrs_t_swigregister
debapp_attrs_t_swigregister(debapp_attrs_t)
DEF_ADDRSIZE = _idaapi.DEF_ADDRSIZE

NO_EVENT = _idaapi.NO_EVENT
PROCESS_START = _idaapi.PROCESS_START
PROCESS_EXIT = _idaapi.PROCESS_EXIT
THREAD_START = _idaapi.THREAD_START
THREAD_EXIT = _idaapi.THREAD_EXIT
BREAKPOINT = _idaapi.BREAKPOINT
STEP = _idaapi.STEP
EXCEPTION = _idaapi.EXCEPTION
LIBRARY_LOAD = _idaapi.LIBRARY_LOAD
LIBRARY_UNLOAD = _idaapi.LIBRARY_UNLOAD
INFORMATION = _idaapi.INFORMATION
SYSCALL = _idaapi.SYSCALL
WINMESSAGE = _idaapi.WINMESSAGE
PROCESS_ATTACH = _idaapi.PROCESS_ATTACH
PROCESS_DETACH = _idaapi.PROCESS_DETACH
PROCESS_SUSPEND = _idaapi.PROCESS_SUSPEND
TRACE_FULL = _idaapi.TRACE_FULL
class module_info_t(object):
    """
    Proxy of C++ module_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.module_info_t_name_get, _idaapi.module_info_t_name_set)
    base = _swig_property(_idaapi.module_info_t_base_get, _idaapi.module_info_t_base_set)
    size = _swig_property(_idaapi.module_info_t_size_get, _idaapi.module_info_t_size_set)
    rebase_to = _swig_property(_idaapi.module_info_t_rebase_to_get, _idaapi.module_info_t_rebase_to_set)
    def __init__(self, *args):
        """
        __init__(self) -> module_info_t
        """
        this = _idaapi.new_module_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_module_info_t
    __del__ = lambda self : None;
module_info_t_swigregister = _idaapi.module_info_t_swigregister
module_info_t_swigregister(module_info_t)

class e_breakpoint_t(object):
    """
    Proxy of C++ e_breakpoint_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    hea = _swig_property(_idaapi.e_breakpoint_t_hea_get, _idaapi.e_breakpoint_t_hea_set)
    kea = _swig_property(_idaapi.e_breakpoint_t_kea_get, _idaapi.e_breakpoint_t_kea_set)
    def __init__(self, *args):
        """
        __init__(self) -> e_breakpoint_t
        """
        this = _idaapi.new_e_breakpoint_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_e_breakpoint_t
    __del__ = lambda self : None;
e_breakpoint_t_swigregister = _idaapi.e_breakpoint_t_swigregister
e_breakpoint_t_swigregister(e_breakpoint_t)

class e_exception_t(object):
    """
    Proxy of C++ e_exception_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    code = _swig_property(_idaapi.e_exception_t_code_get, _idaapi.e_exception_t_code_set)
    can_cont = _swig_property(_idaapi.e_exception_t_can_cont_get, _idaapi.e_exception_t_can_cont_set)
    ea = _swig_property(_idaapi.e_exception_t_ea_get, _idaapi.e_exception_t_ea_set)
    info = _swig_property(_idaapi.e_exception_t_info_get, _idaapi.e_exception_t_info_set)
    def __init__(self, *args):
        """
        __init__(self) -> e_exception_t
        """
        this = _idaapi.new_e_exception_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_e_exception_t
    __del__ = lambda self : None;
e_exception_t_swigregister = _idaapi.e_exception_t_swigregister
e_exception_t_swigregister(e_exception_t)

class debug_event_t(object):
    """
    Proxy of C++ debug_event_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> debug_event_t
        """
        this = _idaapi.new_debug_event_t(*args)
        try: self.this.append(this)
        except: self.this = this
    eid = _swig_property(_idaapi.debug_event_t_eid_get, _idaapi.debug_event_t_eid_set)
    pid = _swig_property(_idaapi.debug_event_t_pid_get, _idaapi.debug_event_t_pid_set)
    tid = _swig_property(_idaapi.debug_event_t_tid_get, _idaapi.debug_event_t_tid_set)
    ea = _swig_property(_idaapi.debug_event_t_ea_get, _idaapi.debug_event_t_ea_set)
    handled = _swig_property(_idaapi.debug_event_t_handled_get, _idaapi.debug_event_t_handled_set)
    modinfo = _swig_property(_idaapi.debug_event_t_modinfo_get, _idaapi.debug_event_t_modinfo_set)
    exit_code = _swig_property(_idaapi.debug_event_t_exit_code_get, _idaapi.debug_event_t_exit_code_set)
    info = _swig_property(_idaapi.debug_event_t_info_get, _idaapi.debug_event_t_info_set)
    bpt = _swig_property(_idaapi.debug_event_t_bpt_get, _idaapi.debug_event_t_bpt_set)
    exc = _swig_property(_idaapi.debug_event_t_exc_get, _idaapi.debug_event_t_exc_set)
    def bpt_ea(self, *args):
        """
        bpt_ea(self) -> ea_t
        """
        return _idaapi.debug_event_t_bpt_ea(self, *args)

    __swig_destroy__ = _idaapi.delete_debug_event_t
    __del__ = lambda self : None;
debug_event_t_swigregister = _idaapi.debug_event_t_swigregister
debug_event_t_swigregister(debug_event_t)

class exception_info_t(object):
    """
    Proxy of C++ exception_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    code = _swig_property(_idaapi.exception_info_t_code_get, _idaapi.exception_info_t_code_set)
    flags = _swig_property(_idaapi.exception_info_t_flags_get, _idaapi.exception_info_t_flags_set)
    def break_on(self, *args):
        """
        break_on(self) -> bool
        """
        return _idaapi.exception_info_t_break_on(self, *args)

    def handle(self, *args):
        """
        handle(self) -> bool
        """
        return _idaapi.exception_info_t_handle(self, *args)

    name = _swig_property(_idaapi.exception_info_t_name_get, _idaapi.exception_info_t_name_set)
    desc = _swig_property(_idaapi.exception_info_t_desc_get, _idaapi.exception_info_t_desc_set)
    def __init__(self, *args):
        """
        __init__(self) -> exception_info_t
        __init__(self, _code, _flags, _name, _desc) -> exception_info_t
        """
        this = _idaapi.new_exception_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_exception_info_t
    __del__ = lambda self : None;
exception_info_t_swigregister = _idaapi.exception_info_t_swigregister
exception_info_t_swigregister(exception_info_t)
BPT_OLD_EXEC = cvar.BPT_OLD_EXEC
BPT_WRITE = cvar.BPT_WRITE
BPT_READ = cvar.BPT_READ
BPT_RDWR = cvar.BPT_RDWR
BPT_SOFT = cvar.BPT_SOFT
BPT_EXEC = cvar.BPT_EXEC
BPT_DEFAULT = cvar.BPT_DEFAULT
EXC_BREAK = _idaapi.EXC_BREAK
EXC_HANDLE = _idaapi.EXC_HANDLE
EXC_MSG = _idaapi.EXC_MSG
EXC_SILENT = _idaapi.EXC_SILENT

class regval_t(object):
    """
    Proxy of C++ regval_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rvtype = _swig_property(_idaapi.regval_t_rvtype_get, _idaapi.regval_t_rvtype_set)
    ival = _swig_property(_idaapi.regval_t_ival_get, _idaapi.regval_t_ival_set)
    fval = _swig_property(_idaapi.regval_t_fval_get, _idaapi.regval_t_fval_set)
    __swig_destroy__ = _idaapi.delete_regval_t
    __del__ = lambda self : None;
    def __init__(self, *args):
        """
        __init__(self) -> regval_t
        __init__(self, r) -> regval_t
        """
        this = _idaapi.new_regval_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.regval_t_clear(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.regval_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.regval_t___ne__(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.regval_t_swap(self, *args)

    def _set_int(self, *args):
        """
        _set_int(self, x)
        """
        return _idaapi.regval_t__set_int(self, *args)

    def _set_float(self, *args):
        """
        _set_float(self, x)
        """
        return _idaapi.regval_t__set_float(self, *args)

    def _set_bytes(self, *args):
        """
        _set_bytes(self, data, size)
        _set_bytes(self, v)
        _set_bytes(self) -> bytevec_t &
        """
        return _idaapi.regval_t__set_bytes(self, *args)

    def set_int(self, *args):
        """
        set_int(self, x)
        """
        return _idaapi.regval_t_set_int(self, *args)

    def set_float(self, *args):
        """
        set_float(self, x)
        """
        return _idaapi.regval_t_set_float(self, *args)

    def set_bytes(self, *args):
        """
        set_bytes(self, data, size)
        set_bytes(self, v)
        set_bytes(self) -> bytevec_t &
        """
        return _idaapi.regval_t_set_bytes(self, *args)

    def bytes(self, *args):
        """
        bytes(self) -> bytevec_t
        bytes(self) -> bytevec_t const &
        """
        return _idaapi.regval_t_bytes(self, *args)

    def get_data(self, *args):
        """
        get_data(self)
        get_data(self) -> void const *
        """
        return _idaapi.regval_t_get_data(self, *args)

    def get_data_size(self, *args):
        """
        get_data_size(self) -> size_t
        """
        return _idaapi.regval_t_get_data_size(self, *args)

regval_t_swigregister = _idaapi.regval_t_swigregister
regval_t_swigregister(regval_t)
RVT_INT = _idaapi.RVT_INT
RVT_FLOAT = _idaapi.RVT_FLOAT

class call_stack_info_t(object):
    """
    Proxy of C++ call_stack_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    callea = _swig_property(_idaapi.call_stack_info_t_callea_get, _idaapi.call_stack_info_t_callea_set)
    funcea = _swig_property(_idaapi.call_stack_info_t_funcea_get, _idaapi.call_stack_info_t_funcea_set)
    fp = _swig_property(_idaapi.call_stack_info_t_fp_get, _idaapi.call_stack_info_t_fp_set)
    funcok = _swig_property(_idaapi.call_stack_info_t_funcok_get, _idaapi.call_stack_info_t_funcok_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.call_stack_info_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.call_stack_info_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> call_stack_info_t
        """
        this = _idaapi.new_call_stack_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_call_stack_info_t
    __del__ = lambda self : None;
call_stack_info_t_swigregister = _idaapi.call_stack_info_t_swigregister
call_stack_info_t_swigregister(call_stack_info_t)

class call_stack_t(object):
    """
    Proxy of C++ call_stack_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dirty = _swig_property(_idaapi.call_stack_t_dirty_get, _idaapi.call_stack_t_dirty_set)
    def __init__(self, *args):
        """
        __init__(self) -> call_stack_t
        """
        this = _idaapi.new_call_stack_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_call_stack_t
    __del__ = lambda self : None;
call_stack_t_swigregister = _idaapi.call_stack_t_swigregister
call_stack_t_swigregister(call_stack_t)


def dbg_appcall(*args):
  """
  dbg_appcall(func_ea, tid, tif, argnum, argv, r) -> error_t
  """
  return _idaapi.dbg_appcall(*args)

def cleanup_appcall(*args):
  """
  cleanup_appcall(tid) -> error_t
  """
  return _idaapi.cleanup_appcall(*args)
RESMOD_NONE = _idaapi.RESMOD_NONE
RESMOD_INTO = _idaapi.RESMOD_INTO
RESMOD_OVER = _idaapi.RESMOD_OVER
RESMOD_OUT = _idaapi.RESMOD_OUT
RESMOD_SRCINTO = _idaapi.RESMOD_SRCINTO
RESMOD_SRCOVER = _idaapi.RESMOD_SRCOVER
RESMOD_SRCOUT = _idaapi.RESMOD_SRCOUT
RESMOD_USER = _idaapi.RESMOD_USER
RESMOD_HANDLE = _idaapi.RESMOD_HANDLE
RESMOD_MAX = _idaapi.RESMOD_MAX
PROCESS_NO_THREAD = _idaapi.PROCESS_NO_THREAD
class idd_opinfo_old_t(object):
    """
    Proxy of C++ idd_opinfo_old_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    addr = _swig_property(_idaapi.idd_opinfo_old_t_addr_get, _idaapi.idd_opinfo_old_t_addr_set)
    value = _swig_property(_idaapi.idd_opinfo_old_t_value_get, _idaapi.idd_opinfo_old_t_value_set)
    modified = _swig_property(_idaapi.idd_opinfo_old_t_modified_get, _idaapi.idd_opinfo_old_t_modified_set)
    def __init__(self, *args):
        """
        __init__(self) -> idd_opinfo_old_t
        """
        this = _idaapi.new_idd_opinfo_old_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idd_opinfo_old_t
    __del__ = lambda self : None;
idd_opinfo_old_t_swigregister = _idaapi.idd_opinfo_old_t_swigregister
idd_opinfo_old_t_swigregister(idd_opinfo_old_t)


def handle_debug_event(*args):
  """
  handle_debug_event(ev, rqflags) -> int
  """
  return _idaapi.handle_debug_event(*args)
RQ_MASKING = _idaapi.RQ_MASKING
RQ_SUSPEND = _idaapi.RQ_SUSPEND
RQ_NOSUSP = _idaapi.RQ_NOSUSP
RQ_IGNWERR = _idaapi.RQ_IGNWERR
RQ_SILENT = _idaapi.RQ_SILENT
RQ_VERBOSE = _idaapi.RQ_VERBOSE
RQ_SWSCREEN = _idaapi.RQ_SWSCREEN
RQ__NOTHRRF = _idaapi.RQ__NOTHRRF
RQ_PROCEXIT = _idaapi.RQ_PROCEXIT
RQ_IDAIDLE = _idaapi.RQ_IDAIDLE
RQ_SUSPRUN = _idaapi.RQ_SUSPRUN
RQ_RESUME = _idaapi.RQ_RESUME
RQ_RESMOD = _idaapi.RQ_RESMOD
RQ_RESMOD_SHIFT = _idaapi.RQ_RESMOD_SHIFT
#<pycode(py_idd_2)>
NO_PROCESS = 0xFFFFFFFF
NO_THREAD  = 0
#</pycode(py_idd_2)>


def dbg_get_registers(*args):
  """
  dbg_get_registers() -> PyObject *


  This function returns the register definition from the currently loaded debugger.
  Basically, it returns an array of structure similar to to idd.hpp / register_info_t
  @return:
      None if no debugger is loaded
      tuple(name, flags, class, dtyp, bit_strings, default_bit_strings_mask)
      The bit_strings can be a tuple of strings or None (if the register does not have bit_strings)
  """
  return _idaapi.dbg_get_registers(*args)

def dbg_get_thread_sreg_base(*args):
  """
  dbg_get_thread_sreg_base(py_tid, py_sreg_value) -> PyObject *


  Returns the segment register base value
  @param tid: thread id
  @param sreg_value: segment register (selector) value
  @return:
      - The base as an 'ea'
      - Or None on failure
  """
  return _idaapi.dbg_get_thread_sreg_base(*args)

def dbg_read_memory(*args):
  """
  dbg_read_memory(py_ea, py_sz) -> PyObject *


  Reads from the debugee's memory at the specified ea
  @return:
      - The read buffer (as a string)
      - Or None on failure
  """
  return _idaapi.dbg_read_memory(*args)

def dbg_write_memory(*args):
  """
  dbg_write_memory(py_ea, py_buf) -> PyObject *


  Writes a buffer to the debugee's memory
  @return: Boolean
  """
  return _idaapi.dbg_write_memory(*args)

def dbg_get_name(*args):
  """
  dbg_get_name() -> PyObject *


  This function returns the current debugger's name.
  @return: Debugger name or None if no debugger is active
  """
  return _idaapi.dbg_get_name(*args)

def dbg_get_memory_info(*args):
  """
  dbg_get_memory_info() -> PyObject *


  This function returns the memory configuration of a debugged process.
  @return:
      None if no debugger is active
      tuple(startEA, endEA, name, sclass, sbase, bitness, perm)
  """
  return _idaapi.dbg_get_memory_info(*args)

def dbg_can_query(*args):
  """
  dbg_can_query() -> bool


  This function can be used to check if the debugger can be queried:
    - debugger is loaded
    - process is suspended
    - process is not suspended but can take requests. In this case some requests like
      memory read/write, bpt management succeed and register querying will fail.
      Check if idaapi.get_process_state() < 0 to tell if the process is suspended
  @return: Boolean
  """
  return _idaapi.dbg_can_query(*args)

def appcall(*args):
  """
  appcall(func_ea, tid, py_type, py_fields, arg_list) -> PyObject *
  """
  return _idaapi.appcall(*args)

def get_event_module_name(*args):
  """
  get_event_module_name(ev) -> char
  """
  return _idaapi.get_event_module_name(*args)

def get_event_module_base(*args):
  """
  get_event_module_base(ev) -> ea_t
  """
  return _idaapi.get_event_module_base(*args)

def get_event_module_size(*args):
  """
  get_event_module_size(ev) -> asize_t
  """
  return _idaapi.get_event_module_size(*args)

def get_event_exc_info(*args):
  """
  get_event_exc_info(ev) -> char
  """
  return _idaapi.get_event_exc_info(*args)

def get_event_info(*args):
  """
  get_event_info(ev) -> char
  """
  return _idaapi.get_event_info(*args)

def get_event_bpt_hea(*args):
  """
  get_event_bpt_hea(ev) -> ea_t
  """
  return _idaapi.get_event_bpt_hea(*args)

def get_event_exc_code(*args):
  """
  get_event_exc_code(ev) -> uint
  """
  return _idaapi.get_event_exc_code(*args)

def get_event_exc_ea(*args):
  """
  get_event_exc_ea(ev) -> ea_t
  """
  return _idaapi.get_event_exc_ea(*args)

def can_exc_continue(*args):
  """
  can_exc_continue(ev) -> bool
  """
  return _idaapi.can_exc_continue(*args)
#<pycode(py_idd)>
import types

# -----------------------------------------------------------------------
class Appcall_array__(object):
    """
    This class is used with Appcall.array() method
    """
    def __init__(self, tp):
        self.__type = tp

    def pack(self, L):
        """
        Packs a list or tuple into a byref buffer
        """
        t = type(L)
        if not (t == types.ListType or t == types.TupleType):
            raise ValueError, "Either a list or a tuple must be passed"
        self.__size = len(L)
        if self.__size == 1:
            self.__typedobj = Appcall__.typedobj(self.__type + ";")
        else:
            self.__typedobj = Appcall__.typedobj("%s x[%d];" % (self.__type, self.__size))
        # Now store the object in a string buffer
        ok, buf = self.__typedobj.store(L)
        if ok:
            return Appcall__.byref(buf)
        else:
            return None

    def try_to_convert_to_list(self, obj):
        """
        Is this object a list? We check for the existance of attribute zero and attribute self.size-1
        """
        if not (hasattr(obj, "0") and hasattr(obj, str(self.__size-1))):
            return obj
        # at this point, we are sure we have an "idc list"
        # let us convert to a Python list
        return [getattr(obj, str(x)) for x in xrange(0, self.__size)]

    def unpack(self, buf, as_list=True):
        """
        Unpacks an array back into a list or an object
        """
        # take the value from the special ref object
        if isinstance(buf, PyIdc_cvt_refclass__):
            buf = buf.value

        # we can only unpack from strings
        if type(buf) != types.StringType:
            raise ValueError, "Cannot unpack this type!"
        # now unpack
        ok, obj = self.__typedobj.retrieve(buf)
        if not ok:
            raise ValueError, "Failed while unpacking!"
        if not as_list:
            return obj
        return self.try_to_convert_to_list(obj)


# -----------------------------------------------------------------------
# Wrapper class for the appcall()
class Appcall_callable__(object):
    """
    Helper class to issue appcalls using a natural syntax:
      appcall.FunctionNameInTheDatabase(arguments, ....)
    or
      appcall["Function@8"](arguments, ...)
    or
      f8 = appcall["Function@8"]
      f8(arg1, arg2, ...)
    or
      o = appcall.obj()
      i = byref(5)
      appcall.funcname(arg1, i, "hello", o)
    """
    def __init__(self, ea, tp = None, fld = None):
        """
        Initializes an appcall with a given function ea
        """
        self.__ea     = ea
        self.__type   = tp
        self.__fields = fld
        self.__options = None # Appcall options
        self.__timeout = None # Appcall timeout

    def __get_timeout(self):
        return self.__timeout

    def __set_timeout(self, v):
        self.__timeout = v

    timeout = property(__get_timeout, __set_timeout)
    """
    An Appcall instance can change its timeout value with this attribute
    """

    def __get_options(self):
        return self.__options if self.__options != None else Appcall__.get_appcall_options()

    def __set_options(self, v):
        if self.timeout:
            # If timeout value is set, then put the timeout flag and encode the timeout value
            v |= Appcall__.APPCALL_TIMEOUT | (self.timeout << 16)
        else:
            # Timeout is not set, then clear the timeout flag
            v &= ~Appcall__.APPCALL_TIMEOUT

        self.__options = v

    options = property(__get_options, __set_options)
    """
    Sets the Appcall options locally to this Appcall instance
    """

    def __call__(self, *args):
        """
        Make object callable. We redirect execution to idaapi.appcall()
        """
        if self.ea is None:
            raise ValueError, "Object not callable!"

        # convert arguments to a list
        arg_list = list(args)

        # Save appcall options and set new global options
        old_opt = Appcall__.get_appcall_options()
        Appcall__.set_appcall_options(self.options)

        # Do the Appcall (use the wrapped version)
        e_obj = None
        try:
            r = _idaapi.appcall(
               self.ea,
               _idaapi.get_current_thread(),
               self.type,
               self.fields,
               arg_list)
        except Exception as e:
            e_obj = e

        # Restore appcall options
        Appcall__.set_appcall_options(old_opt)

        # Return or re-raise exception
        if e_obj:
            raise Exception, e_obj

        return r

    def __get_ea(self):
        return self.__ea

    def __set_ea(self, val):
        self.__ea = val

    ea = property(__get_ea, __set_ea)
    """
    Returns or sets the EA associated with this object
    """

    def __get_size(self):
        if self.__type == None:
            return -1
        r = _idaapi.calc_type_size(_idaapi.cvar.idati, self.__type)
        if not r:
            return -1
        return r

    size = property(__get_size)
    """
    Returns the size of the type
    """

    def __get_type(self):
        return self.__type

    type = property(__get_type)
    """
    Returns the typestring
    """

    def __get_fields(self):
        return self.__fields

    fields = property(__get_fields)
    """
    Returns the field names
    """


    def retrieve(self, src=None, flags=0):
        """
        Unpacks a typed object from the database if an ea is given or from a string if a string was passed
        @param src: the address of the object or a string
        @return: Returns a tuple of boolean and object or error number (Bool, Error | Object).
        """

        # Nothing passed? Take the address and unpack from the database
        if src is None:
            src = self.ea

        if type(src) == types.StringType:
            return _idaapi.unpack_object_from_bv(_idaapi.cvar.idati, self.type, self.fields, src, flags)
        else:
            return _idaapi.unpack_object_from_idb(_idaapi.cvar.idati, self.type, self.fields, src, flags)

    def store(self, obj, dest_ea=None, base_ea=0, flags=0):
        """
        Packs an object into a given ea if provided or into a string if no address was passed.
        @param obj: The object to pack
        @param dest_ea: If packing to idb this will be the store location
        @param base_ea: If packing to a buffer, this will be the base that will be used to relocate the pointers

        @return:
            - If packing to a string then a Tuple(Boolean, packed_string or error code)
            - If packing to the database then a return code is returned (0 is success)
        """

        # no ea passed? thus pack to a string
        if dest_ea is None:
            return _idaapi.pack_object_to_bv(obj,
                                             _idaapi.cvar.idati,
                                             self.type,
                                             self.fields,
                                             base_ea,
                                             flags)
        else:
            return _idaapi.pack_object_to_idb(obj,
                                              _idaapi.cvar.idati,
                                              self.type,
                                              self.fields,
                                              dest_ea,
                                              flags)

# -----------------------------------------------------------------------
class Appcall_consts__(object):
    """
    Helper class used by Appcall.Consts attribute
    It is used to retrieve constants via attribute access
"""
    def __init__(self, default=0):
        self.__default = default

    def __getattr__(self, attr):
        return Appcall__.valueof(attr, self.__default)

# -----------------------------------------------------------------------
class Appcall__(object):
    APPCALL_MANUAL = 0x1
    """
    Only set up the appcall, do not run it.
    you should call CleanupAppcall() when finished
    """

    APPCALL_DEBEV  = 0x2
    """
    Return debug event information
    If this bit is set, exceptions during appcall
    will generate idc exceptions with full
    information about the exception
    """

    APPCALL_TIMEOUT = 0x4
    """
    Appcall with timeout
    The timeout value in milliseconds is specified
    in the high 2 bytes of the 'options' argument:
    If timed out, errbuf will contain "timeout".
    """

    def __init__(self):
        self.__consts = Appcall_consts__()
    def __get_consts(self):
        return self.__consts
    Consts = property(__get_consts)
    """
    Use Appcall.Consts.CONST_NAME to access constants
    """

    @staticmethod
    def __name_or_ea(name_or_ea):
        """
        Function that accepts a name or an ea and checks if the address is enabled.
        If a name is passed then idaapi.get_name_ea() is applied to retrieve the name
        @return:
            - Returns the resolved EA or
            - Raises an exception if the address is not enabled
        """

        # a string? try to resolve it
        if type(name_or_ea) == types.StringType:
            ea = _idaapi.get_name_ea(_idaapi.BADADDR, name_or_ea)
        else:
            ea = name_or_ea
        # could not resolve name or invalid address?
        if ea == _idaapi.BADADDR or not _idaapi.isEnabled(ea):
            raise ValueError, "Undefined function " + name_or_ea
        return ea

    @staticmethod
    def proto(name_or_ea, prototype, flags = None):
        """
        Allows you to instantiate an appcall (callable object) with the desired prototype
        @param name_or_ea: The name of the function (will be resolved with LocByName())
        @param prototype:
        @return:
            - On failure it raises an exception if the prototype could not be parsed
              or the address is not resolvable
            - Returns a callbable Appcall instance with the given prototypes and flags
        """

        # resolve and raise exception on error
        ea = Appcall__.__name_or_ea(name_or_ea)
        # parse the type
        if flags is None:
            flags = 1 | 2 | 4 # PT_SIL | PT_NDC | PT_TYP

        result = _idaapi.idc_parse_decl(_idaapi.cvar.idati, prototype, flags)
        if result is None:
            raise ValueError, "Could not parse type: " + prototype

        # Return the callable method with type info
        return Appcall_callable__(ea, result[1], result[2])

    def __getattr__(self, name_or_ea):
        """
        Allows you to call functions as if they were member functions (by returning a callable object)
        """
        # resolve and raise exception on error
        ea = self.__name_or_ea(name_or_ea)
        if ea == _idaapi.BADADDR:
            raise ValueError, "Undefined function " + name
        # Return the callable method
        return Appcall_callable__(ea)

    def __getitem__(self, idx):
        """
        Use self[func_name] syntax if the function name contains invalid characters for an attribute name
        See __getattr___
        """
        return self.__getattr__(idx)

    @staticmethod
    def valueof(name, default=0):
        """
        Returns the numeric value of a given name string.
        If the name could not be resolved then the default value will be returned
        """
        t, v = _idaapi.get_name_value(_idaapi.BADADDR, name)
        if t == 0: # NT_NONE
          v = default
        return v

    @staticmethod
    def int64(v):
        """
        Whenever a 64bit number is needed use this method to construct an object
        """
        return PyIdc_cvt_int64__(v)

    @staticmethod
    def byref(val):
        """
        Method to create references to immutable objects
        Currently we support references to int/strings
        Objects need not be passed by reference (this will be done automatically)
        """
        return PyIdc_cvt_refclass__(val)

    @staticmethod
    def buffer(str = None, size = 0, fill="\x00"):
        """
        Creates a string buffer. The returned value (r) will be a byref object.
        Use r.value to get the contents and r.size to get the buffer's size
        """
        if str is None:
            str = ""
        left = size - len(str)
        if left > 0:
            str = str + (fill * left)
        r = Appcall__.byref(str)
        r.size = size
        return r

    @staticmethod
    def obj(**kwds):
        """
        Returns an empty object or objects with attributes as passed via its keywords arguments
        """
        return object_t(**kwds)

    @staticmethod
    def cstr(val):
        return as_cstr(val)

    @staticmethod
    def unicode(s):
        return as_unicode(s)

    @staticmethod
    def array(type_name):
        """
        Defines an array type. Later you need to pack() / unpack()
        """
        return Appcall_array__(type_name)

    @staticmethod
    def typedobj(typestr, ea=None):
        """
        Parses a type string and returns an appcall object.
        One can then use retrieve() member method
        @param ea: Optional parameter that later can be used to retrieve the type
        @return: Appcall object or raises ValueError exception
        """
        # parse the type
        result = _idaapi.idc_parse_decl(_idaapi.cvar.idati, typestr, 1 | 2 | 4) # PT_SIL | PT_NDC | PT_TYP
        if result is None:
            raise ValueError, "Could not parse type: " + typestr
        # Return the callable method with type info
        return Appcall_callable__(ea, result[1], result[2])

    @staticmethod
    def set_appcall_options(opt):
        """
        Method to change the Appcall options globally (not per Appcall)
        """
        old_opt = Appcall__.get_appcall_options()
        _idaapi.cvar.inf.appcall_options = opt
        return old_opt

    @staticmethod
    def get_appcall_options():
        """
        Return the global Appcall options
        """
        return _idaapi.cvar.inf.appcall_options

    @staticmethod
    def cleanup_appcall(tid = 0):
        """
        Equivalent to IDC's CleanupAppcall()
        """
        return _idaapi.cleanup_appcall(tid)

Appcall = Appcall__()
#</pycode(py_idd)>

IDP_INTERFACE_VERSION = _idaapi.IDP_INTERFACE_VERSION
NEXTEAS_ANSWER_SIZE = _idaapi.NEXTEAS_ANSWER_SIZE
IDPOPT_CST = _idaapi.IDPOPT_CST
IDPOPT_PRI_DEFAULT = _idaapi.IDPOPT_PRI_DEFAULT
IDPOPT_PRI_HIGH = _idaapi.IDPOPT_PRI_HIGH

def cfg_get_cc_parm(*args):
  """
  cfg_get_cc_parm(compid, name) -> char const *
  """
  return _idaapi.cfg_get_cc_parm(*args)

def cfg_get_cc_header_path(*args):
  """
  cfg_get_cc_header_path(compid) -> char const *
  """
  return _idaapi.cfg_get_cc_header_path(*args)

def cfg_get_cc_predefined_macros(*args):
  """
  cfg_get_cc_predefined_macros(compid) -> char const *
  """
  return _idaapi.cfg_get_cc_predefined_macros(*args)

def InstrIsSet(*args):
  """
  InstrIsSet(icode, bit) -> bool
  """
  return _idaapi.InstrIsSet(*args)

def is_call_insn(*args):
  """
  is_call_insn(ea) -> bool
  """
  return _idaapi.is_call_insn(*args)

def is_ret_insn(*args):
  """
  is_ret_insn(ea, strict=True) -> bool
  """
  return _idaapi.is_ret_insn(*args)

def is_indirect_jump_insn(*args):
  """
  is_indirect_jump_insn(ea) -> bool
  """
  return _idaapi.is_indirect_jump_insn(*args)

def is_basic_block_end(*args):
  """
  is_basic_block_end(call_insn_stops_block) -> bool
  """
  return _idaapi.is_basic_block_end(*args)
class asm_t(object):
    """
    Proxy of C++ asm_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flag = _swig_property(_idaapi.asm_t_flag_get, _idaapi.asm_t_flag_set)
    uflag = _swig_property(_idaapi.asm_t_uflag_get, _idaapi.asm_t_uflag_set)
    name = _swig_property(_idaapi.asm_t_name_get, _idaapi.asm_t_name_set)
    help = _swig_property(_idaapi.asm_t_help_get, _idaapi.asm_t_help_set)
    header = _swig_property(_idaapi.asm_t_header_get, _idaapi.asm_t_header_set)
    badworks = _swig_property(_idaapi.asm_t_badworks_get, _idaapi.asm_t_badworks_set)
    origin = _swig_property(_idaapi.asm_t_origin_get, _idaapi.asm_t_origin_set)
    end = _swig_property(_idaapi.asm_t_end_get, _idaapi.asm_t_end_set)
    cmnt = _swig_property(_idaapi.asm_t_cmnt_get, _idaapi.asm_t_cmnt_set)
    ascsep = _swig_property(_idaapi.asm_t_ascsep_get, _idaapi.asm_t_ascsep_set)
    accsep = _swig_property(_idaapi.asm_t_accsep_get, _idaapi.asm_t_accsep_set)
    esccodes = _swig_property(_idaapi.asm_t_esccodes_get, _idaapi.asm_t_esccodes_set)
    a_ascii = _swig_property(_idaapi.asm_t_a_ascii_get, _idaapi.asm_t_a_ascii_set)
    a_byte = _swig_property(_idaapi.asm_t_a_byte_get, _idaapi.asm_t_a_byte_set)
    a_word = _swig_property(_idaapi.asm_t_a_word_get, _idaapi.asm_t_a_word_set)
    a_dword = _swig_property(_idaapi.asm_t_a_dword_get, _idaapi.asm_t_a_dword_set)
    a_qword = _swig_property(_idaapi.asm_t_a_qword_get, _idaapi.asm_t_a_qword_set)
    a_oword = _swig_property(_idaapi.asm_t_a_oword_get, _idaapi.asm_t_a_oword_set)
    a_float = _swig_property(_idaapi.asm_t_a_float_get, _idaapi.asm_t_a_float_set)
    a_double = _swig_property(_idaapi.asm_t_a_double_get, _idaapi.asm_t_a_double_set)
    a_tbyte = _swig_property(_idaapi.asm_t_a_tbyte_get, _idaapi.asm_t_a_tbyte_set)
    a_packreal = _swig_property(_idaapi.asm_t_a_packreal_get, _idaapi.asm_t_a_packreal_set)
    a_dups = _swig_property(_idaapi.asm_t_a_dups_get, _idaapi.asm_t_a_dups_set)
    a_bss = _swig_property(_idaapi.asm_t_a_bss_get, _idaapi.asm_t_a_bss_set)
    a_equ = _swig_property(_idaapi.asm_t_a_equ_get, _idaapi.asm_t_a_equ_set)
    a_seg = _swig_property(_idaapi.asm_t_a_seg_get, _idaapi.asm_t_a_seg_set)
    _UNUSED1_was_atomprefix = _swig_property(_idaapi.asm_t__UNUSED1_was_atomprefix_get, _idaapi.asm_t__UNUSED1_was_atomprefix_set)
    _UNUSED2_was_checkarg_operations = _swig_property(_idaapi.asm_t__UNUSED2_was_checkarg_operations_get, _idaapi.asm_t__UNUSED2_was_checkarg_operations_set)
    XlatAsciiOutput = _swig_property(_idaapi.asm_t_XlatAsciiOutput_get, _idaapi.asm_t_XlatAsciiOutput_set)
    a_curip = _swig_property(_idaapi.asm_t_a_curip_get, _idaapi.asm_t_a_curip_set)
    a_public = _swig_property(_idaapi.asm_t_a_public_get, _idaapi.asm_t_a_public_set)
    a_weak = _swig_property(_idaapi.asm_t_a_weak_get, _idaapi.asm_t_a_weak_set)
    a_extrn = _swig_property(_idaapi.asm_t_a_extrn_get, _idaapi.asm_t_a_extrn_set)
    a_comdef = _swig_property(_idaapi.asm_t_a_comdef_get, _idaapi.asm_t_a_comdef_set)
    a_align = _swig_property(_idaapi.asm_t_a_align_get, _idaapi.asm_t_a_align_set)
    lbrace = _swig_property(_idaapi.asm_t_lbrace_get, _idaapi.asm_t_lbrace_set)
    rbrace = _swig_property(_idaapi.asm_t_rbrace_get, _idaapi.asm_t_rbrace_set)
    a_mod = _swig_property(_idaapi.asm_t_a_mod_get, _idaapi.asm_t_a_mod_set)
    a_band = _swig_property(_idaapi.asm_t_a_band_get, _idaapi.asm_t_a_band_set)
    a_bor = _swig_property(_idaapi.asm_t_a_bor_get, _idaapi.asm_t_a_bor_set)
    a_xor = _swig_property(_idaapi.asm_t_a_xor_get, _idaapi.asm_t_a_xor_set)
    a_bnot = _swig_property(_idaapi.asm_t_a_bnot_get, _idaapi.asm_t_a_bnot_set)
    a_shl = _swig_property(_idaapi.asm_t_a_shl_get, _idaapi.asm_t_a_shl_set)
    a_shr = _swig_property(_idaapi.asm_t_a_shr_get, _idaapi.asm_t_a_shr_set)
    a_sizeof_fmt = _swig_property(_idaapi.asm_t_a_sizeof_fmt_get, _idaapi.asm_t_a_sizeof_fmt_set)
    flag2 = _swig_property(_idaapi.asm_t_flag2_get, _idaapi.asm_t_flag2_set)
    cmnt2 = _swig_property(_idaapi.asm_t_cmnt2_get, _idaapi.asm_t_cmnt2_set)
    low8 = _swig_property(_idaapi.asm_t_low8_get, _idaapi.asm_t_low8_set)
    high8 = _swig_property(_idaapi.asm_t_high8_get, _idaapi.asm_t_high8_set)
    low16 = _swig_property(_idaapi.asm_t_low16_get, _idaapi.asm_t_low16_set)
    high16 = _swig_property(_idaapi.asm_t_high16_get, _idaapi.asm_t_high16_set)
    a_include_fmt = _swig_property(_idaapi.asm_t_a_include_fmt_get, _idaapi.asm_t_a_include_fmt_set)
    a_vstruc_fmt = _swig_property(_idaapi.asm_t_a_vstruc_fmt_get, _idaapi.asm_t_a_vstruc_fmt_set)
    a_3byte = _swig_property(_idaapi.asm_t_a_3byte_get, _idaapi.asm_t_a_3byte_set)
    a_rva = _swig_property(_idaapi.asm_t_a_rva_get, _idaapi.asm_t_a_rva_set)
    a_yword = _swig_property(_idaapi.asm_t_a_yword_get, _idaapi.asm_t_a_yword_set)
    def __init__(self, *args):
        """
        __init__(self) -> asm_t
        """
        this = _idaapi.new_asm_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_asm_t
    __del__ = lambda self : None;
asm_t_swigregister = _idaapi.asm_t_swigregister
asm_t_swigregister(asm_t)
AS_OFFST = _idaapi.AS_OFFST
AS_COLON = _idaapi.AS_COLON
AS_UDATA = _idaapi.AS_UDATA
AS_2CHRE = _idaapi.AS_2CHRE
AS_NCHRE = _idaapi.AS_NCHRE
AS_N2CHR = _idaapi.AS_N2CHR
AS_1TEXT = _idaapi.AS_1TEXT
AS_NHIAS = _idaapi.AS_NHIAS
AS_NCMAS = _idaapi.AS_NCMAS
AS_HEXFM = _idaapi.AS_HEXFM
ASH_HEXF0 = _idaapi.ASH_HEXF0
ASH_HEXF1 = _idaapi.ASH_HEXF1
ASH_HEXF2 = _idaapi.ASH_HEXF2
ASH_HEXF3 = _idaapi.ASH_HEXF3
ASH_HEXF4 = _idaapi.ASH_HEXF4
ASH_HEXF5 = _idaapi.ASH_HEXF5
AS_DECFM = _idaapi.AS_DECFM
ASD_DECF0 = _idaapi.ASD_DECF0
ASD_DECF1 = _idaapi.ASD_DECF1
ASD_DECF2 = _idaapi.ASD_DECF2
ASD_DECF3 = _idaapi.ASD_DECF3
AS_OCTFM = _idaapi.AS_OCTFM
ASO_OCTF0 = _idaapi.ASO_OCTF0
ASO_OCTF1 = _idaapi.ASO_OCTF1
ASO_OCTF2 = _idaapi.ASO_OCTF2
ASO_OCTF3 = _idaapi.ASO_OCTF3
ASO_OCTF4 = _idaapi.ASO_OCTF4
ASO_OCTF5 = _idaapi.ASO_OCTF5
ASO_OCTF6 = _idaapi.ASO_OCTF6
ASO_OCTF7 = _idaapi.ASO_OCTF7
AS_BINFM = _idaapi.AS_BINFM
ASB_BINF0 = _idaapi.ASB_BINF0
ASB_BINF1 = _idaapi.ASB_BINF1
ASB_BINF2 = _idaapi.ASB_BINF2
ASB_BINF3 = _idaapi.ASB_BINF3
ASB_BINF4 = _idaapi.ASB_BINF4
ASB_BINF5 = _idaapi.ASB_BINF5
AS_UNEQU = _idaapi.AS_UNEQU
AS_ONEDUP = _idaapi.AS_ONEDUP
AS_NOXRF = _idaapi.AS_NOXRF
AS_XTRNTYPE = _idaapi.AS_XTRNTYPE
AS_RELSUP = _idaapi.AS_RELSUP
AS_LALIGN = _idaapi.AS_LALIGN
AS_NOCODECLN = _idaapi.AS_NOCODECLN
AS_NOTAB = _idaapi.AS_NOTAB
AS_NOSPACE = _idaapi.AS_NOSPACE
AS_ALIGN2 = _idaapi.AS_ALIGN2
AS_ASCIIC = _idaapi.AS_ASCIIC
AS_ASCIIZ = _idaapi.AS_ASCIIZ
AS2_BRACE = _idaapi.AS2_BRACE
AS2_STRINV = _idaapi.AS2_STRINV
AS2_BYTE1CHAR = _idaapi.AS2_BYTE1CHAR
AS2_IDEALDSCR = _idaapi.AS2_IDEALDSCR
AS2_TERSESTR = _idaapi.AS2_TERSESTR
AS2_COLONSUF = _idaapi.AS2_COLONSUF
AS2_YWORD = _idaapi.AS2_YWORD


def str2regf(*args):
  """
  str2regf(p) -> int
  """
  return _idaapi.str2regf(*args)

def str2reg(*args):
  """
  str2reg(p) -> int
  """
  return _idaapi.str2reg(*args)

def is_align_insn(*args):
  """
  is_align_insn(ea) -> int
  """
  return _idaapi.is_align_insn(*args)

def get_reg_name(*args):
  """
  get_reg_name(reg, width, reghi=-1) -> ssize_t
  """
  return _idaapi.get_reg_name(*args)

def get_reg_info2(*args):
  """
  get_reg_info2(regname, bitrange) -> char const *
  """
  return _idaapi.get_reg_info2(*args)
class reg_info_t(object):
    """
    Proxy of C++ reg_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    reg = _swig_property(_idaapi.reg_info_t_reg_get, _idaapi.reg_info_t_reg_set)
    size = _swig_property(_idaapi.reg_info_t_size_get, _idaapi.reg_info_t_size_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.reg_info_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.reg_info_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.reg_info_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.reg_info_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.reg_info_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.reg_info_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.reg_info_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> reg_info_t
        """
        this = _idaapi.new_reg_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_reg_info_t
    __del__ = lambda self : None;
reg_info_t_swigregister = _idaapi.reg_info_t_swigregister
reg_info_t_swigregister(reg_info_t)


def parse_reg_name(*args):
  """
  parse_reg_name(regname, ri) -> bool
  """
  return _idaapi.parse_reg_name(*args)

def sizeof_ldbl(*args):
  """
  sizeof_ldbl() -> size_t
  """
  return _idaapi.sizeof_ldbl(*args)

def intel_data(*args):
  """
  intel_data(ea)
  """
  return _idaapi.intel_data(*args)

def gen_spcdef(*args):
  """
  gen_spcdef(ea, segtype) -> bool
  """
  return _idaapi.gen_spcdef(*args)

def gen_extern(*args):
  """
  gen_extern(ea, name) -> bool
  """
  return _idaapi.gen_extern(*args)

def gen_abssym(*args):
  """
  gen_abssym(ea, name) -> bool
  """
  return _idaapi.gen_abssym(*args)

def gen_comvar(*args):
  """
  gen_comvar(ea, name) -> bool
  """
  return _idaapi.gen_comvar(*args)
SETPROC_COMPAT = _idaapi.SETPROC_COMPAT
SETPROC_ALL = _idaapi.SETPROC_ALL
SETPROC_USER = _idaapi.SETPROC_USER
SETPROC_FATAL = _idaapi.SETPROC_FATAL

def set_processor_type(*args):
  """
  set_processor_type(procname, level) -> char *
  """
  return _idaapi.set_processor_type(*args)

def get_idp_name(*args):
  """
  get_idp_name() -> char *
  """
  return _idaapi.get_idp_name(*args)

def set_target_assembler(*args):
  """
  set_target_assembler(asmnum) -> bool
  """
  return _idaapi.set_target_assembler(*args)

def create_custom_fixup(*args):
  """
  create_custom_fixup(name) -> int
  """
  return _idaapi.create_custom_fixup(*args)
byte_patched = _idaapi.byte_patched
cmt_changed = _idaapi.cmt_changed
ti_changed = _idaapi.ti_changed
op_ti_changed = _idaapi.op_ti_changed
op_type_changed = _idaapi.op_type_changed
enum_created = _idaapi.enum_created
enum_deleted = _idaapi.enum_deleted
enum_bf_changed = _idaapi.enum_bf_changed
enum_renamed = _idaapi.enum_renamed
enum_cmt_changed = _idaapi.enum_cmt_changed
enum_const_created = _idaapi.enum_const_created
enum_const_deleted = _idaapi.enum_const_deleted
struc_created = _idaapi.struc_created
struc_deleted = _idaapi.struc_deleted
struc_renamed = _idaapi.struc_renamed
struc_expanded = _idaapi.struc_expanded
struc_cmt_changed = _idaapi.struc_cmt_changed
struc_member_created = _idaapi.struc_member_created
struc_member_deleted = _idaapi.struc_member_deleted
struc_member_renamed = _idaapi.struc_member_renamed
struc_member_changed = _idaapi.struc_member_changed
thunk_func_created = _idaapi.thunk_func_created
func_tail_appended = _idaapi.func_tail_appended
func_tail_removed = _idaapi.func_tail_removed
tail_owner_changed = _idaapi.tail_owner_changed
func_noret_changed = _idaapi.func_noret_changed
segm_added = _idaapi.segm_added
segm_deleted = _idaapi.segm_deleted
segm_start_changed = _idaapi.segm_start_changed
segm_end_changed = _idaapi.segm_end_changed
segm_moved = _idaapi.segm_moved
area_cmt_changed = _idaapi.area_cmt_changed
changing_cmt = _idaapi.changing_cmt
changing_ti = _idaapi.changing_ti
changing_op_ti = _idaapi.changing_op_ti
changing_op_type = _idaapi.changing_op_type
deleting_enum = _idaapi.deleting_enum
changing_enum_bf = _idaapi.changing_enum_bf
renaming_enum = _idaapi.renaming_enum
changing_enum_cmt = _idaapi.changing_enum_cmt
deleting_enum_const = _idaapi.deleting_enum_const
deleting_struc = _idaapi.deleting_struc
renaming_struc = _idaapi.renaming_struc
expanding_struc = _idaapi.expanding_struc
changing_struc_cmt = _idaapi.changing_struc_cmt
deleting_struc_member = _idaapi.deleting_struc_member
renaming_struc_member = _idaapi.renaming_struc_member
changing_struc_member = _idaapi.changing_struc_member
removing_func_tail = _idaapi.removing_func_tail
deleting_segm = _idaapi.deleting_segm
changing_segm_start = _idaapi.changing_segm_start
changing_segm_end = _idaapi.changing_segm_end
changing_area_cmt = _idaapi.changing_area_cmt
changing_segm_name = _idaapi.changing_segm_name
changing_segm_class = _idaapi.changing_segm_class
segm_name_changed = _idaapi.segm_name_changed
segm_class_changed = _idaapi.segm_class_changed
destroyed_items = _idaapi.destroyed_items
changed_stkpnts = _idaapi.changed_stkpnts
extra_cmt_changed = _idaapi.extra_cmt_changed
changing_struc = _idaapi.changing_struc
changed_struc = _idaapi.changed_struc
local_types_changed = _idaapi.local_types_changed
segm_attrs_changed = _idaapi.segm_attrs_changed

def AssembleLine(*args):
  """
  AssembleLine(ea, cs, ip, use32, line) -> PyObject *


  Assemble an instruction to a string (display a warning if an error is found)
  
  @param ea: linear address of instruction
  @param cs:  cs of instruction
  @param ip:  ip of instruction
  @param use32: is 32bit segment
  @param line: line to assemble
  @return:
      - None on failure
      - or a string containing the assembled instruction
  """
  return _idaapi.AssembleLine(*args)

def assemble(*args):
  """
  assemble(ea, cs, ip, use32, line) -> bool


  Assemble an instruction into the database (display a warning if an error is found)
  @param ea: linear address of instruction
  @param cs: cs of instruction
  @param ip: ip of instruction
  @param use32: is 32bit segment?
  @param line: line to assemble
  
  @return: Boolean. True on success.
  """
  return _idaapi.assemble(*args)

def ph_get_id(*args):
  """
  ph_get_id() -> size_t


  Returns the 'ph.id' field
  """
  return _idaapi.ph_get_id(*args)

def ph_get_version(*args):
  """
  ph_get_version() -> size_t


  Returns the 'ph.version'
  """
  return _idaapi.ph_get_version(*args)

def ph_get_flag(*args):
  """
  ph_get_flag() -> size_t


  Returns the 'ph.flag'
  """
  return _idaapi.ph_get_flag(*args)

def ph_get_cnbits(*args):
  """
  ph_get_cnbits() -> size_t


  Returns the 'ph.cnbits'
  """
  return _idaapi.ph_get_cnbits(*args)

def ph_get_dnbits(*args):
  """
  ph_get_dnbits() -> size_t


  Returns the 'ph.dnbits'
  """
  return _idaapi.ph_get_dnbits(*args)

def ph_get_regFirstSreg(*args):
  """
  ph_get_regFirstSreg() -> size_t


  Returns the 'ph.regFirstSreg'
  """
  return _idaapi.ph_get_regFirstSreg(*args)

def ph_get_regLastSreg(*args):
  """
  ph_get_regLastSreg() -> size_t


  Returns the 'ph.regLastSreg'
  """
  return _idaapi.ph_get_regLastSreg(*args)

def ph_get_segreg_size(*args):
  """
  ph_get_segreg_size() -> size_t


  Returns the 'ph.segreg_size'
  """
  return _idaapi.ph_get_segreg_size(*args)

def ph_get_regCodeSreg(*args):
  """
  ph_get_regCodeSreg() -> size_t


  Returns the 'ph.regCodeSreg'
  """
  return _idaapi.ph_get_regCodeSreg(*args)

def ph_get_regDataSreg(*args):
  """
  ph_get_regDataSreg() -> size_t


  Returns the 'ph.regDataSreg'
  """
  return _idaapi.ph_get_regDataSreg(*args)

def ph_get_high_fixup_bits(*args):
  """
  ph_get_high_fixup_bits() -> size_t


  Returns the 'ph.high_fixup_bits'
  """
  return _idaapi.ph_get_high_fixup_bits(*args)

def ph_get_icode_return(*args):
  """
  ph_get_icode_return() -> size_t


  Returns the 'ph.icode_return'
  """
  return _idaapi.ph_get_icode_return(*args)

def ph_get_instruc_start(*args):
  """
  ph_get_instruc_start() -> size_t


  Returns the 'ph.instruc_start'
  """
  return _idaapi.ph_get_instruc_start(*args)

def ph_get_instruc_end(*args):
  """
  ph_get_instruc_end() -> size_t


  Returns the 'ph.instruc_end'
  """
  return _idaapi.ph_get_instruc_end(*args)

def ph_get_tbyte_size(*args):
  """
  ph_get_tbyte_size() -> size_t


  Returns the 'ph.tbyte_size' field as defined in he processor module
  """
  return _idaapi.ph_get_tbyte_size(*args)

def ph_get_instruc(*args):
  """
  ph_get_instruc() -> PyObject *


  Returns a list of tuples (instruction_name, instruction_feature) containing the
  instructions list as defined in he processor module
  """
  return _idaapi.ph_get_instruc(*args)

def ph_get_regnames(*args):
  """
  ph_get_regnames() -> PyObject *


  Returns the list of register names as defined in the processor module
  """
  return _idaapi.ph_get_regnames(*args)

def ph_get_operand_info(*args):
  """
  ph_get_operand_info(ea, n) -> PyObject *


  Returns the operand information given an ea and operand number.
  
  @param ea: address
  @param n: operand number
  
  @return: Returns an idd_opinfo_t as a tuple: (modified, ea, reg_ival, regidx, value_size).
           Please refer to idd_opinfo_t structure in the SDK.
  """
  return _idaapi.ph_get_operand_info(*args)
class IDP_Hooks(object):
    """
    Proxy of C++ IDP_Hooks class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _idaapi.delete_IDP_Hooks
    __del__ = lambda self : None;
    def hook(self, *args):
        """
        hook(self) -> bool


        Creates an IDP hook
        
        @return: Boolean true on success
        """
        return _idaapi.IDP_Hooks_hook(self, *args)

    def unhook(self, *args):
        """
        unhook(self) -> bool


        Removes the IDP hook
        @return: Boolean true on success
        """
        return _idaapi.IDP_Hooks_unhook(self, *args)

    def custom_ana(self, *args):
        """
        custom_ana(self) -> bool


        Analyzes and decodes an instruction at idaapi.cmd.ea
           - cmd.itype must be set >= idaapi.CUSTOM_CMD_ITYPE
           - cmd.size must be set to the instruction length
        
        @return: Boolean
            - False if the instruction is not recognized
            - True if the instruction was decoded. idaapi.cmd should be filled in that case.
        """
        return _idaapi.IDP_Hooks_custom_ana(self, *args)

    def custom_out(self, *args):
        """
        custom_out(self) -> bool


        Outputs the instruction defined in idaapi.cmd
        
        @return: Boolean (whether this instruction can be outputted or not)
        """
        return _idaapi.IDP_Hooks_custom_out(self, *args)

    def custom_emu(self, *args):
        """
        custom_emu(self) -> bool


        Emulate instruction, create cross-references, plan to analyze
        subsequent instructions, modify flags etc. Upon entrance to this function
        all information about the instruction is in 'cmd' structure.
        
        @return: Boolean (whether this instruction has been emulated or not)
        """
        return _idaapi.IDP_Hooks_custom_emu(self, *args)

    def custom_outop(self, *args):
        """
        custom_outop(self, py_op) -> bool


        Notification to generate operand text.
        If False was returned, then the standard operand output function will be called.
        
        The output buffer is inited with init_output_buffer()
        and this notification may use out_...() functions to form the operand text
        
        @return: Boolean (whether the operand has been outputted or not)
        """
        return _idaapi.IDP_Hooks_custom_outop(self, *args)

    def custom_mnem(self, *args):
        """
        custom_mnem(self) -> PyObject *


        Prints the mnemonic of the instruction defined in idaapi.cmd
        
        @return:
            - None: No mnemonic. IDA will use the default mnemonic value if present
            - String: The desired mnemonic string
        """
        return _idaapi.IDP_Hooks_custom_mnem(self, *args)

    def is_sane_insn(self, *args):
        """
        is_sane_insn(self, no_crefs) -> int


        is the instruction sane for the current file type?
        @param no_crefs:
              - 1: the instruction has no code refs to it.
                   ida just tries to convert unexplored bytes
                   to an instruction (but there is no other
                   reason to convert them into an instruction)
              - 0: the instruction is created because
                   of some coderef, user request or another
                   weighty reason.
        @return: 1-ok, <=0-no, the instruction isn't likely to appear in the program
        """
        return _idaapi.IDP_Hooks_is_sane_insn(self, *args)

    def may_be_func(self, *args):
        """
        may_be_func(self, state) -> int


        Can a function start here?
        @param state: autoanalysis phase
              0: creating functions
              1: creating chunks
        
        @return: integer (probability 0..100)
        """
        return _idaapi.IDP_Hooks_may_be_func(self, *args)

    def closebase(self, *args):
        """
        closebase(self) -> int


        The database will be closed now
        """
        return _idaapi.IDP_Hooks_closebase(self, *args)

    def savebase(self, *args):
        """
        savebase(self)


        The database is being saved. Processor module should
        """
        return _idaapi.IDP_Hooks_savebase(self, *args)

    def auto_empty_finally(self, *args):
        """
        auto_empty_finally(self)
        """
        return _idaapi.IDP_Hooks_auto_empty_finally(self, *args)

    def rename(self, *args):
        """
        rename(self, ea, new_name) -> int


        The kernel is going to rename a byte.
        
        @param ea: Address
        @param new_name: The new name
        
        @return:
            - If returns value <=0, then the kernel should
              not rename it. See also the 'renamed' event
        """
        return _idaapi.IDP_Hooks_rename(self, *args)

    def renamed(self, *args):
        """
        renamed(self, ea, new_name, local_name)


        The kernel has renamed a byte
        
        @param ea: Address
        @param new_name: The new name
        @param local_name: Is local name
        
        @return: Ignored
        """
        return _idaapi.IDP_Hooks_renamed(self, *args)

    def undefine(self, *args):
        """
        undefine(self, ea) -> int


        An item in the database (insn or data) is being deleted
        @param ea: Address
        @return:
            - returns: >0-ok, <=0-the kernel should stop
            - if the return value is positive:
               bit0 - ignored
               bit1 - do not delete srareas at the item end
        """
        return _idaapi.IDP_Hooks_undefine(self, *args)

    def make_code(self, *args):
        """
        make_code(self, ea, size) -> int


        An instruction is being created
        @param ea: Address
        @param size: Instruction size
        @return: 1-ok, <=0-the kernel should stop
        """
        return _idaapi.IDP_Hooks_make_code(self, *args)

    def make_data(self, *args):
        """
        make_data(self, ea, flags, tid, len) -> int


        A data item is being created
        @param ea: Address
        @param tid: type id
        @param flags: item flags
        @param len: data item size
        @return: 1-ok, <=0-the kernel should stop
        """
        return _idaapi.IDP_Hooks_make_data(self, *args)

    def load_idasgn(self, *args):
        """
        load_idasgn(self, short_sig_name)


        FLIRT signature have been loaded for normal processing
        (not for recognition of startup sequences)
        @param short_sig_name: signature name
        @return: Ignored
        """
        return _idaapi.IDP_Hooks_load_idasgn(self, *args)

    def auto_empty(self, *args):
        """
        auto_empty(self)
        """
        return _idaapi.IDP_Hooks_auto_empty(self, *args)

    def auto_queue_empty(self, *args):
        """
        auto_queue_empty(self, type) -> int
        """
        return _idaapi.IDP_Hooks_auto_queue_empty(self, *args)

    def add_func(self, *args):
        """
        add_func(self, func)


        The kernel has added a function
        @param func: the func_t instance
        @return: Ignored
        """
        return _idaapi.IDP_Hooks_add_func(self, *args)

    def del_func(self, *args):
        """
        del_func(self, func) -> int


        The kernel is about to delete a function
        @param func: the func_t instance
        @return: 1-ok,<=0-do not delete
        """
        return _idaapi.IDP_Hooks_del_func(self, *args)

    def is_call_insn(self, *args):
        """
        is_call_insn(self, arg0) -> int


        Is the instruction a "call"?
        
        @param ea: instruction address
        @return: 1-unknown, 0-no, 2-yes
        """
        return _idaapi.IDP_Hooks_is_call_insn(self, *args)

    def is_ret_insn(self, *args):
        """
        is_ret_insn(self, arg0, arg1) -> int


        Is the instruction a "return"?
        
        @param ea: instruction address
        @param strict: - True: report only ret instructions
                         False: include instructions like "leave" which begins the function epilog
        @return: 1-unknown, 0-no, 2-yes
        """
        return _idaapi.IDP_Hooks_is_ret_insn(self, *args)

    def assemble(self, *args):
        """
        assemble(self, arg0, arg1, arg2, arg3, arg4) -> PyObject *


        Assembles an instruction
        
        @param ea: linear address of instruction
        @param cs: cs of instruction
        @param ip: ip of instruction
        @param use32: is 32bit segment?
        @param line: line to assemble
        
        @return: - None to let the underlying processor module assemble the line
                 - or a string containing the assembled buffer
        """
        return _idaapi.IDP_Hooks_assemble(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> IDP_Hooks
        """
        if self.__class__ == IDP_Hooks:
            _self = None
        else:
            _self = self
        this = _idaapi.new_IDP_Hooks(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_IDP_Hooks(self)
        return weakref_proxy(self)
IDP_Hooks_swigregister = _idaapi.IDP_Hooks_swigregister
IDP_Hooks_swigregister(IDP_Hooks)

AREACB_TYPE_UNKNOWN = _idaapi.AREACB_TYPE_UNKNOWN
AREACB_TYPE_FUNC = _idaapi.AREACB_TYPE_FUNC
AREACB_TYPE_SEGMENT = _idaapi.AREACB_TYPE_SEGMENT
AREACB_TYPE_HIDDEN_AREA = _idaapi.AREACB_TYPE_HIDDEN_AREA
AREACB_TYPE_SRAREA = _idaapi.AREACB_TYPE_SRAREA
class IDB_Hooks(object):
    """
    Proxy of C++ IDB_Hooks class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _idaapi.delete_IDB_Hooks
    __del__ = lambda self : None;
    def hook(self, *args):
        """
        hook(self) -> bool
        """
        return _idaapi.IDB_Hooks_hook(self, *args)

    def unhook(self, *args):
        """
        unhook(self) -> bool
        """
        return _idaapi.IDB_Hooks_unhook(self, *args)

    def byte_patched(self, *args):
        """
        byte_patched(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_byte_patched(self, *args)

    def cmt_changed(self, *args):
        """
        cmt_changed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_cmt_changed(self, *args)

    def area_cmt_changed(self, *args):
        """
        area_cmt_changed(self, arg0, arg1, arg2, arg3) -> int
        """
        return _idaapi.IDB_Hooks_area_cmt_changed(self, *args)

    def ti_changed(self, *args):
        """
        ti_changed(self, arg0, arg1, arg2) -> int
        """
        return _idaapi.IDB_Hooks_ti_changed(self, *args)

    def op_ti_changed(self, *args):
        """
        op_ti_changed(self, arg0, arg1, arg2, arg3) -> int
        """
        return _idaapi.IDB_Hooks_op_ti_changed(self, *args)

    def op_type_changed(self, *args):
        """
        op_type_changed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_op_type_changed(self, *args)

    def enum_created(self, *args):
        """
        enum_created(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_enum_created(self, *args)

    def enum_deleted(self, *args):
        """
        enum_deleted(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_enum_deleted(self, *args)

    def enum_bf_changed(self, *args):
        """
        enum_bf_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_enum_bf_changed(self, *args)

    def enum_renamed(self, *args):
        """
        enum_renamed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_enum_renamed(self, *args)

    def enum_cmt_changed(self, *args):
        """
        enum_cmt_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_enum_cmt_changed(self, *args)

    def enum_member_created(self, *args):
        """
        enum_member_created(self, arg0, cid) -> int
        """
        return _idaapi.IDB_Hooks_enum_member_created(self, *args)

    def enum_member_deleted(self, *args):
        """
        enum_member_deleted(self, arg0, cid) -> int
        """
        return _idaapi.IDB_Hooks_enum_member_deleted(self, *args)

    def struc_created(self, *args):
        """
        struc_created(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_struc_created(self, *args)

    def struc_deleted(self, *args):
        """
        struc_deleted(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_struc_deleted(self, *args)

    def struc_renamed(self, *args):
        """
        struc_renamed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_struc_renamed(self, *args)

    def struc_expanded(self, *args):
        """
        struc_expanded(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_struc_expanded(self, *args)

    def struc_cmt_changed(self, *args):
        """
        struc_cmt_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_struc_cmt_changed(self, *args)

    def struc_member_created(self, *args):
        """
        struc_member_created(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_struc_member_created(self, *args)

    def struc_member_deleted(self, *args):
        """
        struc_member_deleted(self, arg0, arg1, arg2) -> int
        """
        return _idaapi.IDB_Hooks_struc_member_deleted(self, *args)

    def struc_member_renamed(self, *args):
        """
        struc_member_renamed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_struc_member_renamed(self, *args)

    def struc_member_changed(self, *args):
        """
        struc_member_changed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_struc_member_changed(self, *args)

    def thunk_func_created(self, *args):
        """
        thunk_func_created(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_thunk_func_created(self, *args)

    def func_tail_appended(self, *args):
        """
        func_tail_appended(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_func_tail_appended(self, *args)

    def func_tail_removed(self, *args):
        """
        func_tail_removed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_func_tail_removed(self, *args)

    def tail_owner_changed(self, *args):
        """
        tail_owner_changed(self, arg0, arg1) -> int
        """
        return _idaapi.IDB_Hooks_tail_owner_changed(self, *args)

    def func_noret_changed(self, *args):
        """
        func_noret_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_func_noret_changed(self, *args)

    def segm_added(self, *args):
        """
        segm_added(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_segm_added(self, *args)

    def segm_deleted(self, *args):
        """
        segm_deleted(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_segm_deleted(self, *args)

    def segm_start_changed(self, *args):
        """
        segm_start_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_segm_start_changed(self, *args)

    def segm_end_changed(self, *args):
        """
        segm_end_changed(self, arg0) -> int
        """
        return _idaapi.IDB_Hooks_segm_end_changed(self, *args)

    def segm_moved(self, *args):
        """
        segm_moved(self, arg0, arg1, arg2) -> int
        """
        return _idaapi.IDB_Hooks_segm_moved(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> IDB_Hooks
        """
        if self.__class__ == IDB_Hooks:
            _self = None
        else:
            _self = self
        this = _idaapi.new_IDB_Hooks(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_IDB_Hooks(self)
        return weakref_proxy(self)
IDB_Hooks_swigregister = _idaapi.IDB_Hooks_swigregister
IDB_Hooks_swigregister(IDB_Hooks)

class netnode(object):
    """
    Proxy of C++ netnode class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> netnode
        __init__(self, num) -> netnode
        __init__(self, _name, namlen=0, do_create=False) -> netnode
        """
        this = _idaapi.new_netnode(*args)
        try: self.this.append(this)
        except: self.this = this
    def create(self, *args):
        """
        create(self, _name, namlen=0) -> bool
        create(self) -> bool
        """
        return _idaapi.netnode_create(self, *args)

    def kill(self, *args):
        """
        kill(self)
        """
        return _idaapi.netnode_kill(self, *args)

    def get_name(self, *args):
        """
        get_name(self, buf) -> ssize_t
        """
        return _idaapi.netnode_get_name(self, *args)

    def name(self, *args):
        """
        name(self) -> ssize_t
        """
        return _idaapi.netnode_name(self, *args)

    def rename(self, *args):
        """
        rename(self, newname, namlen=0) -> bool
        """
        return _idaapi.netnode_rename(self, *args)

    def valobj(self, *args):
        """
        valobj(self) -> ssize_t
        """
        return _idaapi.netnode_valobj(self, *args)

    def valstr(self, *args):
        """
        valstr(self) -> ssize_t
        """
        return _idaapi.netnode_valstr(self, *args)

    def set(self, *args):
        """
        set(self, value) -> bool
        """
        return _idaapi.netnode_set(self, *args)

    def delvalue(self, *args):
        """
        delvalue(self) -> bool
        """
        return _idaapi.netnode_delvalue(self, *args)

    def set_long(self, *args):
        """
        set_long(self, x) -> bool
        """
        return _idaapi.netnode_set_long(self, *args)

    def value_exists(self, *args):
        """
        value_exists(self) -> bool
        """
        return _idaapi.netnode_value_exists(self, *args)

    def long_value(self, *args):
        """
        long_value(self) -> nodeidx_t
        """
        return _idaapi.netnode_long_value(self, *args)

    def altval(self, *args):
        """
        altval(self, alt, tag=atag) -> nodeidx_t
        """
        return _idaapi.netnode_altval(self, *args)

    def altset(self, *args):
        """
        altset(self, alt, value, tag=atag) -> bool
        """
        return _idaapi.netnode_altset(self, *args)

    def alt1st(self, *args):
        """
        alt1st(self, tag=atag) -> nodeidx_t
        """
        return _idaapi.netnode_alt1st(self, *args)

    def altnxt(self, *args):
        """
        altnxt(self, cur, tag=atag) -> nodeidx_t
        """
        return _idaapi.netnode_altnxt(self, *args)

    def altlast(self, *args):
        """
        altlast(self, tag=atag) -> nodeidx_t
        """
        return _idaapi.netnode_altlast(self, *args)

    def altprev(self, *args):
        """
        altprev(self, cur, tag=atag) -> nodeidx_t
        """
        return _idaapi.netnode_altprev(self, *args)

    def altshift(self, *args):
        """
        altshift(self, frm, to, size, tag=atag) -> size_t
        """
        return _idaapi.netnode_altshift(self, *args)

    def charval(self, *args):
        """
        charval(self, alt, tag) -> uchar
        """
        return _idaapi.netnode_charval(self, *args)

    def charset(self, *args):
        """
        charset(self, alt, val, tag) -> bool
        """
        return _idaapi.netnode_charset(self, *args)

    def chardel(self, *args):
        """
        chardel(self, alt, tag) -> bool
        """
        return _idaapi.netnode_chardel(self, *args)

    def char1st(self, *args):
        """
        char1st(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_char1st(self, *args)

    def charnxt(self, *args):
        """
        charnxt(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charnxt(self, *args)

    def charlast(self, *args):
        """
        charlast(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charlast(self, *args)

    def charprev(self, *args):
        """
        charprev(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charprev(self, *args)

    def charshift(self, *args):
        """
        charshift(self, frm, to, size, tag) -> size_t
        """
        return _idaapi.netnode_charshift(self, *args)

    def altval_idx8(self, *args):
        """
        altval_idx8(self, alt, tag) -> nodeidx_t
        """
        return _idaapi.netnode_altval_idx8(self, *args)

    def altset_idx8(self, *args):
        """
        altset_idx8(self, alt, val, tag) -> bool
        """
        return _idaapi.netnode_altset_idx8(self, *args)

    def altdel_idx8(self, *args):
        """
        altdel_idx8(self, alt, tag) -> bool
        """
        return _idaapi.netnode_altdel_idx8(self, *args)

    def alt1st_idx8(self, *args):
        """
        alt1st_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_alt1st_idx8(self, *args)

    def altnxt_idx8(self, *args):
        """
        altnxt_idx8(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_altnxt_idx8(self, *args)

    def altlast_idx8(self, *args):
        """
        altlast_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_altlast_idx8(self, *args)

    def altprev_idx8(self, *args):
        """
        altprev_idx8(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_altprev_idx8(self, *args)

    def charval_idx8(self, *args):
        """
        charval_idx8(self, alt, tag) -> uchar
        """
        return _idaapi.netnode_charval_idx8(self, *args)

    def charset_idx8(self, *args):
        """
        charset_idx8(self, alt, val, tag) -> bool
        """
        return _idaapi.netnode_charset_idx8(self, *args)

    def chardel_idx8(self, *args):
        """
        chardel_idx8(self, alt, tag) -> bool
        """
        return _idaapi.netnode_chardel_idx8(self, *args)

    def char1st_idx8(self, *args):
        """
        char1st_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_char1st_idx8(self, *args)

    def charnxt_idx8(self, *args):
        """
        charnxt_idx8(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charnxt_idx8(self, *args)

    def charlast_idx8(self, *args):
        """
        charlast_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charlast_idx8(self, *args)

    def charprev_idx8(self, *args):
        """
        charprev_idx8(self, cur, tag) -> nodeidx_t
        """
        return _idaapi.netnode_charprev_idx8(self, *args)

    def altdel(self, *args):
        """
        altdel(self, alt, tag=atag) -> bool
        altdel(self) -> bool
        """
        return _idaapi.netnode_altdel(self, *args)

    def altdel_all(self, *args):
        """
        altdel_all(self, tag) -> bool
        """
        return _idaapi.netnode_altdel_all(self, *args)

    def supval(self, *args):
        """
        supval(self, alt, tag=stag) -> ssize_t
        """
        return _idaapi.netnode_supval(self, *args)

    def supstr(self, *args):
        """
        supstr(self, alt, tag=stag) -> ssize_t
        """
        return _idaapi.netnode_supstr(self, *args)

    def supset(self, *args):
        """
        supset(self, alt, value, tag=stag) -> bool
        """
        return _idaapi.netnode_supset(self, *args)

    def sup1st(self, *args):
        """
        sup1st(self, tag=stag) -> nodeidx_t
        """
        return _idaapi.netnode_sup1st(self, *args)

    def supnxt(self, *args):
        """
        supnxt(self, cur, tag=stag) -> nodeidx_t
        """
        return _idaapi.netnode_supnxt(self, *args)

    def suplast(self, *args):
        """
        suplast(self, tag=stag) -> nodeidx_t
        """
        return _idaapi.netnode_suplast(self, *args)

    def supprev(self, *args):
        """
        supprev(self, cur, tag=stag) -> nodeidx_t
        """
        return _idaapi.netnode_supprev(self, *args)

    def supshift(self, *args):
        """
        supshift(self, frm, to, size, tag=stag) -> size_t
        """
        return _idaapi.netnode_supshift(self, *args)

    def supval_idx8(self, *args):
        """
        supval_idx8(self, alt, tag) -> ssize_t
        """
        return _idaapi.netnode_supval_idx8(self, *args)

    def supstr_idx8(self, *args):
        """
        supstr_idx8(self, alt, tag) -> ssize_t
        """
        return _idaapi.netnode_supstr_idx8(self, *args)

    def supset_idx8(self, *args):
        """
        supset_idx8(self, alt, value, tag) -> bool
        """
        return _idaapi.netnode_supset_idx8(self, *args)

    def supdel_idx8(self, *args):
        """
        supdel_idx8(self, alt, tag) -> bool
        """
        return _idaapi.netnode_supdel_idx8(self, *args)

    def sup1st_idx8(self, *args):
        """
        sup1st_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_sup1st_idx8(self, *args)

    def supnxt_idx8(self, *args):
        """
        supnxt_idx8(self, alt, tag) -> nodeidx_t
        """
        return _idaapi.netnode_supnxt_idx8(self, *args)

    def suplast_idx8(self, *args):
        """
        suplast_idx8(self, tag) -> nodeidx_t
        """
        return _idaapi.netnode_suplast_idx8(self, *args)

    def supprev_idx8(self, *args):
        """
        supprev_idx8(self, alt, tag) -> nodeidx_t
        """
        return _idaapi.netnode_supprev_idx8(self, *args)

    def supdel(self, *args):
        """
        supdel(self, alt, tag=stag) -> bool
        supdel(self) -> bool
        """
        return _idaapi.netnode_supdel(self, *args)

    def supdel_all(self, *args):
        """
        supdel_all(self, tag) -> bool
        """
        return _idaapi.netnode_supdel_all(self, *args)

    def supdel_range(self, *args):
        """
        supdel_range(self, idx1, idx2, tag) -> int
        """
        return _idaapi.netnode_supdel_range(self, *args)

    def supdel_range_idx8(self, *args):
        """
        supdel_range_idx8(self, idx1, idx2, tag) -> int
        """
        return _idaapi.netnode_supdel_range_idx8(self, *args)

    def hashval(self, *args):
        """
        hashval(self, idx, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hashval(self, *args)

    def hashstr(self, *args):
        """
        hashstr(self, idx, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hashstr(self, *args)

    def hashval_long(self, *args):
        """
        hashval_long(self, idx, tag=htag) -> nodeidx_t
        """
        return _idaapi.netnode_hashval_long(self, *args)

    def hashset(self, *args):
        """
        hashset(self, idx, value, tag=htag) -> bool
        """
        return _idaapi.netnode_hashset(self, *args)

    def hashset_idx(self, *args):
        """
        hashset_idx(self, idx, value, tag=htag) -> bool
        """
        return _idaapi.netnode_hashset_idx(self, *args)

    def hashdel(self, *args):
        """
        hashdel(self, idx, tag=htag) -> bool
        """
        return _idaapi.netnode_hashdel(self, *args)

    def hash1st(self, *args):
        """
        hash1st(self, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hash1st(self, *args)

    def hashnxt(self, *args):
        """
        hashnxt(self, idx, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hashnxt(self, *args)

    def hashlast(self, *args):
        """
        hashlast(self, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hashlast(self, *args)

    def hashprev(self, *args):
        """
        hashprev(self, idx, tag=htag) -> ssize_t
        """
        return _idaapi.netnode_hashprev(self, *args)

    def hashdel_all(self, *args):
        """
        hashdel_all(self, tag=htag) -> bool
        """
        return _idaapi.netnode_hashdel_all(self, *args)

    def blobsize(self, *args):
        """
        blobsize(self, _start, tag) -> size_t
        """
        return _idaapi.netnode_blobsize(self, *args)

    def setblob(self, *args):
        """
        setblob(self, buf, _start, tag) -> bool
        """
        return _idaapi.netnode_setblob(self, *args)

    def delblob(self, *args):
        """
        delblob(self, _start, tag) -> int
        """
        return _idaapi.netnode_delblob(self, *args)

    def start(self, *args):
        """
        start(self) -> bool
        """
        return _idaapi.netnode_start(self, *args)

    def end(self, *args):
        """
        end(self) -> bool
        """
        return _idaapi.netnode_end(self, *args)

    def next(self, *args):
        """
        next(self) -> bool
        """
        return _idaapi.netnode_next(self, *args)

    def prev(self, *args):
        """
        prev(self) -> bool
        """
        return _idaapi.netnode_prev(self, *args)

    def copyto(self, *args):
        """
        copyto(self, target, count=1) -> size_t
        """
        return _idaapi.netnode_copyto(self, *args)

    def moveto(self, *args):
        """
        moveto(self, target, count=1) -> size_t
        """
        return _idaapi.netnode_moveto(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, n) -> bool
        __eq__(self, x) -> bool
        """
        return _idaapi.netnode___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, n) -> bool
        __ne__(self, x) -> bool
        """
        return _idaapi.netnode___ne__(self, *args)

    def index(self, *args):
        """
        index(self) -> nodeidx_t
        """
        return _idaapi.netnode_index(self, *args)

    def getblob(self, *args):
        """
        getblob(self, start, tag) -> PyObject *
        """
        return _idaapi.netnode_getblob(self, *args)

    def hashstr_buf(self, *args):
        """
        hashstr_buf(self, idx, tag=htag) -> PyObject *
        """
        return _idaapi.netnode_hashstr_buf(self, *args)

    def hashset_buf(self, *args):
        """
        hashset_buf(self, idx, py_str, tag=htag) -> bool
        """
        return _idaapi.netnode_hashset_buf(self, *args)

    __swig_destroy__ = _idaapi.delete_netnode
    __del__ = lambda self : None;
netnode_swigregister = _idaapi.netnode_swigregister
netnode_swigregister(netnode)
MAXNAMESIZE = cvar.MAXNAMESIZE
MAX_NODENAME_SIZE = cvar.MAX_NODENAME_SIZE
MAXSPECSIZE = cvar.MAXSPECSIZE
atag = cvar.atag
stag = cvar.stag
htag = cvar.htag
vtag = cvar.vtag
ntag = cvar.ntag
ltag = cvar.ltag
NNBASE_OK = _idaapi.NNBASE_OK
NNBASE_REPAIR = _idaapi.NNBASE_REPAIR
NNBASE_IOERR = _idaapi.NNBASE_IOERR
NNBASE_PAGE16 = _idaapi.NNBASE_PAGE16

class ids_array(object):
    """
    Proxy of C++ wrapped_array_t<(tid_t,32)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = _swig_property(_idaapi.ids_array_data_get)
    def __init__(self, *args):
        """
        __init__(self, data) -> ids_array
        """
        this = _idaapi.new_ids_array(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.ids_array___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> unsigned int const &
        """
        return _idaapi.ids_array___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.ids_array___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

    __swig_destroy__ = _idaapi.delete_ids_array
    __del__ = lambda self : None;
ids_array_swigregister = _idaapi.ids_array_swigregister
ids_array_swigregister(ids_array)
BTREE_PAGE_SIZE = cvar.BTREE_PAGE_SIZE

NALT_SWITCH = _idaapi.NALT_SWITCH
NALT_STRUCT = _idaapi.NALT_STRUCT
NALT_AFLAGS = _idaapi.NALT_AFLAGS
NALT_LINNUM = _idaapi.NALT_LINNUM
NALT_ABSBASE = _idaapi.NALT_ABSBASE
NALT_ENUM0 = _idaapi.NALT_ENUM0
NALT_ENUM1 = _idaapi.NALT_ENUM1
NALT_PURGE = _idaapi.NALT_PURGE
NALT_STRTYPE = _idaapi.NALT_STRTYPE
NALT_ALIGN = _idaapi.NALT_ALIGN
NALT_COLOR = _idaapi.NALT_COLOR
NSUP_CMT = _idaapi.NSUP_CMT
NSUP_REPCMT = _idaapi.NSUP_REPCMT
NSUP_FOP1 = _idaapi.NSUP_FOP1
NSUP_FOP2 = _idaapi.NSUP_FOP2
NSUP_JINFO = _idaapi.NSUP_JINFO
NSUP_ARRAY = _idaapi.NSUP_ARRAY
NSUP_OMFGRP = _idaapi.NSUP_OMFGRP
NSUP_FOP3 = _idaapi.NSUP_FOP3
NSUP_SWITCH = _idaapi.NSUP_SWITCH
NSUP_REF0 = _idaapi.NSUP_REF0
NSUP_REF1 = _idaapi.NSUP_REF1
NSUP_REF2 = _idaapi.NSUP_REF2
NSUP_OREF0 = _idaapi.NSUP_OREF0
NSUP_OREF1 = _idaapi.NSUP_OREF1
NSUP_OREF2 = _idaapi.NSUP_OREF2
NSUP_STROFF0 = _idaapi.NSUP_STROFF0
NSUP_STROFF1 = _idaapi.NSUP_STROFF1
NSUP_SEGTRANS = _idaapi.NSUP_SEGTRANS
NSUP_FOP4 = _idaapi.NSUP_FOP4
NSUP_FOP5 = _idaapi.NSUP_FOP5
NSUP_FOP6 = _idaapi.NSUP_FOP6
NSUP_REF3 = _idaapi.NSUP_REF3
NSUP_REF4 = _idaapi.NSUP_REF4
NSUP_REF5 = _idaapi.NSUP_REF5
NSUP_OREF3 = _idaapi.NSUP_OREF3
NSUP_OREF4 = _idaapi.NSUP_OREF4
NSUP_OREF5 = _idaapi.NSUP_OREF5
NSUP_XREFPOS = _idaapi.NSUP_XREFPOS
NSUP_CUSTDT = _idaapi.NSUP_CUSTDT
NSUP_GROUPS = _idaapi.NSUP_GROUPS
NSUP_POINTS = _idaapi.NSUP_POINTS
NSUP_MANUAL = _idaapi.NSUP_MANUAL
NSUP_TYPEINFO = _idaapi.NSUP_TYPEINFO
NSUP_REGVAR = _idaapi.NSUP_REGVAR
NSUP_LLABEL = _idaapi.NSUP_LLABEL
NSUP_REGARG = _idaapi.NSUP_REGARG
NSUP_FTAILS = _idaapi.NSUP_FTAILS
NSUP_GROUP = _idaapi.NSUP_GROUP
NSUP_OPTYPES = _idaapi.NSUP_OPTYPES
NALT_CREF_TO = _idaapi.NALT_CREF_TO
NALT_CREF_FROM = _idaapi.NALT_CREF_FROM
NALT_DREF_TO = _idaapi.NALT_DREF_TO
NALT_DREF_FROM = _idaapi.NALT_DREF_FROM
NSUP_GR_INFO = _idaapi.NSUP_GR_INFO
NALT_GR_LAYX = _idaapi.NALT_GR_LAYX
NSUP_GR_LAYT = _idaapi.NSUP_GR_LAYT
PATCH_TAG = _idaapi.PATCH_TAG
AFL_LINNUM = _idaapi.AFL_LINNUM
AFL_USERSP = _idaapi.AFL_USERSP
AFL_PUBNAM = _idaapi.AFL_PUBNAM
AFL_WEAKNAM = _idaapi.AFL_WEAKNAM
AFL_HIDDEN = _idaapi.AFL_HIDDEN
AFL_MANUAL = _idaapi.AFL_MANUAL
AFL_NOBRD = _idaapi.AFL_NOBRD
AFL_ZSTROFF = _idaapi.AFL_ZSTROFF
AFL_BNOT0 = _idaapi.AFL_BNOT0
AFL_BNOT1 = _idaapi.AFL_BNOT1
AFL_LIB = _idaapi.AFL_LIB
AFL_TI = _idaapi.AFL_TI
AFL_TI0 = _idaapi.AFL_TI0
AFL_TI1 = _idaapi.AFL_TI1
AFL_LNAME = _idaapi.AFL_LNAME
AFL_TILCMT = _idaapi.AFL_TILCMT
AFL_LZERO0 = _idaapi.AFL_LZERO0
AFL_LZERO1 = _idaapi.AFL_LZERO1
AFL_COLORED = _idaapi.AFL_COLORED
AFL_TERSESTR = _idaapi.AFL_TERSESTR
AFL_SIGN0 = _idaapi.AFL_SIGN0
AFL_SIGN1 = _idaapi.AFL_SIGN1
AFL_NORET = _idaapi.AFL_NORET
AFL_FIXEDSPD = _idaapi.AFL_FIXEDSPD
AFL_ALIGNFLOW = _idaapi.AFL_ALIGNFLOW
AFL_USERTI = _idaapi.AFL_USERTI
AFL_RETFP = _idaapi.AFL_RETFP
AFL_USEMODSP = _idaapi.AFL_USEMODSP
AFL_NOTCODE = _idaapi.AFL_NOTCODE

def set_aflags(*args):
  """
  set_aflags(ea, flags)
  """
  return _idaapi.set_aflags(*args)

def set_abits(*args):
  """
  set_abits(ea, bits)
  """
  return _idaapi.set_abits(*args)

def clr_abits(*args):
  """
  clr_abits(ea, bits)
  """
  return _idaapi.clr_abits(*args)

def get_aflags(*args):
  """
  get_aflags(ea) -> uint32
  """
  return _idaapi.get_aflags(*args)

def del_aflags(*args):
  """
  del_aflags(ea)
  """
  return _idaapi.del_aflags(*args)

def is_hidden_item(*args):
  """
  is_hidden_item(ea) -> bool
  """
  return _idaapi.is_hidden_item(*args)

def hide_item(*args):
  """
  hide_item(ea)
  """
  return _idaapi.hide_item(*args)

def unhide_item(*args):
  """
  unhide_item(ea)
  """
  return _idaapi.unhide_item(*args)

def is_hidden_border(*args):
  """
  is_hidden_border(ea) -> bool
  """
  return _idaapi.is_hidden_border(*args)

def hide_border(*args):
  """
  hide_border(ea)
  """
  return _idaapi.hide_border(*args)

def unhide_border(*args):
  """
  unhide_border(ea)
  """
  return _idaapi.unhide_border(*args)

def uses_modsp(*args):
  """
  uses_modsp(ea) -> bool
  """
  return _idaapi.uses_modsp(*args)

def set_usemodsp(*args):
  """
  set_usemodsp(ea)
  """
  return _idaapi.set_usemodsp(*args)

def clr_usemodsp(*args):
  """
  clr_usemodsp(ea)
  """
  return _idaapi.clr_usemodsp(*args)

def is_zstroff(*args):
  """
  is_zstroff(ea) -> bool
  """
  return _idaapi.is_zstroff(*args)

def set_zstroff(*args):
  """
  set_zstroff(ea)
  """
  return _idaapi.set_zstroff(*args)

def clr_zstroff(*args):
  """
  clr_zstroff(ea)
  """
  return _idaapi.clr_zstroff(*args)

def is__bnot0(*args):
  """
  is__bnot0(ea) -> bool
  """
  return _idaapi.is__bnot0(*args)

def set__bnot0(*args):
  """
  set__bnot0(ea)
  """
  return _idaapi.set__bnot0(*args)

def clr__bnot0(*args):
  """
  clr__bnot0(ea)
  """
  return _idaapi.clr__bnot0(*args)

def is__bnot1(*args):
  """
  is__bnot1(ea) -> bool
  """
  return _idaapi.is__bnot1(*args)

def set__bnot1(*args):
  """
  set__bnot1(ea)
  """
  return _idaapi.set__bnot1(*args)

def clr__bnot1(*args):
  """
  clr__bnot1(ea)
  """
  return _idaapi.clr__bnot1(*args)

def is_libitem(*args):
  """
  is_libitem(ea) -> bool
  """
  return _idaapi.is_libitem(*args)

def set_libitem(*args):
  """
  set_libitem(ea)
  """
  return _idaapi.set_libitem(*args)

def clr_libitem(*args):
  """
  clr_libitem(ea)
  """
  return _idaapi.clr_libitem(*args)

def has_ti(*args):
  """
  has_ti(ea) -> bool
  """
  return _idaapi.has_ti(*args)

def set_has_ti(*args):
  """
  set_has_ti(ea)
  """
  return _idaapi.set_has_ti(*args)

def clr_has_ti(*args):
  """
  clr_has_ti(ea)
  """
  return _idaapi.clr_has_ti(*args)

def has_ti0(*args):
  """
  has_ti0(ea) -> bool
  """
  return _idaapi.has_ti0(*args)

def set_has_ti0(*args):
  """
  set_has_ti0(ea)
  """
  return _idaapi.set_has_ti0(*args)

def clr_has_ti0(*args):
  """
  clr_has_ti0(ea)
  """
  return _idaapi.clr_has_ti0(*args)

def has_ti1(*args):
  """
  has_ti1(ea) -> bool
  """
  return _idaapi.has_ti1(*args)

def set_has_ti1(*args):
  """
  set_has_ti1(ea)
  """
  return _idaapi.set_has_ti1(*args)

def clr_has_ti1(*args):
  """
  clr_has_ti1(ea)
  """
  return _idaapi.clr_has_ti1(*args)

def has_lname(*args):
  """
  has_lname(ea) -> bool
  """
  return _idaapi.has_lname(*args)

def set_has_lname(*args):
  """
  set_has_lname(ea)
  """
  return _idaapi.set_has_lname(*args)

def clr_has_lname(*args):
  """
  clr_has_lname(ea)
  """
  return _idaapi.clr_has_lname(*args)

def is_tilcmt(*args):
  """
  is_tilcmt(ea) -> bool
  """
  return _idaapi.is_tilcmt(*args)

def set_tilcmt(*args):
  """
  set_tilcmt(ea)
  """
  return _idaapi.set_tilcmt(*args)

def clr_tilcmt(*args):
  """
  clr_tilcmt(ea)
  """
  return _idaapi.clr_tilcmt(*args)

def is_usersp(*args):
  """
  is_usersp(ea) -> bool
  """
  return _idaapi.is_usersp(*args)

def set_usersp(*args):
  """
  set_usersp(ea)
  """
  return _idaapi.set_usersp(*args)

def clr_usersp(*args):
  """
  clr_usersp(ea)
  """
  return _idaapi.clr_usersp(*args)

def is_lzero0(*args):
  """
  is_lzero0(ea) -> bool
  """
  return _idaapi.is_lzero0(*args)

def set_lzero0(*args):
  """
  set_lzero0(ea)
  """
  return _idaapi.set_lzero0(*args)

def clr_lzero0(*args):
  """
  clr_lzero0(ea)
  """
  return _idaapi.clr_lzero0(*args)

def is_lzero1(*args):
  """
  is_lzero1(ea) -> bool
  """
  return _idaapi.is_lzero1(*args)

def set_lzero1(*args):
  """
  set_lzero1(ea)
  """
  return _idaapi.set_lzero1(*args)

def clr_lzero1(*args):
  """
  clr_lzero1(ea)
  """
  return _idaapi.clr_lzero1(*args)

def is_colored_item(*args):
  """
  is_colored_item(ea) -> bool
  """
  return _idaapi.is_colored_item(*args)

def set_colored_item(*args):
  """
  set_colored_item(ea)
  """
  return _idaapi.set_colored_item(*args)

def clr_colored_item(*args):
  """
  clr_colored_item(ea)
  """
  return _idaapi.clr_colored_item(*args)

def is_terse_struc(*args):
  """
  is_terse_struc(ea) -> bool
  """
  return _idaapi.is_terse_struc(*args)

def set_terse_struc(*args):
  """
  set_terse_struc(ea)
  """
  return _idaapi.set_terse_struc(*args)

def clr_terse_struc(*args):
  """
  clr_terse_struc(ea)
  """
  return _idaapi.clr_terse_struc(*args)

def is__invsign0(*args):
  """
  is__invsign0(ea) -> bool
  """
  return _idaapi.is__invsign0(*args)

def set__invsign0(*args):
  """
  set__invsign0(ea)
  """
  return _idaapi.set__invsign0(*args)

def clr__invsign0(*args):
  """
  clr__invsign0(ea)
  """
  return _idaapi.clr__invsign0(*args)

def is__invsign1(*args):
  """
  is__invsign1(ea) -> bool
  """
  return _idaapi.is__invsign1(*args)

def set__invsign1(*args):
  """
  set__invsign1(ea)
  """
  return _idaapi.set__invsign1(*args)

def clr__invsign1(*args):
  """
  clr__invsign1(ea)
  """
  return _idaapi.clr__invsign1(*args)

def is_noret(*args):
  """
  is_noret(ea) -> bool
  """
  return _idaapi.is_noret(*args)

def set_noret(*args):
  """
  set_noret(ea)
  """
  return _idaapi.set_noret(*args)

def clr_noret(*args):
  """
  clr_noret(ea)
  """
  return _idaapi.clr_noret(*args)

def is_fixed_spd(*args):
  """
  is_fixed_spd(ea) -> bool
  """
  return _idaapi.is_fixed_spd(*args)

def set_fixed_spd(*args):
  """
  set_fixed_spd(ea)
  """
  return _idaapi.set_fixed_spd(*args)

def clr_fixed_spd(*args):
  """
  clr_fixed_spd(ea)
  """
  return _idaapi.clr_fixed_spd(*args)

def is_align_flow(*args):
  """
  is_align_flow(ea) -> bool
  """
  return _idaapi.is_align_flow(*args)

def set_align_flow(*args):
  """
  set_align_flow(ea)
  """
  return _idaapi.set_align_flow(*args)

def clr_align_flow(*args):
  """
  clr_align_flow(ea)
  """
  return _idaapi.clr_align_flow(*args)

def is_userti(*args):
  """
  is_userti(ea) -> bool
  """
  return _idaapi.is_userti(*args)

def set_userti(*args):
  """
  set_userti(ea)
  """
  return _idaapi.set_userti(*args)

def clr_userti(*args):
  """
  clr_userti(ea)
  """
  return _idaapi.clr_userti(*args)

def is_retfp(*args):
  """
  is_retfp(ea) -> bool
  """
  return _idaapi.is_retfp(*args)

def set_retfp(*args):
  """
  set_retfp(ea)
  """
  return _idaapi.set_retfp(*args)

def clr_retfp(*args):
  """
  clr_retfp(ea)
  """
  return _idaapi.clr_retfp(*args)

def is_notcode(*args):
  """
  is_notcode(ea) -> bool
  """
  return _idaapi.is_notcode(*args)

def set_notcode(*args):
  """
  set_notcode(ea)
  """
  return _idaapi.set_notcode(*args)

def clr_notcode(*args):
  """
  clr_notcode(ea)
  """
  return _idaapi.clr_notcode(*args)

def set_visible_item(*args):
  """
  set_visible_item(ea, visible)
  """
  return _idaapi.set_visible_item(*args)

def is_visible_item(*args):
  """
  is_visible_item(ea) -> bool
  """
  return _idaapi.is_visible_item(*args)

def is_finally_visible_item(*args):
  """
  is_finally_visible_item(ea) -> bool
  """
  return _idaapi.is_finally_visible_item(*args)

def set_source_linnum(*args):
  """
  set_source_linnum(ea, lnnum)
  """
  return _idaapi.set_source_linnum(*args)

def get_source_linnum(*args):
  """
  get_source_linnum(ea) -> uval_t
  """
  return _idaapi.get_source_linnum(*args)

def del_source_linnum(*args):
  """
  del_source_linnum(ea)
  """
  return _idaapi.del_source_linnum(*args)

def get_absbase(*args):
  """
  get_absbase(ea) -> ea_t
  """
  return _idaapi.get_absbase(*args)

def set_absbase(*args):
  """
  set_absbase(ea, x)
  """
  return _idaapi.set_absbase(*args)

def del_absbase(*args):
  """
  del_absbase(ea)
  """
  return _idaapi.del_absbase(*args)

def get_ind_purged(*args):
  """
  get_ind_purged(ea) -> ea_t
  """
  return _idaapi.get_ind_purged(*args)

def del_ind_purged(*args):
  """
  del_ind_purged(ea)
  """
  return _idaapi.del_ind_purged(*args)
ASCSTR_TERMCHR = _idaapi.ASCSTR_TERMCHR
ASCSTR_PASCAL = _idaapi.ASCSTR_PASCAL
ASCSTR_LEN2 = _idaapi.ASCSTR_LEN2
ASCSTR_UNICODE = _idaapi.ASCSTR_UNICODE
ASCSTR_UTF16 = _idaapi.ASCSTR_UTF16
ASCSTR_LEN4 = _idaapi.ASCSTR_LEN4
ASCSTR_ULEN2 = _idaapi.ASCSTR_ULEN2
ASCSTR_ULEN4 = _idaapi.ASCSTR_ULEN4
ASCSTR_UTF32 = _idaapi.ASCSTR_UTF32
ASCSTR_LAST = _idaapi.ASCSTR_LAST

def get_str_type_code(*args):
  """
  get_str_type_code(strtype) -> char
  """
  return _idaapi.get_str_type_code(*args)

def get_str_term1(*args):
  """
  get_str_term1(strtype) -> char
  """
  return _idaapi.get_str_term1(*args)

def get_str_term2(*args):
  """
  get_str_term2(strtype) -> char
  """
  return _idaapi.get_str_term2(*args)

def is_unicode(*args):
  """
  is_unicode(strtype) -> bool
  """
  return _idaapi.is_unicode(*args)

def is_pascal(*args):
  """
  is_pascal(strtype) -> bool
  """
  return _idaapi.is_pascal(*args)

def get_str_encoding_idx(*args):
  """
  get_str_encoding_idx(strtype) -> uchar
  """
  return _idaapi.get_str_encoding_idx(*args)
STRENC_DEFAULT = _idaapi.STRENC_DEFAULT
STRENC_NONE = _idaapi.STRENC_NONE

def get_alignment(*args):
  """
  get_alignment(ea) -> uint32
  """
  return _idaapi.get_alignment(*args)

def set_alignment(*args):
  """
  set_alignment(ea, x)
  """
  return _idaapi.set_alignment(*args)

def del_alignment(*args):
  """
  del_alignment(ea)
  """
  return _idaapi.del_alignment(*args)

def set_item_color(*args):
  """
  set_item_color(ea, color)
  """
  return _idaapi.set_item_color(*args)

def get_item_color(*args):
  """
  get_item_color(ea) -> bgcolor_t
  """
  return _idaapi.get_item_color(*args)

def del_item_color(*args):
  """
  del_item_color(ea)
  """
  return _idaapi.del_item_color(*args)
class jumptable_info_t(object):
    """
    Proxy of C++ jumptable_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    table = _swig_property(_idaapi.jumptable_info_t_table_get, _idaapi.jumptable_info_t_table_set)
    size = _swig_property(_idaapi.jumptable_info_t_size_get, _idaapi.jumptable_info_t_size_set)
    def __init__(self, *args):
        """
        __init__(self) -> jumptable_info_t
        """
        this = _idaapi.new_jumptable_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_jumptable_info_t
    __del__ = lambda self : None;
jumptable_info_t_swigregister = _idaapi.jumptable_info_t_swigregister
jumptable_info_t_swigregister(jumptable_info_t)


def get_jumptable_info(*args):
  """
  get_jumptable_info(ea, buf, bufsize) -> ssize_t
  """
  return _idaapi.get_jumptable_info(*args)

def set_jumptable_info(*args):
  """
  set_jumptable_info(ea, oi)
  """
  return _idaapi.set_jumptable_info(*args)

def del_jumptable_info(*args):
  """
  del_jumptable_info(ea)
  """
  return _idaapi.del_jumptable_info(*args)
class array_parameters_t(object):
    """
    Proxy of C++ array_parameters_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.array_parameters_t_flags_get, _idaapi.array_parameters_t_flags_set)
    lineitems = _swig_property(_idaapi.array_parameters_t_lineitems_get, _idaapi.array_parameters_t_lineitems_set)
    alignment = _swig_property(_idaapi.array_parameters_t_alignment_get, _idaapi.array_parameters_t_alignment_set)
    def __init__(self, *args):
        """
        __init__(self) -> array_parameters_t
        """
        this = _idaapi.new_array_parameters_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_array_parameters_t
    __del__ = lambda self : None;
array_parameters_t_swigregister = _idaapi.array_parameters_t_swigregister
array_parameters_t_swigregister(array_parameters_t)
AP_ALLOWDUPS = _idaapi.AP_ALLOWDUPS
AP_SIGNED = _idaapi.AP_SIGNED
AP_INDEX = _idaapi.AP_INDEX
AP_ARRAY = _idaapi.AP_ARRAY
AP_IDXBASEMASK = _idaapi.AP_IDXBASEMASK
AP_IDXDEC = _idaapi.AP_IDXDEC
AP_IDXHEX = _idaapi.AP_IDXHEX
AP_IDXOCT = _idaapi.AP_IDXOCT
AP_IDXBIN = _idaapi.AP_IDXBIN


def get_array_parameters(*args):
  """
  get_array_parameters(ea, buf, bufsize) -> ssize_t
  """
  return _idaapi.get_array_parameters(*args)

def set_array_parameters(*args):
  """
  set_array_parameters(ea, oi)
  """
  return _idaapi.set_array_parameters(*args)

def del_array_parameters(*args):
  """
  del_array_parameters(ea)
  """
  return _idaapi.del_array_parameters(*args)

def get_switch_parent(*args):
  """
  get_switch_parent(ea) -> ea_t
  """
  return _idaapi.get_switch_parent(*args)

def set_switch_parent(*args):
  """
  set_switch_parent(ea, x)
  """
  return _idaapi.set_switch_parent(*args)

def del_switch_parent(*args):
  """
  del_switch_parent(ea)
  """
  return _idaapi.del_switch_parent(*args)
class custom_data_type_ids_t(object):
    """
    Proxy of C++ custom_data_type_ids_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dtid = _swig_property(_idaapi.custom_data_type_ids_t_dtid_get, _idaapi.custom_data_type_ids_t_dtid_set)
    fids = _swig_property(_idaapi.custom_data_type_ids_t_fids_get, _idaapi.custom_data_type_ids_t_fids_set)
    def __init__(self, *args):
        """
        __init__(self) -> custom_data_type_ids_t
        """
        this = _idaapi.new_custom_data_type_ids_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_custom_data_type_ids_t
    __del__ = lambda self : None;
custom_data_type_ids_t_swigregister = _idaapi.custom_data_type_ids_t_swigregister
custom_data_type_ids_t_swigregister(custom_data_type_ids_t)


def get_custom_data_type_ids(*args):
  """
  get_custom_data_type_ids(ea, cdis, bufsize) -> int
  """
  return _idaapi.get_custom_data_type_ids(*args)

def set_custom_data_type_ids(*args):
  """
  set_custom_data_type_ids(ea, cdis)
  """
  return _idaapi.set_custom_data_type_ids(*args)

def del_custom_data_type_ids(*args):
  """
  del_custom_data_type_ids(ea)
  """
  return _idaapi.del_custom_data_type_ids(*args)

def get_reftype_by_size(*args):
  """
  get_reftype_by_size(size) -> reftype_t
  """
  return _idaapi.get_reftype_by_size(*args)
class refinfo_t(object):
    """
    Proxy of C++ refinfo_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    target = _swig_property(_idaapi.refinfo_t_target_get, _idaapi.refinfo_t_target_set)
    base = _swig_property(_idaapi.refinfo_t_base_get, _idaapi.refinfo_t_base_set)
    tdelta = _swig_property(_idaapi.refinfo_t_tdelta_get, _idaapi.refinfo_t_tdelta_set)
    flags = _swig_property(_idaapi.refinfo_t_flags_get, _idaapi.refinfo_t_flags_set)
    def type(self, *args):
        """
        type(self) -> reftype_t
        """
        return _idaapi.refinfo_t_type(self, *args)

    def no_base_xref(self, *args):
        """
        no_base_xref(self) -> bool
        """
        return _idaapi.refinfo_t_no_base_xref(self, *args)

    def is_pastend(self, *args):
        """
        is_pastend(self) -> bool
        """
        return _idaapi.refinfo_t_is_pastend(self, *args)

    def is_rvaoff(self, *args):
        """
        is_rvaoff(self) -> bool
        """
        return _idaapi.refinfo_t_is_rvaoff(self, *args)

    def is_custom(self, *args):
        """
        is_custom(self) -> bool
        """
        return _idaapi.refinfo_t_is_custom(self, *args)

    def is_subtract(self, *args):
        """
        is_subtract(self) -> bool
        """
        return _idaapi.refinfo_t_is_subtract(self, *args)

    def is_signed(self, *args):
        """
        is_signed(self) -> bool
        """
        return _idaapi.refinfo_t_is_signed(self, *args)

    def set_type(self, *args):
        """
        set_type(self, t)
        """
        return _idaapi.refinfo_t_set_type(self, *args)

    def init(self, *args):
        """
        init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0)
        """
        return _idaapi.refinfo_t_init(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> refinfo_t
        """
        this = _idaapi.new_refinfo_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_refinfo_t
    __del__ = lambda self : None;
refinfo_t_swigregister = _idaapi.refinfo_t_swigregister
refinfo_t_swigregister(refinfo_t)
REF_OFF8 = cvar.REF_OFF8
REF_OFF16 = cvar.REF_OFF16
REF_OFF32 = cvar.REF_OFF32
REF_LOW8 = cvar.REF_LOW8
REF_LOW16 = cvar.REF_LOW16
REF_HIGH8 = cvar.REF_HIGH8
REF_HIGH16 = cvar.REF_HIGH16
REF_VHIGH = cvar.REF_VHIGH
REF_VLOW = cvar.REF_VLOW
REF_OFF64 = cvar.REF_OFF64
REF_LAST = cvar.REF_LAST
REFINFO_TYPE = _idaapi.REFINFO_TYPE
REFINFO_RVAOFF = _idaapi.REFINFO_RVAOFF
REFINFO_PASTEND = _idaapi.REFINFO_PASTEND
REFINFO_CUSTOM = _idaapi.REFINFO_CUSTOM
REFINFO_NOBASE = _idaapi.REFINFO_NOBASE
REFINFO_SUBTRACT = _idaapi.REFINFO_SUBTRACT
REFINFO_SIGNEDOP = _idaapi.REFINFO_SIGNEDOP

MAXSTRUCPATH = _idaapi.MAXSTRUCPATH
class strpath_t(object):
    """
    Proxy of C++ strpath_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    len = _swig_property(_idaapi.strpath_t_len_get, _idaapi.strpath_t_len_set)
    ids = _swig_property(_idaapi.strpath_t_ids_get, _idaapi.strpath_t_ids_set)
    delta = _swig_property(_idaapi.strpath_t_delta_get, _idaapi.strpath_t_delta_set)
    def __getIds(self, *args):
        """
        __getIds(self) -> ids_array
        """
        return _idaapi.strpath_t___getIds(self, *args)

    ids = property(__getIds)

    def __init__(self, *args):
        """
        __init__(self) -> strpath_t
        """
        this = _idaapi.new_strpath_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_strpath_t
    __del__ = lambda self : None;
strpath_t_swigregister = _idaapi.strpath_t_swigregister
strpath_t_swigregister(strpath_t)

class enum_const_t(object):
    """
    Proxy of C++ enum_const_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    tid = _swig_property(_idaapi.enum_const_t_tid_get, _idaapi.enum_const_t_tid_set)
    serial = _swig_property(_idaapi.enum_const_t_serial_get, _idaapi.enum_const_t_serial_set)
    def __init__(self, *args):
        """
        __init__(self) -> enum_const_t
        """
        this = _idaapi.new_enum_const_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_enum_const_t
    __del__ = lambda self : None;
enum_const_t_swigregister = _idaapi.enum_const_t_swigregister
enum_const_t_swigregister(enum_const_t)

class opinfo_t(object):
    """
    Proxy of C++ opinfo_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ri = _swig_property(_idaapi.opinfo_t_ri_get, _idaapi.opinfo_t_ri_set)
    tid = _swig_property(_idaapi.opinfo_t_tid_get, _idaapi.opinfo_t_tid_set)
    path = _swig_property(_idaapi.opinfo_t_path_get, _idaapi.opinfo_t_path_set)
    strtype = _swig_property(_idaapi.opinfo_t_strtype_get, _idaapi.opinfo_t_strtype_set)
    ec = _swig_property(_idaapi.opinfo_t_ec_get, _idaapi.opinfo_t_ec_set)
    cd = _swig_property(_idaapi.opinfo_t_cd_get, _idaapi.opinfo_t_cd_set)
    def __init__(self, *args):
        """
        __init__(self) -> opinfo_t
        """
        this = _idaapi.new_opinfo_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_opinfo_t
    __del__ = lambda self : None;
opinfo_t_swigregister = _idaapi.opinfo_t_swigregister
opinfo_t_swigregister(opinfo_t)


def set_refinfo_ex(*args):
  """
  set_refinfo_ex(ea, n, ri) -> int
  """
  return _idaapi.set_refinfo_ex(*args)

def set_refinfo(*args):
  """
  set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int
  """
  return _idaapi.set_refinfo(*args)

def get_refinfo(*args):
  """
  get_refinfo(ea, n, ri) -> int
  """
  return _idaapi.get_refinfo(*args)

def del_refinfo(*args):
  """
  del_refinfo(ea, n) -> int
  """
  return _idaapi.del_refinfo(*args)

def get_tinfo2(*args):
  """
  get_tinfo2(ea, tif) -> bool
  """
  return _idaapi.get_tinfo2(*args)

def set_tinfo2(*args):
  """
  set_tinfo2(ea, tif) -> bool
  """
  return _idaapi.set_tinfo2(*args)

def get_op_tinfo2(*args):
  """
  get_op_tinfo2(ea, n, tif) -> bool
  """
  return _idaapi.get_op_tinfo2(*args)

def set_op_tinfo2(*args):
  """
  set_op_tinfo2(ea, n, tif) -> bool
  """
  return _idaapi.set_op_tinfo2(*args)

def del_tinfo2(*args):
  """
    del_tinfo2(ea)
    del_tinfo2(ea, n)
    """
  return _idaapi.del_tinfo2(*args)
RIDX_FILE_FORMAT_NAME = _idaapi.RIDX_FILE_FORMAT_NAME
RIDX_SELECTORS = _idaapi.RIDX_SELECTORS
RIDX_GROUPS = _idaapi.RIDX_GROUPS
RIDX_H_PATH = _idaapi.RIDX_H_PATH
RIDX_C_MACROS = _idaapi.RIDX_C_MACROS
RIDX_SMALL_IDC_OLD = _idaapi.RIDX_SMALL_IDC_OLD
RIDX_NOTEPAD = _idaapi.RIDX_NOTEPAD
RIDX_INCLUDE = _idaapi.RIDX_INCLUDE
RIDX_SMALL_IDC = _idaapi.RIDX_SMALL_IDC
RIDX_DUALOP_GRAPH = _idaapi.RIDX_DUALOP_GRAPH
RIDX_DUALOP_TEXT = _idaapi.RIDX_DUALOP_TEXT
RIDX_MD5 = _idaapi.RIDX_MD5
RIDX_IDA_VERSION = _idaapi.RIDX_IDA_VERSION
RIDX_AUTO_PLUGINS = _idaapi.RIDX_AUTO_PLUGINS
RIDX_STR_ENCODINGS = _idaapi.RIDX_STR_ENCODINGS
RIDX_SRCDBG_PATHS = _idaapi.RIDX_SRCDBG_PATHS
RIDX_SELECTED_EXTLANG = _idaapi.RIDX_SELECTED_EXTLANG
RIDX_DBG_BINPATHS = _idaapi.RIDX_DBG_BINPATHS

def get_input_file_path(*args):
  """
  get_input_file_path() -> ssize_t
  """
  return _idaapi.get_input_file_path(*args)

def get_root_filename(*args):
  """
  get_root_filename() -> ssize_t
  """
  return _idaapi.get_root_filename(*args)

def set_root_filename(*args):
  """
  set_root_filename(file)
  """
  return _idaapi.set_root_filename(*args)

def retrieve_input_file_crc32(*args):
  """
  retrieve_input_file_crc32() -> uint32
  """
  return _idaapi.retrieve_input_file_crc32(*args)

def retrieve_input_file_md5(*args):
  """
  retrieve_input_file_md5(hash) -> bool
  """
  return _idaapi.retrieve_input_file_md5(*args)

def get_asm_inc_file(*args):
  """
  get_asm_inc_file() -> ssize_t
  """
  return _idaapi.get_asm_inc_file(*args)

def set_asm_inc_file(*args):
  """
  set_asm_inc_file(file) -> bool
  """
  return _idaapi.set_asm_inc_file(*args)

def get_imagebase(*args):
  """
  get_imagebase() -> ea_t
  """
  return _idaapi.get_imagebase(*args)

def set_imagebase(*args):
  """
  set_imagebase(base)
  """
  return _idaapi.set_imagebase(*args)

def get_ids_modnode(*args):
  """
  get_ids_modnode() -> netnode
  """
  return _idaapi.get_ids_modnode(*args)

def set_ids_modnode(*args):
  """
  set_ids_modnode(id)
  """
  return _idaapi.set_ids_modnode(*args)

def get_auto_plugins(*args):
  """
  get_auto_plugins() -> ssize_t
  """
  return _idaapi.get_auto_plugins(*args)

def set_auto_plugins(*args):
  """
  set_auto_plugins(list, listsize=0) -> bool
  """
  return _idaapi.set_auto_plugins(*args)

def dbg_get_input_path(*args):
  """
  dbg_get_input_path() -> ssize_t
  """
  return _idaapi.dbg_get_input_path(*args)

def get_encodings_count(*args):
  """
  get_encodings_count() -> int
  """
  return _idaapi.get_encodings_count(*args)

def get_encoding_name(*args):
  """
  get_encoding_name(idx) -> char const *
  """
  return _idaapi.get_encoding_name(*args)

def add_encoding(*args):
  """
  add_encoding(encoding) -> int
  """
  return _idaapi.add_encoding(*args)

def del_encoding(*args):
  """
  del_encoding(idx) -> bool
  """
  return _idaapi.del_encoding(*args)

def change_encoding_name(*args):
  """
  change_encoding_name(idx, encoding) -> bool
  """
  return _idaapi.change_encoding_name(*args)

def get_default_encoding_idx(*args):
  """
  get_default_encoding_idx(strtype) -> int
  """
  return _idaapi.get_default_encoding_idx(*args)

def set_default_encoding_idx(*args):
  """
  set_default_encoding_idx(strtype, idx) -> bool
  """
  return _idaapi.set_default_encoding_idx(*args)

def encoding_from_strtype(*args):
  """
  encoding_from_strtype(strtype) -> char const *
  """
  return _idaapi.encoding_from_strtype(*args)

def get_import_module_qty(*args):
  """
  get_import_module_qty() -> uint
  """
  return _idaapi.get_import_module_qty(*args)

def validate_idb_names(*args):
  """
  validate_idb_names() -> int
  """
  return _idaapi.validate_idb_names(*args)
SWI_SHIFT1 = _idaapi.SWI_SHIFT1

def get_tinfo(*args):
  """
  get_tinfo(ea, type, fields) -> bool
  """
  return _idaapi.get_tinfo(*args)

def set_tinfo(*args):
  """
  set_tinfo(ea, ti, fnames) -> bool
  """
  return _idaapi.set_tinfo(*args)

def get_import_module_name(*args):
  """
  get_import_module_name(mod_index) -> PyObject *


  Returns the name of an imported module given its index
  @return: None or the module name
  """
  return _idaapi.get_import_module_name(*args)

def get_switch_info_ex(*args):
  """
  get_switch_info_ex(ea) -> PyObject *


  Returns the a switch_info_ex_t structure containing the information about the switch.
  Please refer to the SDK sample 'uiswitch'
  @return: None or switch_info_ex_t instance
  """
  return _idaapi.get_switch_info_ex(*args)

def create_switch_xrefs(*args):
  """
  create_switch_xrefs(insn_ea, py_swi) -> bool


  This function creates xrefs from the indirect jump.
  
  Usually there is no need to call this function directly because the kernel
  will call it for switch tables
  
  Note: Custom switch information are not supported yet.
  
  @param insn_ea: address of the 'indirect jump' instruction
  @param si: switch information
  
  @return: Boolean
  """
  return _idaapi.create_switch_xrefs(*args)
class cases_and_targets_t(object):
    """
    Proxy of C++ cases_and_targets_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cases = _swig_property(_idaapi.cases_and_targets_t_cases_get, _idaapi.cases_and_targets_t_cases_set)
    targets = _swig_property(_idaapi.cases_and_targets_t_targets_get, _idaapi.cases_and_targets_t_targets_set)
    def __init__(self, *args):
        """
        __init__(self) -> cases_and_targets_t
        """
        this = _idaapi.new_cases_and_targets_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cases_and_targets_t
    __del__ = lambda self : None;
cases_and_targets_t_swigregister = _idaapi.cases_and_targets_t_swigregister
cases_and_targets_t_swigregister(cases_and_targets_t)


def create_switch_table(*args):
  """
  create_switch_table(insn_ea, py_swi) -> bool


  Create switch table from the switch information
  
  @param insn_ea: address of the 'indirect jump' instruction
  @param si: switch information
  
  @return: Boolean
  """
  return _idaapi.create_switch_table(*args)

def set_switch_info_ex(*args):
  """
  set_switch_info_ex(ea, py_swi) -> bool


  Saves the switch information in the database
  Please refer to the SDK sample 'uiswitch'
  @return: Boolean
  """
  return _idaapi.set_switch_info_ex(*args)

def del_switch_info_ex(*args):
  """
  del_switch_info_ex(ea)


  Deletes stored switch information
  """
  return _idaapi.del_switch_info_ex(*args)

def enum_import_names(*args):
  """
  enum_import_names(mod_index, py_cb) -> int


  Enumerate imports from a specific module.
  Please refer to ex_imports.py example.
  
  @param mod_index: The module index
  @param callback: A callable object that will be invoked with an ea, name (could be None) and ordinal.
  @return: 1-finished ok, -1 on error, otherwise callback return value (<=0)
  """
  return _idaapi.enum_import_names(*args)

def switch_info_ex_t_create(*args):
  """
  switch_info_ex_t_create() -> PyObject *
  """
  return _idaapi.switch_info_ex_t_create(*args)

def switch_info_ex_t_destroy(*args):
  """
  switch_info_ex_t_destroy(py_obj) -> bool
  """
  return _idaapi.switch_info_ex_t_destroy(*args)

def switch_info_ex_t_assign(*args):
  """
  switch_info_ex_t_assign(self, other) -> bool
  """
  return _idaapi.switch_info_ex_t_assign(*args)

def switch_info_ex_t_get_regdtyp(*args):
  """
  switch_info_ex_t_get_regdtyp(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_regdtyp(*args)

def switch_info_ex_t_set_regdtyp(*args):
  """
  switch_info_ex_t_set_regdtyp(self, value)
  """
  return _idaapi.switch_info_ex_t_set_regdtyp(*args)

def switch_info_ex_t_get_flags2(*args):
  """
  switch_info_ex_t_get_flags2(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_flags2(*args)

def switch_info_ex_t_set_flags2(*args):
  """
  switch_info_ex_t_set_flags2(self, value)
  """
  return _idaapi.switch_info_ex_t_set_flags2(*args)

def switch_info_ex_t_get_jcases(*args):
  """
  switch_info_ex_t_get_jcases(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_jcases(*args)

def switch_info_ex_t_set_jcases(*args):
  """
  switch_info_ex_t_set_jcases(self, value)
  """
  return _idaapi.switch_info_ex_t_set_jcases(*args)

def switch_info_ex_t_get_regnum(*args):
  """
  switch_info_ex_t_get_regnum(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_regnum(*args)

def switch_info_ex_t_set_regnum(*args):
  """
  switch_info_ex_t_set_regnum(self, value)
  """
  return _idaapi.switch_info_ex_t_set_regnum(*args)

def switch_info_ex_t_get_flags(*args):
  """
  switch_info_ex_t_get_flags(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_flags(*args)

def switch_info_ex_t_set_flags(*args):
  """
  switch_info_ex_t_set_flags(self, value)
  """
  return _idaapi.switch_info_ex_t_set_flags(*args)

def switch_info_ex_t_get_ncases(*args):
  """
  switch_info_ex_t_get_ncases(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_ncases(*args)

def switch_info_ex_t_set_ncases(*args):
  """
  switch_info_ex_t_set_ncases(self, value)
  """
  return _idaapi.switch_info_ex_t_set_ncases(*args)

def switch_info_ex_t_get_defjump(*args):
  """
  switch_info_ex_t_get_defjump(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_defjump(*args)

def switch_info_ex_t_set_defjump(*args):
  """
  switch_info_ex_t_set_defjump(self, value)
  """
  return _idaapi.switch_info_ex_t_set_defjump(*args)

def switch_info_ex_t_get_jumps(*args):
  """
  switch_info_ex_t_get_jumps(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_jumps(*args)

def switch_info_ex_t_set_jumps(*args):
  """
  switch_info_ex_t_set_jumps(self, value)
  """
  return _idaapi.switch_info_ex_t_set_jumps(*args)

def switch_info_ex_t_get_elbase(*args):
  """
  switch_info_ex_t_get_elbase(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_elbase(*args)

def switch_info_ex_t_set_elbase(*args):
  """
  switch_info_ex_t_set_elbase(self, value)
  """
  return _idaapi.switch_info_ex_t_set_elbase(*args)

def switch_info_ex_t_get_startea(*args):
  """
  switch_info_ex_t_get_startea(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_startea(*args)

def switch_info_ex_t_set_startea(*args):
  """
  switch_info_ex_t_set_startea(self, value)
  """
  return _idaapi.switch_info_ex_t_set_startea(*args)

def switch_info_ex_t_get_custom(*args):
  """
  switch_info_ex_t_get_custom(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_custom(*args)

def switch_info_ex_t_set_custom(*args):
  """
  switch_info_ex_t_set_custom(self, value)
  """
  return _idaapi.switch_info_ex_t_set_custom(*args)

def switch_info_ex_t_get_ind_lowcase(*args):
  """
  switch_info_ex_t_get_ind_lowcase(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_ind_lowcase(*args)

def switch_info_ex_t_set_ind_lowcase(*args):
  """
  switch_info_ex_t_set_ind_lowcase(self, value)
  """
  return _idaapi.switch_info_ex_t_set_ind_lowcase(*args)

def switch_info_ex_t_get_values_lowcase(*args):
  """
  switch_info_ex_t_get_values_lowcase(self) -> PyObject *
  """
  return _idaapi.switch_info_ex_t_get_values_lowcase(*args)

def switch_info_ex_t_set_values_lowcase(*args):
  """
  switch_info_ex_t_set_values_lowcase(self, value)
  """
  return _idaapi.switch_info_ex_t_set_values_lowcase(*args)
#<pycode(py_nalt)>
SWI_SPARSE      = 0x1
"""
sparse switch ( value table present ) otherwise lowcase present
"""
SWI_V32         = 0x2
"""
32-bit values in table
"""
SWI_J32         = 0x4
"""
32-bit jump offsets
"""
SWI_VSPLIT      = 0x8
"""
value table is split (only for 32-bit values)
"""
SWI_DEFAULT     = 0x10
"""
default case is present
"""
SWI_END_IN_TBL  = 0x20
"""
switchend in table (default entry)
"""
SWI_JMP_INV     = 0x40
"""
jumptable is inversed (last entry is for first entry in values table)
"""
SWI_SHIFT_MASK  = 0x180
"""
use formula (element*shift + elbase) to find jump targets
"""

SWI_ELBASE      = 0x200
"""
elbase is present (if not and shift!=0, endof(jumpea) is used)
"""
SWI_JSIZE       = 0x400
"""
jump offset expansion bit
"""

SWI_VSIZE       = 0x800
"""
value table element size expansion bit
"""

SWI_SEPARATE    = 0x1000
"""
do not create an array of individual dwords
"""

SWI_SIGNED      = 0x2000
"""
jump table entries are signed
"""

SWI_CUSTOM      = 0x4000
"""
custom jump table - ph.create_switch_xrefs will be called to create code xrefs for the table. it must return 2. custom jump table must be created by the module
"""

SWI_EXTENDED    = 0x8000
"""
this is switch_info_ex_t
"""

SWI2_INDIRECT = 0x0001
"""
value table elements are used as indexes into the jump table
"""
SWI2_SUBTRACT = 0x0002
"""
table values are subtracted from the elbase instead of being addded
"""

# --------------------------------------------------------------------------
class switch_info_ex_t(py_clinked_object_t):
    def __init__(self, lnk = None):
        py_clinked_object_t.__init__(self, lnk)

    def _create_clink(self):
        return _idaapi.switch_info_ex_t_create()

    def _del_clink(self, lnk):
        return _idaapi.switch_info_ex_t_destroy(lnk)

    def assign(self, other):
        return _idaapi.switch_info_ex_t_assign(self, other)

    def is_indirect(self):
        return (self.flags & SWI_EXTENDED) != 0 and (self.flags2 & SWI2_INDIRECT) != 0

    def is_subtract(self):
        return (self.flags & SWI_EXTENDED) != 0 and (self.flags2 & SWI2_SUBTRACT) != 0

    def get_jtable_size(self):
        return self.jcases if self.is_indirect() else self.ncases

    def get_lowcase(self):
        return self.ind_lowcase if self.is_indirect() else self.lowcase

    def set_expr(self, r, dt):
        self.regnum = r
        self.regdtyp = dt

    def get_shift(self):
        return (self.flags & SWI_SHIFT_MASK) >> 7

    def set_shift(self, shift):
        self.flags &= ~SWI_SHIFT_MASK
        self.flags |= ((shift & 3) << 7)

    def get_jtable_element_size(self):
        code = self.flags & (SWI_J32|SWI_JSIZE)
        if   code == 0:         return 2
        elif code == SWI_J32:   return 4
        elif code == SWI_JSIZE: return 1
        else:                   return 8

    def set_jtable_element_size(self, size):
        self.flags &= ~(SWI_J32|SWI_JSIZE)
        if size == 4:   self.flags |= SWI_J32
        elif size == 1: self.flags |= SWI_JSIZE
        elif size == 8: self.flags |= SWI_J32|SWI_JSIZE
        elif size != 2: return False
        return True

    def get_vtable_element_size(self):
        code = self.flags & (SWI_V32|SWI_VSIZE)
        if   code == 0:         return 2
        elif code == SWI_V32:   return 4
        elif code == SWI_VSIZE: return 1
        return 8

    def set_vtable_element_size(self, size):
        self.flags &= ~SWI_V32|SWI_VSIZE
        if size == 4:   self.flags |= SWI_V32
        elif size == 1: self.flags |= SWI_VSIZE
        elif size == 8: self.flags |= SWI_V32|SWI_VSIZE
        elif size != 2: return False
        return True

    #
    # Autogenerated
    #
    def __get_regdtyp__(self):
        return _idaapi.switch_info_ex_t_get_regdtyp(self)
    def __set_regdtyp__(self, v):
        _idaapi.switch_info_ex_t_set_regdtyp(self, v)
    def __get_flags2__(self):
        return _idaapi.switch_info_ex_t_get_flags2(self)
    def __set_flags2__(self, v):
        _idaapi.switch_info_ex_t_set_flags2(self, v)
    def __get_jcases__(self):
        return _idaapi.switch_info_ex_t_get_jcases(self)
    def __set_jcases__(self, v):
        _idaapi.switch_info_ex_t_set_jcases(self, v)
    def __get_regnum__(self):
        return _idaapi.switch_info_ex_t_get_regnum(self)
    def __set_regnum__(self, v):
        _idaapi.switch_info_ex_t_set_regnum(self, v)
    def __get_flags__(self):
        return _idaapi.switch_info_ex_t_get_flags(self)
    def __set_flags__(self, v):
        _idaapi.switch_info_ex_t_set_flags(self, v)
    def __get_ncases__(self):
        return _idaapi.switch_info_ex_t_get_ncases(self)
    def __set_ncases__(self, v):
        _idaapi.switch_info_ex_t_set_ncases(self, v)
    def __get_defjump__(self):
        return _idaapi.switch_info_ex_t_get_defjump(self)
    def __set_defjump__(self, v):
        _idaapi.switch_info_ex_t_set_defjump(self, v)
    def __get_jumps__(self):
        return _idaapi.switch_info_ex_t_get_jumps(self)
    def __set_jumps__(self, v):
        _idaapi.switch_info_ex_t_set_jumps(self, v)
    def __get_elbase__(self):
        return _idaapi.switch_info_ex_t_get_elbase(self)
    def __set_elbase__(self, v):
        _idaapi.switch_info_ex_t_set_elbase(self, v)
    def __get_startea__(self):
        return _idaapi.switch_info_ex_t_get_startea(self)
    def __set_startea__(self, v):
        _idaapi.switch_info_ex_t_set_startea(self, v)
    def __get_custom__(self):
        return _idaapi.switch_info_ex_t_get_custom(self)
    def __set_custom__(self, v):
        _idaapi.switch_info_ex_t_set_custom(self, v)
    def __get_ind_lowcase__(self):
        return _idaapi.switch_info_ex_t_get_ind_lowcase(self)
    def __set_ind_lowcase__(self, v):
        _idaapi.switch_info_ex_t_set_ind_lowcase(self, v)
    def __get_values_lowcase__(self):
        return _idaapi.switch_info_ex_t_get_values_lowcase(self)
    def __set_values_lowcase__(self, v):
        _idaapi.switch_info_ex_t_set_values_lowcase(self, v)
    regdtyp = property(__get_regdtyp__, __set_regdtyp__)
    """
    size of the switch expression register as dtyp
    """
    flags2 = property(__get_flags2__, __set_flags2__)
    jcases = property(__get_jcases__, __set_jcases__)
    """
    number of entries in the jump table (SWI2_INDIRECT)
    """
    regnum = property(__get_regnum__, __set_regnum__)
    """
    the switch expression as a register number
    """
    flags = property(__get_flags__, __set_flags__)
    """
    the switch expression as a register number
    """
    ncases = property(__get_ncases__, __set_ncases__)
    """
    number of cases (excluding default)
    """
    defjump = property(__get_defjump__, __set_defjump__)
    """
    default jump address
    """
    jumps = property(__get_jumps__, __set_jumps__)
    """
    jump table address
    """
    elbase = property(__get_elbase__, __set_elbase__)
    """
    element base
    """
    startea = property(__get_startea__, __set_startea__)
    """
    start of switch idiom
    """
    custom = property(__get_custom__, __set_custom__)
    """
    information for custom tables (filled and used by modules)
    """
    ind_lowcase = property(__get_ind_lowcase__, __set_ind_lowcase__)
    values = property(__get_values_lowcase__, __set_values_lowcase__)
    lowcase = property(__get_values_lowcase__, __set_values_lowcase__)

#</pycode(py_nalt)>

NN_null = _idaapi.NN_null
NN_aaa = _idaapi.NN_aaa
NN_aad = _idaapi.NN_aad
NN_aam = _idaapi.NN_aam
NN_aas = _idaapi.NN_aas
NN_adc = _idaapi.NN_adc
NN_add = _idaapi.NN_add
NN_and = _idaapi.NN_and
NN_arpl = _idaapi.NN_arpl
NN_bound = _idaapi.NN_bound
NN_bsf = _idaapi.NN_bsf
NN_bsr = _idaapi.NN_bsr
NN_bt = _idaapi.NN_bt
NN_btc = _idaapi.NN_btc
NN_btr = _idaapi.NN_btr
NN_bts = _idaapi.NN_bts
NN_call = _idaapi.NN_call
NN_callfi = _idaapi.NN_callfi
NN_callni = _idaapi.NN_callni
NN_cbw = _idaapi.NN_cbw
NN_cwde = _idaapi.NN_cwde
NN_cdqe = _idaapi.NN_cdqe
NN_clc = _idaapi.NN_clc
NN_cld = _idaapi.NN_cld
NN_cli = _idaapi.NN_cli
NN_clts = _idaapi.NN_clts
NN_cmc = _idaapi.NN_cmc
NN_cmp = _idaapi.NN_cmp
NN_cmps = _idaapi.NN_cmps
NN_cwd = _idaapi.NN_cwd
NN_cdq = _idaapi.NN_cdq
NN_cqo = _idaapi.NN_cqo
NN_daa = _idaapi.NN_daa
NN_das = _idaapi.NN_das
NN_dec = _idaapi.NN_dec
NN_div = _idaapi.NN_div
NN_enterw = _idaapi.NN_enterw
NN_enter = _idaapi.NN_enter
NN_enterd = _idaapi.NN_enterd
NN_enterq = _idaapi.NN_enterq
NN_hlt = _idaapi.NN_hlt
NN_idiv = _idaapi.NN_idiv
NN_imul = _idaapi.NN_imul
NN_in = _idaapi.NN_in
NN_inc = _idaapi.NN_inc
NN_ins = _idaapi.NN_ins
NN_int = _idaapi.NN_int
NN_into = _idaapi.NN_into
NN_int3 = _idaapi.NN_int3
NN_iretw = _idaapi.NN_iretw
NN_iret = _idaapi.NN_iret
NN_iretd = _idaapi.NN_iretd
NN_iretq = _idaapi.NN_iretq
NN_ja = _idaapi.NN_ja
NN_jae = _idaapi.NN_jae
NN_jb = _idaapi.NN_jb
NN_jbe = _idaapi.NN_jbe
NN_jc = _idaapi.NN_jc
NN_jcxz = _idaapi.NN_jcxz
NN_jecxz = _idaapi.NN_jecxz
NN_jrcxz = _idaapi.NN_jrcxz
NN_je = _idaapi.NN_je
NN_jg = _idaapi.NN_jg
NN_jge = _idaapi.NN_jge
NN_jl = _idaapi.NN_jl
NN_jle = _idaapi.NN_jle
NN_jna = _idaapi.NN_jna
NN_jnae = _idaapi.NN_jnae
NN_jnb = _idaapi.NN_jnb
NN_jnbe = _idaapi.NN_jnbe
NN_jnc = _idaapi.NN_jnc
NN_jne = _idaapi.NN_jne
NN_jng = _idaapi.NN_jng
NN_jnge = _idaapi.NN_jnge
NN_jnl = _idaapi.NN_jnl
NN_jnle = _idaapi.NN_jnle
NN_jno = _idaapi.NN_jno
NN_jnp = _idaapi.NN_jnp
NN_jns = _idaapi.NN_jns
NN_jnz = _idaapi.NN_jnz
NN_jo = _idaapi.NN_jo
NN_jp = _idaapi.NN_jp
NN_jpe = _idaapi.NN_jpe
NN_jpo = _idaapi.NN_jpo
NN_js = _idaapi.NN_js
NN_jz = _idaapi.NN_jz
NN_jmp = _idaapi.NN_jmp
NN_jmpfi = _idaapi.NN_jmpfi
NN_jmpni = _idaapi.NN_jmpni
NN_jmpshort = _idaapi.NN_jmpshort
NN_lahf = _idaapi.NN_lahf
NN_lar = _idaapi.NN_lar
NN_lea = _idaapi.NN_lea
NN_leavew = _idaapi.NN_leavew
NN_leave = _idaapi.NN_leave
NN_leaved = _idaapi.NN_leaved
NN_leaveq = _idaapi.NN_leaveq
NN_lgdt = _idaapi.NN_lgdt
NN_lidt = _idaapi.NN_lidt
NN_lgs = _idaapi.NN_lgs
NN_lss = _idaapi.NN_lss
NN_lds = _idaapi.NN_lds
NN_les = _idaapi.NN_les
NN_lfs = _idaapi.NN_lfs
NN_lldt = _idaapi.NN_lldt
NN_lmsw = _idaapi.NN_lmsw
NN_lock = _idaapi.NN_lock
NN_lods = _idaapi.NN_lods
NN_loopw = _idaapi.NN_loopw
NN_loop = _idaapi.NN_loop
NN_loopd = _idaapi.NN_loopd
NN_loopq = _idaapi.NN_loopq
NN_loopwe = _idaapi.NN_loopwe
NN_loope = _idaapi.NN_loope
NN_loopde = _idaapi.NN_loopde
NN_loopqe = _idaapi.NN_loopqe
NN_loopwne = _idaapi.NN_loopwne
NN_loopne = _idaapi.NN_loopne
NN_loopdne = _idaapi.NN_loopdne
NN_loopqne = _idaapi.NN_loopqne
NN_lsl = _idaapi.NN_lsl
NN_ltr = _idaapi.NN_ltr
NN_mov = _idaapi.NN_mov
NN_movsp = _idaapi.NN_movsp
NN_movs = _idaapi.NN_movs
NN_movsx = _idaapi.NN_movsx
NN_movzx = _idaapi.NN_movzx
NN_mul = _idaapi.NN_mul
NN_neg = _idaapi.NN_neg
NN_nop = _idaapi.NN_nop
NN_not = _idaapi.NN_not
NN_or = _idaapi.NN_or
NN_out = _idaapi.NN_out
NN_outs = _idaapi.NN_outs
NN_pop = _idaapi.NN_pop
NN_popaw = _idaapi.NN_popaw
NN_popa = _idaapi.NN_popa
NN_popad = _idaapi.NN_popad
NN_popaq = _idaapi.NN_popaq
NN_popfw = _idaapi.NN_popfw
NN_popf = _idaapi.NN_popf
NN_popfd = _idaapi.NN_popfd
NN_popfq = _idaapi.NN_popfq
NN_push = _idaapi.NN_push
NN_pushaw = _idaapi.NN_pushaw
NN_pusha = _idaapi.NN_pusha
NN_pushad = _idaapi.NN_pushad
NN_pushaq = _idaapi.NN_pushaq
NN_pushfw = _idaapi.NN_pushfw
NN_pushf = _idaapi.NN_pushf
NN_pushfd = _idaapi.NN_pushfd
NN_pushfq = _idaapi.NN_pushfq
NN_rcl = _idaapi.NN_rcl
NN_rcr = _idaapi.NN_rcr
NN_rol = _idaapi.NN_rol
NN_ror = _idaapi.NN_ror
NN_rep = _idaapi.NN_rep
NN_repe = _idaapi.NN_repe
NN_repne = _idaapi.NN_repne
NN_retn = _idaapi.NN_retn
NN_retf = _idaapi.NN_retf
NN_sahf = _idaapi.NN_sahf
NN_sal = _idaapi.NN_sal
NN_sar = _idaapi.NN_sar
NN_shl = _idaapi.NN_shl
NN_shr = _idaapi.NN_shr
NN_sbb = _idaapi.NN_sbb
NN_scas = _idaapi.NN_scas
NN_seta = _idaapi.NN_seta
NN_setae = _idaapi.NN_setae
NN_setb = _idaapi.NN_setb
NN_setbe = _idaapi.NN_setbe
NN_setc = _idaapi.NN_setc
NN_sete = _idaapi.NN_sete
NN_setg = _idaapi.NN_setg
NN_setge = _idaapi.NN_setge
NN_setl = _idaapi.NN_setl
NN_setle = _idaapi.NN_setle
NN_setna = _idaapi.NN_setna
NN_setnae = _idaapi.NN_setnae
NN_setnb = _idaapi.NN_setnb
NN_setnbe = _idaapi.NN_setnbe
NN_setnc = _idaapi.NN_setnc
NN_setne = _idaapi.NN_setne
NN_setng = _idaapi.NN_setng
NN_setnge = _idaapi.NN_setnge
NN_setnl = _idaapi.NN_setnl
NN_setnle = _idaapi.NN_setnle
NN_setno = _idaapi.NN_setno
NN_setnp = _idaapi.NN_setnp
NN_setns = _idaapi.NN_setns
NN_setnz = _idaapi.NN_setnz
NN_seto = _idaapi.NN_seto
NN_setp = _idaapi.NN_setp
NN_setpe = _idaapi.NN_setpe
NN_setpo = _idaapi.NN_setpo
NN_sets = _idaapi.NN_sets
NN_setz = _idaapi.NN_setz
NN_sgdt = _idaapi.NN_sgdt
NN_sidt = _idaapi.NN_sidt
NN_shld = _idaapi.NN_shld
NN_shrd = _idaapi.NN_shrd
NN_sldt = _idaapi.NN_sldt
NN_smsw = _idaapi.NN_smsw
NN_stc = _idaapi.NN_stc
NN_std = _idaapi.NN_std
NN_sti = _idaapi.NN_sti
NN_stos = _idaapi.NN_stos
NN_str = _idaapi.NN_str
NN_sub = _idaapi.NN_sub
NN_test = _idaapi.NN_test
NN_verr = _idaapi.NN_verr
NN_verw = _idaapi.NN_verw
NN_wait = _idaapi.NN_wait
NN_xchg = _idaapi.NN_xchg
NN_xlat = _idaapi.NN_xlat
NN_xor = _idaapi.NN_xor
NN_cmpxchg = _idaapi.NN_cmpxchg
NN_bswap = _idaapi.NN_bswap
NN_xadd = _idaapi.NN_xadd
NN_invd = _idaapi.NN_invd
NN_wbinvd = _idaapi.NN_wbinvd
NN_invlpg = _idaapi.NN_invlpg
NN_rdmsr = _idaapi.NN_rdmsr
NN_wrmsr = _idaapi.NN_wrmsr
NN_cpuid = _idaapi.NN_cpuid
NN_cmpxchg8b = _idaapi.NN_cmpxchg8b
NN_rdtsc = _idaapi.NN_rdtsc
NN_rsm = _idaapi.NN_rsm
NN_cmova = _idaapi.NN_cmova
NN_cmovb = _idaapi.NN_cmovb
NN_cmovbe = _idaapi.NN_cmovbe
NN_cmovg = _idaapi.NN_cmovg
NN_cmovge = _idaapi.NN_cmovge
NN_cmovl = _idaapi.NN_cmovl
NN_cmovle = _idaapi.NN_cmovle
NN_cmovnb = _idaapi.NN_cmovnb
NN_cmovno = _idaapi.NN_cmovno
NN_cmovnp = _idaapi.NN_cmovnp
NN_cmovns = _idaapi.NN_cmovns
NN_cmovnz = _idaapi.NN_cmovnz
NN_cmovo = _idaapi.NN_cmovo
NN_cmovp = _idaapi.NN_cmovp
NN_cmovs = _idaapi.NN_cmovs
NN_cmovz = _idaapi.NN_cmovz
NN_fcmovb = _idaapi.NN_fcmovb
NN_fcmove = _idaapi.NN_fcmove
NN_fcmovbe = _idaapi.NN_fcmovbe
NN_fcmovu = _idaapi.NN_fcmovu
NN_fcmovnb = _idaapi.NN_fcmovnb
NN_fcmovne = _idaapi.NN_fcmovne
NN_fcmovnbe = _idaapi.NN_fcmovnbe
NN_fcmovnu = _idaapi.NN_fcmovnu
NN_fcomi = _idaapi.NN_fcomi
NN_fucomi = _idaapi.NN_fucomi
NN_fcomip = _idaapi.NN_fcomip
NN_fucomip = _idaapi.NN_fucomip
NN_rdpmc = _idaapi.NN_rdpmc
NN_fld = _idaapi.NN_fld
NN_fst = _idaapi.NN_fst
NN_fstp = _idaapi.NN_fstp
NN_fxch = _idaapi.NN_fxch
NN_fild = _idaapi.NN_fild
NN_fist = _idaapi.NN_fist
NN_fistp = _idaapi.NN_fistp
NN_fbld = _idaapi.NN_fbld
NN_fbstp = _idaapi.NN_fbstp
NN_fadd = _idaapi.NN_fadd
NN_faddp = _idaapi.NN_faddp
NN_fiadd = _idaapi.NN_fiadd
NN_fsub = _idaapi.NN_fsub
NN_fsubp = _idaapi.NN_fsubp
NN_fisub = _idaapi.NN_fisub
NN_fsubr = _idaapi.NN_fsubr
NN_fsubrp = _idaapi.NN_fsubrp
NN_fisubr = _idaapi.NN_fisubr
NN_fmul = _idaapi.NN_fmul
NN_fmulp = _idaapi.NN_fmulp
NN_fimul = _idaapi.NN_fimul
NN_fdiv = _idaapi.NN_fdiv
NN_fdivp = _idaapi.NN_fdivp
NN_fidiv = _idaapi.NN_fidiv
NN_fdivr = _idaapi.NN_fdivr
NN_fdivrp = _idaapi.NN_fdivrp
NN_fidivr = _idaapi.NN_fidivr
NN_fsqrt = _idaapi.NN_fsqrt
NN_fscale = _idaapi.NN_fscale
NN_fprem = _idaapi.NN_fprem
NN_frndint = _idaapi.NN_frndint
NN_fxtract = _idaapi.NN_fxtract
NN_fabs = _idaapi.NN_fabs
NN_fchs = _idaapi.NN_fchs
NN_fcom = _idaapi.NN_fcom
NN_fcomp = _idaapi.NN_fcomp
NN_fcompp = _idaapi.NN_fcompp
NN_ficom = _idaapi.NN_ficom
NN_ficomp = _idaapi.NN_ficomp
NN_ftst = _idaapi.NN_ftst
NN_fxam = _idaapi.NN_fxam
NN_fptan = _idaapi.NN_fptan
NN_fpatan = _idaapi.NN_fpatan
NN_f2xm1 = _idaapi.NN_f2xm1
NN_fyl2x = _idaapi.NN_fyl2x
NN_fyl2xp1 = _idaapi.NN_fyl2xp1
NN_fldz = _idaapi.NN_fldz
NN_fld1 = _idaapi.NN_fld1
NN_fldpi = _idaapi.NN_fldpi
NN_fldl2t = _idaapi.NN_fldl2t
NN_fldl2e = _idaapi.NN_fldl2e
NN_fldlg2 = _idaapi.NN_fldlg2
NN_fldln2 = _idaapi.NN_fldln2
NN_finit = _idaapi.NN_finit
NN_fninit = _idaapi.NN_fninit
NN_fsetpm = _idaapi.NN_fsetpm
NN_fldcw = _idaapi.NN_fldcw
NN_fstcw = _idaapi.NN_fstcw
NN_fnstcw = _idaapi.NN_fnstcw
NN_fstsw = _idaapi.NN_fstsw
NN_fnstsw = _idaapi.NN_fnstsw
NN_fclex = _idaapi.NN_fclex
NN_fnclex = _idaapi.NN_fnclex
NN_fstenv = _idaapi.NN_fstenv
NN_fnstenv = _idaapi.NN_fnstenv
NN_fldenv = _idaapi.NN_fldenv
NN_fsave = _idaapi.NN_fsave
NN_fnsave = _idaapi.NN_fnsave
NN_frstor = _idaapi.NN_frstor
NN_fincstp = _idaapi.NN_fincstp
NN_fdecstp = _idaapi.NN_fdecstp
NN_ffree = _idaapi.NN_ffree
NN_fnop = _idaapi.NN_fnop
NN_feni = _idaapi.NN_feni
NN_fneni = _idaapi.NN_fneni
NN_fdisi = _idaapi.NN_fdisi
NN_fndisi = _idaapi.NN_fndisi
NN_fprem1 = _idaapi.NN_fprem1
NN_fsincos = _idaapi.NN_fsincos
NN_fsin = _idaapi.NN_fsin
NN_fcos = _idaapi.NN_fcos
NN_fucom = _idaapi.NN_fucom
NN_fucomp = _idaapi.NN_fucomp
NN_fucompp = _idaapi.NN_fucompp
NN_setalc = _idaapi.NN_setalc
NN_svdc = _idaapi.NN_svdc
NN_rsdc = _idaapi.NN_rsdc
NN_svldt = _idaapi.NN_svldt
NN_rsldt = _idaapi.NN_rsldt
NN_svts = _idaapi.NN_svts
NN_rsts = _idaapi.NN_rsts
NN_icebp = _idaapi.NN_icebp
NN_loadall = _idaapi.NN_loadall
NN_emms = _idaapi.NN_emms
NN_movd = _idaapi.NN_movd
NN_movq = _idaapi.NN_movq
NN_packsswb = _idaapi.NN_packsswb
NN_packssdw = _idaapi.NN_packssdw
NN_packuswb = _idaapi.NN_packuswb
NN_paddb = _idaapi.NN_paddb
NN_paddw = _idaapi.NN_paddw
NN_paddd = _idaapi.NN_paddd
NN_paddsb = _idaapi.NN_paddsb
NN_paddsw = _idaapi.NN_paddsw
NN_paddusb = _idaapi.NN_paddusb
NN_paddusw = _idaapi.NN_paddusw
NN_pand = _idaapi.NN_pand
NN_pandn = _idaapi.NN_pandn
NN_pcmpeqb = _idaapi.NN_pcmpeqb
NN_pcmpeqw = _idaapi.NN_pcmpeqw
NN_pcmpeqd = _idaapi.NN_pcmpeqd
NN_pcmpgtb = _idaapi.NN_pcmpgtb
NN_pcmpgtw = _idaapi.NN_pcmpgtw
NN_pcmpgtd = _idaapi.NN_pcmpgtd
NN_pmaddwd = _idaapi.NN_pmaddwd
NN_pmulhw = _idaapi.NN_pmulhw
NN_pmullw = _idaapi.NN_pmullw
NN_por = _idaapi.NN_por
NN_psllw = _idaapi.NN_psllw
NN_pslld = _idaapi.NN_pslld
NN_psllq = _idaapi.NN_psllq
NN_psraw = _idaapi.NN_psraw
NN_psrad = _idaapi.NN_psrad
NN_psrlw = _idaapi.NN_psrlw
NN_psrld = _idaapi.NN_psrld
NN_psrlq = _idaapi.NN_psrlq
NN_psubb = _idaapi.NN_psubb
NN_psubw = _idaapi.NN_psubw
NN_psubd = _idaapi.NN_psubd
NN_psubsb = _idaapi.NN_psubsb
NN_psubsw = _idaapi.NN_psubsw
NN_psubusb = _idaapi.NN_psubusb
NN_psubusw = _idaapi.NN_psubusw
NN_punpckhbw = _idaapi.NN_punpckhbw
NN_punpckhwd = _idaapi.NN_punpckhwd
NN_punpckhdq = _idaapi.NN_punpckhdq
NN_punpcklbw = _idaapi.NN_punpcklbw
NN_punpcklwd = _idaapi.NN_punpcklwd
NN_punpckldq = _idaapi.NN_punpckldq
NN_pxor = _idaapi.NN_pxor
NN_fxsave = _idaapi.NN_fxsave
NN_fxrstor = _idaapi.NN_fxrstor
NN_sysenter = _idaapi.NN_sysenter
NN_sysexit = _idaapi.NN_sysexit
NN_pavgusb = _idaapi.NN_pavgusb
NN_pfadd = _idaapi.NN_pfadd
NN_pfsub = _idaapi.NN_pfsub
NN_pfsubr = _idaapi.NN_pfsubr
NN_pfacc = _idaapi.NN_pfacc
NN_pfcmpge = _idaapi.NN_pfcmpge
NN_pfcmpgt = _idaapi.NN_pfcmpgt
NN_pfcmpeq = _idaapi.NN_pfcmpeq
NN_pfmin = _idaapi.NN_pfmin
NN_pfmax = _idaapi.NN_pfmax
NN_pi2fd = _idaapi.NN_pi2fd
NN_pf2id = _idaapi.NN_pf2id
NN_pfrcp = _idaapi.NN_pfrcp
NN_pfrsqrt = _idaapi.NN_pfrsqrt
NN_pfmul = _idaapi.NN_pfmul
NN_pfrcpit1 = _idaapi.NN_pfrcpit1
NN_pfrsqit1 = _idaapi.NN_pfrsqit1
NN_pfrcpit2 = _idaapi.NN_pfrcpit2
NN_pmulhrw = _idaapi.NN_pmulhrw
NN_femms = _idaapi.NN_femms
NN_prefetch = _idaapi.NN_prefetch
NN_prefetchw = _idaapi.NN_prefetchw
NN_addps = _idaapi.NN_addps
NN_addss = _idaapi.NN_addss
NN_andnps = _idaapi.NN_andnps
NN_andps = _idaapi.NN_andps
NN_cmpps = _idaapi.NN_cmpps
NN_cmpss = _idaapi.NN_cmpss
NN_comiss = _idaapi.NN_comiss
NN_cvtpi2ps = _idaapi.NN_cvtpi2ps
NN_cvtps2pi = _idaapi.NN_cvtps2pi
NN_cvtsi2ss = _idaapi.NN_cvtsi2ss
NN_cvtss2si = _idaapi.NN_cvtss2si
NN_cvttps2pi = _idaapi.NN_cvttps2pi
NN_cvttss2si = _idaapi.NN_cvttss2si
NN_divps = _idaapi.NN_divps
NN_divss = _idaapi.NN_divss
NN_ldmxcsr = _idaapi.NN_ldmxcsr
NN_maxps = _idaapi.NN_maxps
NN_maxss = _idaapi.NN_maxss
NN_minps = _idaapi.NN_minps
NN_minss = _idaapi.NN_minss
NN_movaps = _idaapi.NN_movaps
NN_movhlps = _idaapi.NN_movhlps
NN_movhps = _idaapi.NN_movhps
NN_movlhps = _idaapi.NN_movlhps
NN_movlps = _idaapi.NN_movlps
NN_movmskps = _idaapi.NN_movmskps
NN_movss = _idaapi.NN_movss
NN_movups = _idaapi.NN_movups
NN_mulps = _idaapi.NN_mulps
NN_mulss = _idaapi.NN_mulss
NN_orps = _idaapi.NN_orps
NN_rcpps = _idaapi.NN_rcpps
NN_rcpss = _idaapi.NN_rcpss
NN_rsqrtps = _idaapi.NN_rsqrtps
NN_rsqrtss = _idaapi.NN_rsqrtss
NN_shufps = _idaapi.NN_shufps
NN_sqrtps = _idaapi.NN_sqrtps
NN_sqrtss = _idaapi.NN_sqrtss
NN_stmxcsr = _idaapi.NN_stmxcsr
NN_subps = _idaapi.NN_subps
NN_subss = _idaapi.NN_subss
NN_ucomiss = _idaapi.NN_ucomiss
NN_unpckhps = _idaapi.NN_unpckhps
NN_unpcklps = _idaapi.NN_unpcklps
NN_xorps = _idaapi.NN_xorps
NN_pavgb = _idaapi.NN_pavgb
NN_pavgw = _idaapi.NN_pavgw
NN_pextrw = _idaapi.NN_pextrw
NN_pinsrw = _idaapi.NN_pinsrw
NN_pmaxsw = _idaapi.NN_pmaxsw
NN_pmaxub = _idaapi.NN_pmaxub
NN_pminsw = _idaapi.NN_pminsw
NN_pminub = _idaapi.NN_pminub
NN_pmovmskb = _idaapi.NN_pmovmskb
NN_pmulhuw = _idaapi.NN_pmulhuw
NN_psadbw = _idaapi.NN_psadbw
NN_pshufw = _idaapi.NN_pshufw
NN_maskmovq = _idaapi.NN_maskmovq
NN_movntps = _idaapi.NN_movntps
NN_movntq = _idaapi.NN_movntq
NN_prefetcht0 = _idaapi.NN_prefetcht0
NN_prefetcht1 = _idaapi.NN_prefetcht1
NN_prefetcht2 = _idaapi.NN_prefetcht2
NN_prefetchnta = _idaapi.NN_prefetchnta
NN_sfence = _idaapi.NN_sfence
NN_cmpeqps = _idaapi.NN_cmpeqps
NN_cmpltps = _idaapi.NN_cmpltps
NN_cmpleps = _idaapi.NN_cmpleps
NN_cmpunordps = _idaapi.NN_cmpunordps
NN_cmpneqps = _idaapi.NN_cmpneqps
NN_cmpnltps = _idaapi.NN_cmpnltps
NN_cmpnleps = _idaapi.NN_cmpnleps
NN_cmpordps = _idaapi.NN_cmpordps
NN_cmpeqss = _idaapi.NN_cmpeqss
NN_cmpltss = _idaapi.NN_cmpltss
NN_cmpless = _idaapi.NN_cmpless
NN_cmpunordss = _idaapi.NN_cmpunordss
NN_cmpneqss = _idaapi.NN_cmpneqss
NN_cmpnltss = _idaapi.NN_cmpnltss
NN_cmpnless = _idaapi.NN_cmpnless
NN_cmpordss = _idaapi.NN_cmpordss
NN_pf2iw = _idaapi.NN_pf2iw
NN_pfnacc = _idaapi.NN_pfnacc
NN_pfpnacc = _idaapi.NN_pfpnacc
NN_pi2fw = _idaapi.NN_pi2fw
NN_pswapd = _idaapi.NN_pswapd
NN_fstp1 = _idaapi.NN_fstp1
NN_fcom2 = _idaapi.NN_fcom2
NN_fcomp3 = _idaapi.NN_fcomp3
NN_fxch4 = _idaapi.NN_fxch4
NN_fcomp5 = _idaapi.NN_fcomp5
NN_ffreep = _idaapi.NN_ffreep
NN_fxch7 = _idaapi.NN_fxch7
NN_fstp8 = _idaapi.NN_fstp8
NN_fstp9 = _idaapi.NN_fstp9
NN_addpd = _idaapi.NN_addpd
NN_addsd = _idaapi.NN_addsd
NN_andnpd = _idaapi.NN_andnpd
NN_andpd = _idaapi.NN_andpd
NN_clflush = _idaapi.NN_clflush
NN_cmppd = _idaapi.NN_cmppd
NN_cmpsd = _idaapi.NN_cmpsd
NN_comisd = _idaapi.NN_comisd
NN_cvtdq2pd = _idaapi.NN_cvtdq2pd
NN_cvtdq2ps = _idaapi.NN_cvtdq2ps
NN_cvtpd2dq = _idaapi.NN_cvtpd2dq
NN_cvtpd2pi = _idaapi.NN_cvtpd2pi
NN_cvtpd2ps = _idaapi.NN_cvtpd2ps
NN_cvtpi2pd = _idaapi.NN_cvtpi2pd
NN_cvtps2dq = _idaapi.NN_cvtps2dq
NN_cvtps2pd = _idaapi.NN_cvtps2pd
NN_cvtsd2si = _idaapi.NN_cvtsd2si
NN_cvtsd2ss = _idaapi.NN_cvtsd2ss
NN_cvtsi2sd = _idaapi.NN_cvtsi2sd
NN_cvtss2sd = _idaapi.NN_cvtss2sd
NN_cvttpd2dq = _idaapi.NN_cvttpd2dq
NN_cvttpd2pi = _idaapi.NN_cvttpd2pi
NN_cvttps2dq = _idaapi.NN_cvttps2dq
NN_cvttsd2si = _idaapi.NN_cvttsd2si
NN_divpd = _idaapi.NN_divpd
NN_divsd = _idaapi.NN_divsd
NN_lfence = _idaapi.NN_lfence
NN_maskmovdqu = _idaapi.NN_maskmovdqu
NN_maxpd = _idaapi.NN_maxpd
NN_maxsd = _idaapi.NN_maxsd
NN_mfence = _idaapi.NN_mfence
NN_minpd = _idaapi.NN_minpd
NN_minsd = _idaapi.NN_minsd
NN_movapd = _idaapi.NN_movapd
NN_movdq2q = _idaapi.NN_movdq2q
NN_movdqa = _idaapi.NN_movdqa
NN_movdqu = _idaapi.NN_movdqu
NN_movhpd = _idaapi.NN_movhpd
NN_movlpd = _idaapi.NN_movlpd
NN_movmskpd = _idaapi.NN_movmskpd
NN_movntdq = _idaapi.NN_movntdq
NN_movnti = _idaapi.NN_movnti
NN_movntpd = _idaapi.NN_movntpd
NN_movq2dq = _idaapi.NN_movq2dq
NN_movsd = _idaapi.NN_movsd
NN_movupd = _idaapi.NN_movupd
NN_mulpd = _idaapi.NN_mulpd
NN_mulsd = _idaapi.NN_mulsd
NN_orpd = _idaapi.NN_orpd
NN_paddq = _idaapi.NN_paddq
NN_pause = _idaapi.NN_pause
NN_pmuludq = _idaapi.NN_pmuludq
NN_pshufd = _idaapi.NN_pshufd
NN_pshufhw = _idaapi.NN_pshufhw
NN_pshuflw = _idaapi.NN_pshuflw
NN_pslldq = _idaapi.NN_pslldq
NN_psrldq = _idaapi.NN_psrldq
NN_psubq = _idaapi.NN_psubq
NN_punpckhqdq = _idaapi.NN_punpckhqdq
NN_punpcklqdq = _idaapi.NN_punpcklqdq
NN_shufpd = _idaapi.NN_shufpd
NN_sqrtpd = _idaapi.NN_sqrtpd
NN_sqrtsd = _idaapi.NN_sqrtsd
NN_subpd = _idaapi.NN_subpd
NN_subsd = _idaapi.NN_subsd
NN_ucomisd = _idaapi.NN_ucomisd
NN_unpckhpd = _idaapi.NN_unpckhpd
NN_unpcklpd = _idaapi.NN_unpcklpd
NN_xorpd = _idaapi.NN_xorpd
NN_syscall = _idaapi.NN_syscall
NN_sysret = _idaapi.NN_sysret
NN_swapgs = _idaapi.NN_swapgs
NN_movddup = _idaapi.NN_movddup
NN_movshdup = _idaapi.NN_movshdup
NN_movsldup = _idaapi.NN_movsldup
NN_movsxd = _idaapi.NN_movsxd
NN_cmpxchg16b = _idaapi.NN_cmpxchg16b
NN_addsubpd = _idaapi.NN_addsubpd
NN_addsubps = _idaapi.NN_addsubps
NN_haddpd = _idaapi.NN_haddpd
NN_haddps = _idaapi.NN_haddps
NN_hsubpd = _idaapi.NN_hsubpd
NN_hsubps = _idaapi.NN_hsubps
NN_monitor = _idaapi.NN_monitor
NN_mwait = _idaapi.NN_mwait
NN_fisttp = _idaapi.NN_fisttp
NN_lddqu = _idaapi.NN_lddqu
NN_psignb = _idaapi.NN_psignb
NN_psignw = _idaapi.NN_psignw
NN_psignd = _idaapi.NN_psignd
NN_pshufb = _idaapi.NN_pshufb
NN_pmulhrsw = _idaapi.NN_pmulhrsw
NN_pmaddubsw = _idaapi.NN_pmaddubsw
NN_phsubsw = _idaapi.NN_phsubsw
NN_phaddsw = _idaapi.NN_phaddsw
NN_phaddw = _idaapi.NN_phaddw
NN_phaddd = _idaapi.NN_phaddd
NN_phsubw = _idaapi.NN_phsubw
NN_phsubd = _idaapi.NN_phsubd
NN_palignr = _idaapi.NN_palignr
NN_pabsb = _idaapi.NN_pabsb
NN_pabsw = _idaapi.NN_pabsw
NN_pabsd = _idaapi.NN_pabsd
NN_vmcall = _idaapi.NN_vmcall
NN_vmclear = _idaapi.NN_vmclear
NN_vmlaunch = _idaapi.NN_vmlaunch
NN_vmresume = _idaapi.NN_vmresume
NN_vmptrld = _idaapi.NN_vmptrld
NN_vmptrst = _idaapi.NN_vmptrst
NN_vmread = _idaapi.NN_vmread
NN_vmwrite = _idaapi.NN_vmwrite
NN_vmxoff = _idaapi.NN_vmxoff
NN_vmxon = _idaapi.NN_vmxon
NN_ud2 = _idaapi.NN_ud2
NN_rdtscp = _idaapi.NN_rdtscp
NN_pfrcpv = _idaapi.NN_pfrcpv
NN_pfrsqrtv = _idaapi.NN_pfrsqrtv
NN_cmpeqpd = _idaapi.NN_cmpeqpd
NN_cmpltpd = _idaapi.NN_cmpltpd
NN_cmplepd = _idaapi.NN_cmplepd
NN_cmpunordpd = _idaapi.NN_cmpunordpd
NN_cmpneqpd = _idaapi.NN_cmpneqpd
NN_cmpnltpd = _idaapi.NN_cmpnltpd
NN_cmpnlepd = _idaapi.NN_cmpnlepd
NN_cmpordpd = _idaapi.NN_cmpordpd
NN_cmpeqsd = _idaapi.NN_cmpeqsd
NN_cmpltsd = _idaapi.NN_cmpltsd
NN_cmplesd = _idaapi.NN_cmplesd
NN_cmpunordsd = _idaapi.NN_cmpunordsd
NN_cmpneqsd = _idaapi.NN_cmpneqsd
NN_cmpnltsd = _idaapi.NN_cmpnltsd
NN_cmpnlesd = _idaapi.NN_cmpnlesd
NN_cmpordsd = _idaapi.NN_cmpordsd
NN_blendpd = _idaapi.NN_blendpd
NN_blendps = _idaapi.NN_blendps
NN_blendvpd = _idaapi.NN_blendvpd
NN_blendvps = _idaapi.NN_blendvps
NN_dppd = _idaapi.NN_dppd
NN_dpps = _idaapi.NN_dpps
NN_extractps = _idaapi.NN_extractps
NN_insertps = _idaapi.NN_insertps
NN_movntdqa = _idaapi.NN_movntdqa
NN_mpsadbw = _idaapi.NN_mpsadbw
NN_packusdw = _idaapi.NN_packusdw
NN_pblendvb = _idaapi.NN_pblendvb
NN_pblendw = _idaapi.NN_pblendw
NN_pcmpeqq = _idaapi.NN_pcmpeqq
NN_pextrb = _idaapi.NN_pextrb
NN_pextrd = _idaapi.NN_pextrd
NN_pextrq = _idaapi.NN_pextrq
NN_phminposuw = _idaapi.NN_phminposuw
NN_pinsrb = _idaapi.NN_pinsrb
NN_pinsrd = _idaapi.NN_pinsrd
NN_pinsrq = _idaapi.NN_pinsrq
NN_pmaxsb = _idaapi.NN_pmaxsb
NN_pmaxsd = _idaapi.NN_pmaxsd
NN_pmaxud = _idaapi.NN_pmaxud
NN_pmaxuw = _idaapi.NN_pmaxuw
NN_pminsb = _idaapi.NN_pminsb
NN_pminsd = _idaapi.NN_pminsd
NN_pminud = _idaapi.NN_pminud
NN_pminuw = _idaapi.NN_pminuw
NN_pmovsxbw = _idaapi.NN_pmovsxbw
NN_pmovsxbd = _idaapi.NN_pmovsxbd
NN_pmovsxbq = _idaapi.NN_pmovsxbq
NN_pmovsxwd = _idaapi.NN_pmovsxwd
NN_pmovsxwq = _idaapi.NN_pmovsxwq
NN_pmovsxdq = _idaapi.NN_pmovsxdq
NN_pmovzxbw = _idaapi.NN_pmovzxbw
NN_pmovzxbd = _idaapi.NN_pmovzxbd
NN_pmovzxbq = _idaapi.NN_pmovzxbq
NN_pmovzxwd = _idaapi.NN_pmovzxwd
NN_pmovzxwq = _idaapi.NN_pmovzxwq
NN_pmovzxdq = _idaapi.NN_pmovzxdq
NN_pmuldq = _idaapi.NN_pmuldq
NN_pmulld = _idaapi.NN_pmulld
NN_ptest = _idaapi.NN_ptest
NN_roundpd = _idaapi.NN_roundpd
NN_roundps = _idaapi.NN_roundps
NN_roundsd = _idaapi.NN_roundsd
NN_roundss = _idaapi.NN_roundss
NN_crc32 = _idaapi.NN_crc32
NN_pcmpestri = _idaapi.NN_pcmpestri
NN_pcmpestrm = _idaapi.NN_pcmpestrm
NN_pcmpistri = _idaapi.NN_pcmpistri
NN_pcmpistrm = _idaapi.NN_pcmpistrm
NN_pcmpgtq = _idaapi.NN_pcmpgtq
NN_popcnt = _idaapi.NN_popcnt
NN_extrq = _idaapi.NN_extrq
NN_insertq = _idaapi.NN_insertq
NN_movntsd = _idaapi.NN_movntsd
NN_movntss = _idaapi.NN_movntss
NN_lzcnt = _idaapi.NN_lzcnt
NN_xgetbv = _idaapi.NN_xgetbv
NN_xrstor = _idaapi.NN_xrstor
NN_xsave = _idaapi.NN_xsave
NN_xsetbv = _idaapi.NN_xsetbv
NN_getsec = _idaapi.NN_getsec
NN_clgi = _idaapi.NN_clgi
NN_invlpga = _idaapi.NN_invlpga
NN_skinit = _idaapi.NN_skinit
NN_stgi = _idaapi.NN_stgi
NN_vmexit = _idaapi.NN_vmexit
NN_vmload = _idaapi.NN_vmload
NN_vmmcall = _idaapi.NN_vmmcall
NN_vmrun = _idaapi.NN_vmrun
NN_vmsave = _idaapi.NN_vmsave
NN_invept = _idaapi.NN_invept
NN_invvpid = _idaapi.NN_invvpid
NN_movbe = _idaapi.NN_movbe
NN_aesenc = _idaapi.NN_aesenc
NN_aesenclast = _idaapi.NN_aesenclast
NN_aesdec = _idaapi.NN_aesdec
NN_aesdeclast = _idaapi.NN_aesdeclast
NN_aesimc = _idaapi.NN_aesimc
NN_aeskeygenassist = _idaapi.NN_aeskeygenassist
NN_pclmulqdq = _idaapi.NN_pclmulqdq
NN_retnw = _idaapi.NN_retnw
NN_retnd = _idaapi.NN_retnd
NN_retnq = _idaapi.NN_retnq
NN_retfw = _idaapi.NN_retfw
NN_retfd = _idaapi.NN_retfd
NN_retfq = _idaapi.NN_retfq
NN_rdrand = _idaapi.NN_rdrand
NN_adcx = _idaapi.NN_adcx
NN_adox = _idaapi.NN_adox
NN_andn = _idaapi.NN_andn
NN_bextr = _idaapi.NN_bextr
NN_blsi = _idaapi.NN_blsi
NN_blsmsk = _idaapi.NN_blsmsk
NN_blsr = _idaapi.NN_blsr
NN_bzhi = _idaapi.NN_bzhi
NN_clac = _idaapi.NN_clac
NN_mulx = _idaapi.NN_mulx
NN_pdep = _idaapi.NN_pdep
NN_pext = _idaapi.NN_pext
NN_rorx = _idaapi.NN_rorx
NN_sarx = _idaapi.NN_sarx
NN_shlx = _idaapi.NN_shlx
NN_shrx = _idaapi.NN_shrx
NN_stac = _idaapi.NN_stac
NN_tzcnt = _idaapi.NN_tzcnt
NN_xsaveopt = _idaapi.NN_xsaveopt
NN_invpcid = _idaapi.NN_invpcid
NN_rdseed = _idaapi.NN_rdseed
NN_rdfsbase = _idaapi.NN_rdfsbase
NN_rdgsbase = _idaapi.NN_rdgsbase
NN_wrfsbase = _idaapi.NN_wrfsbase
NN_wrgsbase = _idaapi.NN_wrgsbase
NN_vaddpd = _idaapi.NN_vaddpd
NN_vaddps = _idaapi.NN_vaddps
NN_vaddsd = _idaapi.NN_vaddsd
NN_vaddss = _idaapi.NN_vaddss
NN_vaddsubpd = _idaapi.NN_vaddsubpd
NN_vaddsubps = _idaapi.NN_vaddsubps
NN_vaesdec = _idaapi.NN_vaesdec
NN_vaesdeclast = _idaapi.NN_vaesdeclast
NN_vaesenc = _idaapi.NN_vaesenc
NN_vaesenclast = _idaapi.NN_vaesenclast
NN_vaesimc = _idaapi.NN_vaesimc
NN_vaeskeygenassist = _idaapi.NN_vaeskeygenassist
NN_vandnpd = _idaapi.NN_vandnpd
NN_vandnps = _idaapi.NN_vandnps
NN_vandpd = _idaapi.NN_vandpd
NN_vandps = _idaapi.NN_vandps
NN_vblendpd = _idaapi.NN_vblendpd
NN_vblendps = _idaapi.NN_vblendps
NN_vblendvpd = _idaapi.NN_vblendvpd
NN_vblendvps = _idaapi.NN_vblendvps
NN_vbroadcastf128 = _idaapi.NN_vbroadcastf128
NN_vbroadcasti128 = _idaapi.NN_vbroadcasti128
NN_vbroadcastsd = _idaapi.NN_vbroadcastsd
NN_vbroadcastss = _idaapi.NN_vbroadcastss
NN_vcmppd = _idaapi.NN_vcmppd
NN_vcmpps = _idaapi.NN_vcmpps
NN_vcmpsd = _idaapi.NN_vcmpsd
NN_vcmpss = _idaapi.NN_vcmpss
NN_vcomisd = _idaapi.NN_vcomisd
NN_vcomiss = _idaapi.NN_vcomiss
NN_vcvtdq2pd = _idaapi.NN_vcvtdq2pd
NN_vcvtdq2ps = _idaapi.NN_vcvtdq2ps
NN_vcvtpd2dq = _idaapi.NN_vcvtpd2dq
NN_vcvtpd2ps = _idaapi.NN_vcvtpd2ps
NN_vcvtph2ps = _idaapi.NN_vcvtph2ps
NN_vcvtps2dq = _idaapi.NN_vcvtps2dq
NN_vcvtps2pd = _idaapi.NN_vcvtps2pd
NN_vcvtps2ph = _idaapi.NN_vcvtps2ph
NN_vcvtsd2si = _idaapi.NN_vcvtsd2si
NN_vcvtsd2ss = _idaapi.NN_vcvtsd2ss
NN_vcvtsi2sd = _idaapi.NN_vcvtsi2sd
NN_vcvtsi2ss = _idaapi.NN_vcvtsi2ss
NN_vcvtss2sd = _idaapi.NN_vcvtss2sd
NN_vcvtss2si = _idaapi.NN_vcvtss2si
NN_vcvttpd2dq = _idaapi.NN_vcvttpd2dq
NN_vcvttps2dq = _idaapi.NN_vcvttps2dq
NN_vcvttsd2si = _idaapi.NN_vcvttsd2si
NN_vcvttss2si = _idaapi.NN_vcvttss2si
NN_vdivpd = _idaapi.NN_vdivpd
NN_vdivps = _idaapi.NN_vdivps
NN_vdivsd = _idaapi.NN_vdivsd
NN_vdivss = _idaapi.NN_vdivss
NN_vdppd = _idaapi.NN_vdppd
NN_vdpps = _idaapi.NN_vdpps
NN_vextractf128 = _idaapi.NN_vextractf128
NN_vextracti128 = _idaapi.NN_vextracti128
NN_vextractps = _idaapi.NN_vextractps
NN_vfmadd132pd = _idaapi.NN_vfmadd132pd
NN_vfmadd132ps = _idaapi.NN_vfmadd132ps
NN_vfmadd132sd = _idaapi.NN_vfmadd132sd
NN_vfmadd132ss = _idaapi.NN_vfmadd132ss
NN_vfmadd213pd = _idaapi.NN_vfmadd213pd
NN_vfmadd213ps = _idaapi.NN_vfmadd213ps
NN_vfmadd213sd = _idaapi.NN_vfmadd213sd
NN_vfmadd213ss = _idaapi.NN_vfmadd213ss
NN_vfmadd231pd = _idaapi.NN_vfmadd231pd
NN_vfmadd231ps = _idaapi.NN_vfmadd231ps
NN_vfmadd231sd = _idaapi.NN_vfmadd231sd
NN_vfmadd231ss = _idaapi.NN_vfmadd231ss
NN_vfmaddsub132pd = _idaapi.NN_vfmaddsub132pd
NN_vfmaddsub132ps = _idaapi.NN_vfmaddsub132ps
NN_vfmaddsub213pd = _idaapi.NN_vfmaddsub213pd
NN_vfmaddsub213ps = _idaapi.NN_vfmaddsub213ps
NN_vfmaddsub231pd = _idaapi.NN_vfmaddsub231pd
NN_vfmaddsub231ps = _idaapi.NN_vfmaddsub231ps
NN_vfmsub132pd = _idaapi.NN_vfmsub132pd
NN_vfmsub132ps = _idaapi.NN_vfmsub132ps
NN_vfmsub132sd = _idaapi.NN_vfmsub132sd
NN_vfmsub132ss = _idaapi.NN_vfmsub132ss
NN_vfmsub213pd = _idaapi.NN_vfmsub213pd
NN_vfmsub213ps = _idaapi.NN_vfmsub213ps
NN_vfmsub213sd = _idaapi.NN_vfmsub213sd
NN_vfmsub213ss = _idaapi.NN_vfmsub213ss
NN_vfmsub231pd = _idaapi.NN_vfmsub231pd
NN_vfmsub231ps = _idaapi.NN_vfmsub231ps
NN_vfmsub231sd = _idaapi.NN_vfmsub231sd
NN_vfmsub231ss = _idaapi.NN_vfmsub231ss
NN_vfmsubadd132pd = _idaapi.NN_vfmsubadd132pd
NN_vfmsubadd132ps = _idaapi.NN_vfmsubadd132ps
NN_vfmsubadd213pd = _idaapi.NN_vfmsubadd213pd
NN_vfmsubadd213ps = _idaapi.NN_vfmsubadd213ps
NN_vfmsubadd231pd = _idaapi.NN_vfmsubadd231pd
NN_vfmsubadd231ps = _idaapi.NN_vfmsubadd231ps
NN_vfnmadd132pd = _idaapi.NN_vfnmadd132pd
NN_vfnmadd132ps = _idaapi.NN_vfnmadd132ps
NN_vfnmadd132sd = _idaapi.NN_vfnmadd132sd
NN_vfnmadd132ss = _idaapi.NN_vfnmadd132ss
NN_vfnmadd213pd = _idaapi.NN_vfnmadd213pd
NN_vfnmadd213ps = _idaapi.NN_vfnmadd213ps
NN_vfnmadd213sd = _idaapi.NN_vfnmadd213sd
NN_vfnmadd213ss = _idaapi.NN_vfnmadd213ss
NN_vfnmadd231pd = _idaapi.NN_vfnmadd231pd
NN_vfnmadd231ps = _idaapi.NN_vfnmadd231ps
NN_vfnmadd231sd = _idaapi.NN_vfnmadd231sd
NN_vfnmadd231ss = _idaapi.NN_vfnmadd231ss
NN_vfnmsub132pd = _idaapi.NN_vfnmsub132pd
NN_vfnmsub132ps = _idaapi.NN_vfnmsub132ps
NN_vfnmsub132sd = _idaapi.NN_vfnmsub132sd
NN_vfnmsub132ss = _idaapi.NN_vfnmsub132ss
NN_vfnmsub213pd = _idaapi.NN_vfnmsub213pd
NN_vfnmsub213ps = _idaapi.NN_vfnmsub213ps
NN_vfnmsub213sd = _idaapi.NN_vfnmsub213sd
NN_vfnmsub213ss = _idaapi.NN_vfnmsub213ss
NN_vfnmsub231pd = _idaapi.NN_vfnmsub231pd
NN_vfnmsub231ps = _idaapi.NN_vfnmsub231ps
NN_vfnmsub231sd = _idaapi.NN_vfnmsub231sd
NN_vfnmsub231ss = _idaapi.NN_vfnmsub231ss
NN_vgatherdps = _idaapi.NN_vgatherdps
NN_vgatherdpd = _idaapi.NN_vgatherdpd
NN_vgatherqps = _idaapi.NN_vgatherqps
NN_vgatherqpd = _idaapi.NN_vgatherqpd
NN_vhaddpd = _idaapi.NN_vhaddpd
NN_vhaddps = _idaapi.NN_vhaddps
NN_vhsubpd = _idaapi.NN_vhsubpd
NN_vhsubps = _idaapi.NN_vhsubps
NN_vinsertf128 = _idaapi.NN_vinsertf128
NN_vinserti128 = _idaapi.NN_vinserti128
NN_vinsertps = _idaapi.NN_vinsertps
NN_vlddqu = _idaapi.NN_vlddqu
NN_vldmxcsr = _idaapi.NN_vldmxcsr
NN_vmaskmovdqu = _idaapi.NN_vmaskmovdqu
NN_vmaskmovpd = _idaapi.NN_vmaskmovpd
NN_vmaskmovps = _idaapi.NN_vmaskmovps
NN_vmaxpd = _idaapi.NN_vmaxpd
NN_vmaxps = _idaapi.NN_vmaxps
NN_vmaxsd = _idaapi.NN_vmaxsd
NN_vmaxss = _idaapi.NN_vmaxss
NN_vminpd = _idaapi.NN_vminpd
NN_vminps = _idaapi.NN_vminps
NN_vminsd = _idaapi.NN_vminsd
NN_vminss = _idaapi.NN_vminss
NN_vmovapd = _idaapi.NN_vmovapd
NN_vmovaps = _idaapi.NN_vmovaps
NN_vmovd = _idaapi.NN_vmovd
NN_vmovddup = _idaapi.NN_vmovddup
NN_vmovdqa = _idaapi.NN_vmovdqa
NN_vmovdqu = _idaapi.NN_vmovdqu
NN_vmovhlps = _idaapi.NN_vmovhlps
NN_vmovhpd = _idaapi.NN_vmovhpd
NN_vmovhps = _idaapi.NN_vmovhps
NN_vmovlhps = _idaapi.NN_vmovlhps
NN_vmovlpd = _idaapi.NN_vmovlpd
NN_vmovlps = _idaapi.NN_vmovlps
NN_vmovmskpd = _idaapi.NN_vmovmskpd
NN_vmovmskps = _idaapi.NN_vmovmskps
NN_vmovntdq = _idaapi.NN_vmovntdq
NN_vmovntdqa = _idaapi.NN_vmovntdqa
NN_vmovntpd = _idaapi.NN_vmovntpd
NN_vmovntps = _idaapi.NN_vmovntps
NN_vmovntsd = _idaapi.NN_vmovntsd
NN_vmovntss = _idaapi.NN_vmovntss
NN_vmovq = _idaapi.NN_vmovq
NN_vmovsd = _idaapi.NN_vmovsd
NN_vmovshdup = _idaapi.NN_vmovshdup
NN_vmovsldup = _idaapi.NN_vmovsldup
NN_vmovss = _idaapi.NN_vmovss
NN_vmovupd = _idaapi.NN_vmovupd
NN_vmovups = _idaapi.NN_vmovups
NN_vmpsadbw = _idaapi.NN_vmpsadbw
NN_vmulpd = _idaapi.NN_vmulpd
NN_vmulps = _idaapi.NN_vmulps
NN_vmulsd = _idaapi.NN_vmulsd
NN_vmulss = _idaapi.NN_vmulss
NN_vorpd = _idaapi.NN_vorpd
NN_vorps = _idaapi.NN_vorps
NN_vpabsb = _idaapi.NN_vpabsb
NN_vpabsd = _idaapi.NN_vpabsd
NN_vpabsw = _idaapi.NN_vpabsw
NN_vpackssdw = _idaapi.NN_vpackssdw
NN_vpacksswb = _idaapi.NN_vpacksswb
NN_vpackusdw = _idaapi.NN_vpackusdw
NN_vpackuswb = _idaapi.NN_vpackuswb
NN_vpaddb = _idaapi.NN_vpaddb
NN_vpaddd = _idaapi.NN_vpaddd
NN_vpaddq = _idaapi.NN_vpaddq
NN_vpaddsb = _idaapi.NN_vpaddsb
NN_vpaddsw = _idaapi.NN_vpaddsw
NN_vpaddusb = _idaapi.NN_vpaddusb
NN_vpaddusw = _idaapi.NN_vpaddusw
NN_vpaddw = _idaapi.NN_vpaddw
NN_vpalignr = _idaapi.NN_vpalignr
NN_vpand = _idaapi.NN_vpand
NN_vpandn = _idaapi.NN_vpandn
NN_vpavgb = _idaapi.NN_vpavgb
NN_vpavgw = _idaapi.NN_vpavgw
NN_vpblendd = _idaapi.NN_vpblendd
NN_vpblendvb = _idaapi.NN_vpblendvb
NN_vpblendw = _idaapi.NN_vpblendw
NN_vpbroadcastb = _idaapi.NN_vpbroadcastb
NN_vpbroadcastd = _idaapi.NN_vpbroadcastd
NN_vpbroadcastq = _idaapi.NN_vpbroadcastq
NN_vpbroadcastw = _idaapi.NN_vpbroadcastw
NN_vpclmulqdq = _idaapi.NN_vpclmulqdq
NN_vpcmpeqb = _idaapi.NN_vpcmpeqb
NN_vpcmpeqd = _idaapi.NN_vpcmpeqd
NN_vpcmpeqq = _idaapi.NN_vpcmpeqq
NN_vpcmpeqw = _idaapi.NN_vpcmpeqw
NN_vpcmpestri = _idaapi.NN_vpcmpestri
NN_vpcmpestrm = _idaapi.NN_vpcmpestrm
NN_vpcmpgtb = _idaapi.NN_vpcmpgtb
NN_vpcmpgtd = _idaapi.NN_vpcmpgtd
NN_vpcmpgtq = _idaapi.NN_vpcmpgtq
NN_vpcmpgtw = _idaapi.NN_vpcmpgtw
NN_vpcmpistri = _idaapi.NN_vpcmpistri
NN_vpcmpistrm = _idaapi.NN_vpcmpistrm
NN_vperm2f128 = _idaapi.NN_vperm2f128
NN_vperm2i128 = _idaapi.NN_vperm2i128
NN_vpermd = _idaapi.NN_vpermd
NN_vpermilpd = _idaapi.NN_vpermilpd
NN_vpermilps = _idaapi.NN_vpermilps
NN_vpermpd = _idaapi.NN_vpermpd
NN_vpermps = _idaapi.NN_vpermps
NN_vpermq = _idaapi.NN_vpermq
NN_vpextrb = _idaapi.NN_vpextrb
NN_vpextrd = _idaapi.NN_vpextrd
NN_vpextrq = _idaapi.NN_vpextrq
NN_vpextrw = _idaapi.NN_vpextrw
NN_vpgatherdd = _idaapi.NN_vpgatherdd
NN_vpgatherdq = _idaapi.NN_vpgatherdq
NN_vpgatherqd = _idaapi.NN_vpgatherqd
NN_vpgatherqq = _idaapi.NN_vpgatherqq
NN_vphaddd = _idaapi.NN_vphaddd
NN_vphaddsw = _idaapi.NN_vphaddsw
NN_vphaddw = _idaapi.NN_vphaddw
NN_vphminposuw = _idaapi.NN_vphminposuw
NN_vphsubd = _idaapi.NN_vphsubd
NN_vphsubsw = _idaapi.NN_vphsubsw
NN_vphsubw = _idaapi.NN_vphsubw
NN_vpinsrb = _idaapi.NN_vpinsrb
NN_vpinsrd = _idaapi.NN_vpinsrd
NN_vpinsrq = _idaapi.NN_vpinsrq
NN_vpinsrw = _idaapi.NN_vpinsrw
NN_vpmaddubsw = _idaapi.NN_vpmaddubsw
NN_vpmaddwd = _idaapi.NN_vpmaddwd
NN_vpmaskmovd = _idaapi.NN_vpmaskmovd
NN_vpmaskmovq = _idaapi.NN_vpmaskmovq
NN_vpmaxsb = _idaapi.NN_vpmaxsb
NN_vpmaxsd = _idaapi.NN_vpmaxsd
NN_vpmaxsw = _idaapi.NN_vpmaxsw
NN_vpmaxub = _idaapi.NN_vpmaxub
NN_vpmaxud = _idaapi.NN_vpmaxud
NN_vpmaxuw = _idaapi.NN_vpmaxuw
NN_vpminsb = _idaapi.NN_vpminsb
NN_vpminsd = _idaapi.NN_vpminsd
NN_vpminsw = _idaapi.NN_vpminsw
NN_vpminub = _idaapi.NN_vpminub
NN_vpminud = _idaapi.NN_vpminud
NN_vpminuw = _idaapi.NN_vpminuw
NN_vpmovmskb = _idaapi.NN_vpmovmskb
NN_vpmovsxbd = _idaapi.NN_vpmovsxbd
NN_vpmovsxbq = _idaapi.NN_vpmovsxbq
NN_vpmovsxbw = _idaapi.NN_vpmovsxbw
NN_vpmovsxdq = _idaapi.NN_vpmovsxdq
NN_vpmovsxwd = _idaapi.NN_vpmovsxwd
NN_vpmovsxwq = _idaapi.NN_vpmovsxwq
NN_vpmovzxbd = _idaapi.NN_vpmovzxbd
NN_vpmovzxbq = _idaapi.NN_vpmovzxbq
NN_vpmovzxbw = _idaapi.NN_vpmovzxbw
NN_vpmovzxdq = _idaapi.NN_vpmovzxdq
NN_vpmovzxwd = _idaapi.NN_vpmovzxwd
NN_vpmovzxwq = _idaapi.NN_vpmovzxwq
NN_vpmuldq = _idaapi.NN_vpmuldq
NN_vpmulhrsw = _idaapi.NN_vpmulhrsw
NN_vpmulhuw = _idaapi.NN_vpmulhuw
NN_vpmulhw = _idaapi.NN_vpmulhw
NN_vpmulld = _idaapi.NN_vpmulld
NN_vpmullw = _idaapi.NN_vpmullw
NN_vpmuludq = _idaapi.NN_vpmuludq
NN_vpor = _idaapi.NN_vpor
NN_vpsadbw = _idaapi.NN_vpsadbw
NN_vpshufb = _idaapi.NN_vpshufb
NN_vpshufd = _idaapi.NN_vpshufd
NN_vpshufhw = _idaapi.NN_vpshufhw
NN_vpshuflw = _idaapi.NN_vpshuflw
NN_vpsignb = _idaapi.NN_vpsignb
NN_vpsignd = _idaapi.NN_vpsignd
NN_vpsignw = _idaapi.NN_vpsignw
NN_vpslld = _idaapi.NN_vpslld
NN_vpslldq = _idaapi.NN_vpslldq
NN_vpsllq = _idaapi.NN_vpsllq
NN_vpsllvd = _idaapi.NN_vpsllvd
NN_vpsllvq = _idaapi.NN_vpsllvq
NN_vpsllw = _idaapi.NN_vpsllw
NN_vpsrad = _idaapi.NN_vpsrad
NN_vpsravd = _idaapi.NN_vpsravd
NN_vpsraw = _idaapi.NN_vpsraw
NN_vpsrld = _idaapi.NN_vpsrld
NN_vpsrldq = _idaapi.NN_vpsrldq
NN_vpsrlq = _idaapi.NN_vpsrlq
NN_vpsrlvd = _idaapi.NN_vpsrlvd
NN_vpsrlvq = _idaapi.NN_vpsrlvq
NN_vpsrlw = _idaapi.NN_vpsrlw
NN_vpsubb = _idaapi.NN_vpsubb
NN_vpsubd = _idaapi.NN_vpsubd
NN_vpsubq = _idaapi.NN_vpsubq
NN_vpsubsb = _idaapi.NN_vpsubsb
NN_vpsubsw = _idaapi.NN_vpsubsw
NN_vpsubusb = _idaapi.NN_vpsubusb
NN_vpsubusw = _idaapi.NN_vpsubusw
NN_vpsubw = _idaapi.NN_vpsubw
NN_vptest = _idaapi.NN_vptest
NN_vpunpckhbw = _idaapi.NN_vpunpckhbw
NN_vpunpckhdq = _idaapi.NN_vpunpckhdq
NN_vpunpckhqdq = _idaapi.NN_vpunpckhqdq
NN_vpunpckhwd = _idaapi.NN_vpunpckhwd
NN_vpunpcklbw = _idaapi.NN_vpunpcklbw
NN_vpunpckldq = _idaapi.NN_vpunpckldq
NN_vpunpcklqdq = _idaapi.NN_vpunpcklqdq
NN_vpunpcklwd = _idaapi.NN_vpunpcklwd
NN_vpxor = _idaapi.NN_vpxor
NN_vrcpps = _idaapi.NN_vrcpps
NN_vrcpss = _idaapi.NN_vrcpss
NN_vroundpd = _idaapi.NN_vroundpd
NN_vroundps = _idaapi.NN_vroundps
NN_vroundsd = _idaapi.NN_vroundsd
NN_vroundss = _idaapi.NN_vroundss
NN_vrsqrtps = _idaapi.NN_vrsqrtps
NN_vrsqrtss = _idaapi.NN_vrsqrtss
NN_vshufpd = _idaapi.NN_vshufpd
NN_vshufps = _idaapi.NN_vshufps
NN_vsqrtpd = _idaapi.NN_vsqrtpd
NN_vsqrtps = _idaapi.NN_vsqrtps
NN_vsqrtsd = _idaapi.NN_vsqrtsd
NN_vsqrtss = _idaapi.NN_vsqrtss
NN_vstmxcsr = _idaapi.NN_vstmxcsr
NN_vsubpd = _idaapi.NN_vsubpd
NN_vsubps = _idaapi.NN_vsubps
NN_vsubsd = _idaapi.NN_vsubsd
NN_vsubss = _idaapi.NN_vsubss
NN_vtestpd = _idaapi.NN_vtestpd
NN_vtestps = _idaapi.NN_vtestps
NN_vucomisd = _idaapi.NN_vucomisd
NN_vucomiss = _idaapi.NN_vucomiss
NN_vunpckhpd = _idaapi.NN_vunpckhpd
NN_vunpckhps = _idaapi.NN_vunpckhps
NN_vunpcklpd = _idaapi.NN_vunpcklpd
NN_vunpcklps = _idaapi.NN_vunpcklps
NN_vxorpd = _idaapi.NN_vxorpd
NN_vxorps = _idaapi.NN_vxorps
NN_vzeroall = _idaapi.NN_vzeroall
NN_vzeroupper = _idaapi.NN_vzeroupper
NN_xabort = _idaapi.NN_xabort
NN_xbegin = _idaapi.NN_xbegin
NN_xend = _idaapi.NN_xend
NN_xtest = _idaapi.NN_xtest
NN_vmgetinfo = _idaapi.NN_vmgetinfo
NN_vmsetinfo = _idaapi.NN_vmsetinfo
NN_vmdxdsbl = _idaapi.NN_vmdxdsbl
NN_vmdxenbl = _idaapi.NN_vmdxenbl
NN_vmcpuid = _idaapi.NN_vmcpuid
NN_vmhlt = _idaapi.NN_vmhlt
NN_vmsplaf = _idaapi.NN_vmsplaf
NN_vmpushfd = _idaapi.NN_vmpushfd
NN_vmpopfd = _idaapi.NN_vmpopfd
NN_vmcli = _idaapi.NN_vmcli
NN_vmsti = _idaapi.NN_vmsti
NN_vmiretd = _idaapi.NN_vmiretd
NN_vmsgdt = _idaapi.NN_vmsgdt
NN_vmsidt = _idaapi.NN_vmsidt
NN_vmsldt = _idaapi.NN_vmsldt
NN_vmstr = _idaapi.NN_vmstr
NN_vmsdte = _idaapi.NN_vmsdte
NN_vpcext = _idaapi.NN_vpcext
NN_vfmaddsubps = _idaapi.NN_vfmaddsubps
NN_vfmaddsubpd = _idaapi.NN_vfmaddsubpd
NN_vfmsubaddps = _idaapi.NN_vfmsubaddps
NN_vfmsubaddpd = _idaapi.NN_vfmsubaddpd
NN_vfmaddps = _idaapi.NN_vfmaddps
NN_vfmaddpd = _idaapi.NN_vfmaddpd
NN_vfmaddss = _idaapi.NN_vfmaddss
NN_vfmaddsd = _idaapi.NN_vfmaddsd
NN_vfmsubps = _idaapi.NN_vfmsubps
NN_vfmsubpd = _idaapi.NN_vfmsubpd
NN_vfmsubss = _idaapi.NN_vfmsubss
NN_vfmsubsd = _idaapi.NN_vfmsubsd
NN_vfnmaddps = _idaapi.NN_vfnmaddps
NN_vfnmaddpd = _idaapi.NN_vfnmaddpd
NN_vfnmaddss = _idaapi.NN_vfnmaddss
NN_vfnmaddsd = _idaapi.NN_vfnmaddsd
NN_vfnmsubps = _idaapi.NN_vfnmsubps
NN_vfnmsubpd = _idaapi.NN_vfnmsubpd
NN_vfnmsubss = _idaapi.NN_vfnmsubss
NN_vfnmsubsd = _idaapi.NN_vfnmsubsd
NN_last = _idaapi.NN_last
I5_null = _idaapi.I5_null
I5_aci = _idaapi.I5_aci
I5_adc = _idaapi.I5_adc
Z80_adc = _idaapi.Z80_adc
I5_add = _idaapi.I5_add
Z80_add = _idaapi.Z80_add
I5_adi = _idaapi.I5_adi
I5_ana = _idaapi.I5_ana
I5_ani = _idaapi.I5_ani
I5_call = _idaapi.I5_call
I5_cnz = _idaapi.I5_cnz
I5_cz = _idaapi.I5_cz
I5_cnc = _idaapi.I5_cnc
I5_cc = _idaapi.I5_cc
I5_cpo = _idaapi.I5_cpo
I5_cpe = _idaapi.I5_cpe
I5_cp = _idaapi.I5_cp
I5_cm = _idaapi.I5_cm
I5_cmc = _idaapi.I5_cmc
I5_cmp = _idaapi.I5_cmp
I5_cpi = _idaapi.I5_cpi
I5_cma = _idaapi.I5_cma
I5_daa = _idaapi.I5_daa
I5_dad = _idaapi.I5_dad
I5_dcr = _idaapi.I5_dcr
I5_dcx = _idaapi.I5_dcx
I5_di = _idaapi.I5_di
Z80_di = _idaapi.Z80_di
I5_ei = _idaapi.I5_ei
Z80_ei = _idaapi.Z80_ei
I5_halt = _idaapi.I5_halt
I5_in = _idaapi.I5_in
Z80_in = _idaapi.Z80_in
I5_inr = _idaapi.I5_inr
I5_inx = _idaapi.I5_inx
I5_jmp = _idaapi.I5_jmp
I5_jnz = _idaapi.I5_jnz
I5_jz = _idaapi.I5_jz
I5_jnc = _idaapi.I5_jnc
I5_jc = _idaapi.I5_jc
I5_jpo = _idaapi.I5_jpo
I5_jpe = _idaapi.I5_jpe
I5_jp = _idaapi.I5_jp
I5_jm = _idaapi.I5_jm
I5_lda = _idaapi.I5_lda
I5_ldax = _idaapi.I5_ldax
I5_lhld = _idaapi.I5_lhld
I5_lxi = _idaapi.I5_lxi
I5_mov = _idaapi.I5_mov
I5_mvi = _idaapi.I5_mvi
I5_nop = _idaapi.I5_nop
I5_ora = _idaapi.I5_ora
I5_ori = _idaapi.I5_ori
I5_out = _idaapi.I5_out
Z80_out = _idaapi.Z80_out
I5_pchl = _idaapi.I5_pchl
I5_pop = _idaapi.I5_pop
Z80_pop = _idaapi.Z80_pop
I5_push = _idaapi.I5_push
Z80_push = _idaapi.Z80_push
I5_ret = _idaapi.I5_ret
I5_rnz = _idaapi.I5_rnz
I5_rz = _idaapi.I5_rz
I5_rnc = _idaapi.I5_rnc
I5_rc = _idaapi.I5_rc
I5_rpo = _idaapi.I5_rpo
I5_rpe = _idaapi.I5_rpe
I5_rp = _idaapi.I5_rp
I5_rm = _idaapi.I5_rm
I5_ral = _idaapi.I5_ral
I5_rlc = _idaapi.I5_rlc
I5_rar = _idaapi.I5_rar
I5_rrc = _idaapi.I5_rrc
I5_rst = _idaapi.I5_rst
I5_sbb = _idaapi.I5_sbb
I5_sbi = _idaapi.I5_sbi
I5_stc = _idaapi.I5_stc
I5_sphl = _idaapi.I5_sphl
I5_sta = _idaapi.I5_sta
I5_stax = _idaapi.I5_stax
I5_shld = _idaapi.I5_shld
I5_sui = _idaapi.I5_sui
I5_sub = _idaapi.I5_sub
Z80_sub = _idaapi.Z80_sub
I5_xra = _idaapi.I5_xra
I5_xri = _idaapi.I5_xri
I5_xchg = _idaapi.I5_xchg
I5_xthl = _idaapi.I5_xthl
I5_rim = _idaapi.I5_rim
I5_sim = _idaapi.I5_sim
Z80_and = _idaapi.Z80_and
Z80_bit = _idaapi.Z80_bit
Z80_call = _idaapi.Z80_call
Z80_ccf = _idaapi.Z80_ccf
Z80_cp = _idaapi.Z80_cp
Z80_cpd = _idaapi.Z80_cpd
Z80_cpdr = _idaapi.Z80_cpdr
Z80_cpi = _idaapi.Z80_cpi
Z80_cpir = _idaapi.Z80_cpir
Z80_cpl = _idaapi.Z80_cpl
Z80_dec = _idaapi.Z80_dec
Z80_djnz = _idaapi.Z80_djnz
Z80_ex = _idaapi.Z80_ex
Z80_exx = _idaapi.Z80_exx
Z80_halt = _idaapi.Z80_halt
Z80_im = _idaapi.Z80_im
Z80_inc = _idaapi.Z80_inc
Z80_ind = _idaapi.Z80_ind
Z80_indr = _idaapi.Z80_indr
Z80_ini = _idaapi.Z80_ini
Z80_inir = _idaapi.Z80_inir
Z80_jp = _idaapi.Z80_jp
Z80_jr = _idaapi.Z80_jr
Z80_ld = _idaapi.Z80_ld
Z80_ldd = _idaapi.Z80_ldd
Z80_lddr = _idaapi.Z80_lddr
Z80_ldi = _idaapi.Z80_ldi
Z80_ldir = _idaapi.Z80_ldir
Z80_neg = _idaapi.Z80_neg
Z80_or = _idaapi.Z80_or
Z80_otdr = _idaapi.Z80_otdr
Z80_otir = _idaapi.Z80_otir
Z80_outd = _idaapi.Z80_outd
Z80_outi = _idaapi.Z80_outi
Z80_res = _idaapi.Z80_res
Z80_ret = _idaapi.Z80_ret
Z80_reti = _idaapi.Z80_reti
Z80_retn = _idaapi.Z80_retn
Z80_rl = _idaapi.Z80_rl
Z80_rla = _idaapi.Z80_rla
Z80_rlc = _idaapi.Z80_rlc
Z80_rlca = _idaapi.Z80_rlca
Z80_rld = _idaapi.Z80_rld
Z80_rr = _idaapi.Z80_rr
Z80_rra = _idaapi.Z80_rra
Z80_rrc = _idaapi.Z80_rrc
Z80_rrca = _idaapi.Z80_rrca
Z80_rrd = _idaapi.Z80_rrd
Z80_scf = _idaapi.Z80_scf
Z80_sbc = _idaapi.Z80_sbc
Z80_set = _idaapi.Z80_set
Z80_sla = _idaapi.Z80_sla
Z80_sra = _idaapi.Z80_sra
Z80_srl = _idaapi.Z80_srl
Z80_xor = _idaapi.Z80_xor
Z80_inp = _idaapi.Z80_inp
Z80_outp = _idaapi.Z80_outp
Z80_srr = _idaapi.Z80_srr
HD_in0 = _idaapi.HD_in0
Z80_in0 = _idaapi.Z80_in0
HD_mlt = _idaapi.HD_mlt
Z80_mlt = _idaapi.Z80_mlt
HD_otim = _idaapi.HD_otim
Z80_otim = _idaapi.Z80_otim
HD_otimr = _idaapi.HD_otimr
Z80_otimr = _idaapi.Z80_otimr
HD_otdm = _idaapi.HD_otdm
Z80_otdm = _idaapi.Z80_otdm
HD_otdmr = _idaapi.HD_otdmr
Z80_otdmr = _idaapi.Z80_otdmr
HD_out0 = _idaapi.HD_out0
Z80_out0 = _idaapi.Z80_out0
HD_slp = _idaapi.HD_slp
Z80_slp = _idaapi.Z80_slp
HD_tst = _idaapi.HD_tst
Z80_tst = _idaapi.Z80_tst
HD_tstio = _idaapi.HD_tstio
Z80_tstio = _idaapi.Z80_tstio
A80_lbcd = _idaapi.A80_lbcd
A80_lded = _idaapi.A80_lded
A80_lspd = _idaapi.A80_lspd
A80_lixd = _idaapi.A80_lixd
A80_liyd = _idaapi.A80_liyd
A80_sbcd = _idaapi.A80_sbcd
A80_sded = _idaapi.A80_sded
A80_sspd = _idaapi.A80_sspd
A80_sixd = _idaapi.A80_sixd
A80_siyd = _idaapi.A80_siyd
A80_xtix = _idaapi.A80_xtix
A80_xtiy = _idaapi.A80_xtiy
A80_spix = _idaapi.A80_spix
A80_spiy = _idaapi.A80_spiy
A80_pcix = _idaapi.A80_pcix
A80_pciy = _idaapi.A80_pciy
A80_mvra = _idaapi.A80_mvra
A80_mvia = _idaapi.A80_mvia
A80_mvar = _idaapi.A80_mvar
A80_mvai = _idaapi.A80_mvai
A80_addix = _idaapi.A80_addix
A80_addiy = _idaapi.A80_addiy
A80_addc = _idaapi.A80_addc
A80_addcix = _idaapi.A80_addcix
A80_addciy = _idaapi.A80_addciy
A80_subc = _idaapi.A80_subc
A80_subcix = _idaapi.A80_subcix
A80_subciy = _idaapi.A80_subciy
A80_jrc = _idaapi.A80_jrc
A80_jrnc = _idaapi.A80_jrnc
A80_jrz = _idaapi.A80_jrz
A80_jrnz = _idaapi.A80_jrnz
A80_cmpi = _idaapi.A80_cmpi
A80_cmpd = _idaapi.A80_cmpd
A80_im0 = _idaapi.A80_im0
A80_im1 = _idaapi.A80_im1
A80_im2 = _idaapi.A80_im2
A80_otd = _idaapi.A80_otd
A80_oti = _idaapi.A80_oti
I5_dsub = _idaapi.I5_dsub
I5_arhl = _idaapi.I5_arhl
I5_rdel = _idaapi.I5_rdel
I5_ldhi = _idaapi.I5_ldhi
I5_ldsi = _idaapi.I5_ldsi
I5_shlx = _idaapi.I5_shlx
I5_lhlx = _idaapi.I5_lhlx
I5_rstv = _idaapi.I5_rstv
I5_jx5 = _idaapi.I5_jx5
I5_jnx5 = _idaapi.I5_jnx5
Z80_cplw = _idaapi.Z80_cplw
Z80_swap = _idaapi.Z80_swap
Z80_inw = _idaapi.Z80_inw
Z80_outw = _idaapi.Z80_outw
Z80_ldw = _idaapi.Z80_ldw
Z80_addw = _idaapi.Z80_addw
Z80_subw = _idaapi.Z80_subw
Z80_adcw = _idaapi.Z80_adcw
Z80_sbcw = _idaapi.Z80_sbcw
Z80_andw = _idaapi.Z80_andw
Z80_xorw = _idaapi.Z80_xorw
Z80_orw = _idaapi.Z80_orw
Z80_cpw = _idaapi.Z80_cpw
Z80_ddir = _idaapi.Z80_ddir
Z80_calr = _idaapi.Z80_calr
Z80_ldctl = _idaapi.Z80_ldctl
Z80_mtest = _idaapi.Z80_mtest
Z80_exxx = _idaapi.Z80_exxx
Z80_exxy = _idaapi.Z80_exxy
Z80_exall = _idaapi.Z80_exall
Z80_setc = _idaapi.Z80_setc
Z80_resc = _idaapi.Z80_resc
Z80_rlcw = _idaapi.Z80_rlcw
Z80_rrcw = _idaapi.Z80_rrcw
Z80_rlw = _idaapi.Z80_rlw
Z80_rrw = _idaapi.Z80_rrw
Z80_slaw = _idaapi.Z80_slaw
Z80_sraw = _idaapi.Z80_sraw
Z80_srlw = _idaapi.Z80_srlw
Z80_multw = _idaapi.Z80_multw
Z80_multuw = _idaapi.Z80_multuw
Z80_divuw = _idaapi.Z80_divuw
Z80_outaw = _idaapi.Z80_outaw
Z80_inaw = _idaapi.Z80_inaw
Z80_outa = _idaapi.Z80_outa
Z80_ina = _idaapi.Z80_ina
Z80_negw = _idaapi.Z80_negw
Z80_exts = _idaapi.Z80_exts
Z80_extsw = _idaapi.Z80_extsw
Z80_btest = _idaapi.Z80_btest
Z80_ldiw = _idaapi.Z80_ldiw
Z80_ldirw = _idaapi.Z80_ldirw
Z80_lddw = _idaapi.Z80_lddw
Z80_lddrw = _idaapi.Z80_lddrw
Z80_iniw = _idaapi.Z80_iniw
Z80_inirw = _idaapi.Z80_inirw
Z80_indw = _idaapi.Z80_indw
Z80_indrw = _idaapi.Z80_indrw
Z80_outiw = _idaapi.Z80_outiw
Z80_otirw = _idaapi.Z80_otirw
Z80_outdw = _idaapi.Z80_outdw
Z80_otdrw = _idaapi.Z80_otdrw
GB_ldh = _idaapi.GB_ldh
GB_stop = _idaapi.GB_stop
I5_last = _idaapi.I5_last
I860_null = _idaapi.I860_null
I860_adds = _idaapi.I860_adds
I860_addu = _idaapi.I860_addu
I860_and = _idaapi.I860_and
I860_andh = _idaapi.I860_andh
I860_andnot = _idaapi.I860_andnot
I860_andnoth = _idaapi.I860_andnoth
I860_bc = _idaapi.I860_bc
I860_bc_t = _idaapi.I860_bc_t
I860_bla = _idaapi.I860_bla
I860_bnc = _idaapi.I860_bnc
I860_bnc_t = _idaapi.I860_bnc_t
I860_br = _idaapi.I860_br
I860_bri = _idaapi.I860_bri
I860_bte = _idaapi.I860_bte
I860_btne = _idaapi.I860_btne
I860_call = _idaapi.I860_call
I860_calli = _idaapi.I860_calli
I860_fadd = _idaapi.I860_fadd
I860_faddp = _idaapi.I860_faddp
I860_faddz = _idaapi.I860_faddz
I860_famov = _idaapi.I860_famov
I860_fiadd = _idaapi.I860_fiadd
I860_fisub = _idaapi.I860_fisub
I860_fix = _idaapi.I860_fix
I860_fld = _idaapi.I860_fld
I860_flush = _idaapi.I860_flush
I860_fmlow_dd = _idaapi.I860_fmlow_dd
I860_fmul = _idaapi.I860_fmul
I860_form = _idaapi.I860_form
I860_frcp = _idaapi.I860_frcp
I860_frsqr = _idaapi.I860_frsqr
I860_fst = _idaapi.I860_fst
I860_fsub = _idaapi.I860_fsub
I860_ftrunc = _idaapi.I860_ftrunc
I860_fxfr = _idaapi.I860_fxfr
I860_fzchkl = _idaapi.I860_fzchkl
I860_fzchks = _idaapi.I860_fzchks
I860_introvr = _idaapi.I860_introvr
I860_ixfr = _idaapi.I860_ixfr
I860_ld_c = _idaapi.I860_ld_c
I860_ld = _idaapi.I860_ld
I860_ldint = _idaapi.I860_ldint
I860_ldio = _idaapi.I860_ldio
I860_lock = _idaapi.I860_lock
I860_or = _idaapi.I860_or
I860_orh = _idaapi.I860_orh
I860_pfadd = _idaapi.I860_pfadd
I860_pfaddp = _idaapi.I860_pfaddp
I860_pfaddz = _idaapi.I860_pfaddz
I860_pfamov = _idaapi.I860_pfamov
I860_pfeq = _idaapi.I860_pfeq
I860_pfgt = _idaapi.I860_pfgt
I860_pfiadd = _idaapi.I860_pfiadd
I860_pfisub = _idaapi.I860_pfisub
I860_pfix = _idaapi.I860_pfix
I860_pfld = _idaapi.I860_pfld
I860_pfle = _idaapi.I860_pfle
I860_pfmul = _idaapi.I860_pfmul
I860_pfmul3_dd = _idaapi.I860_pfmul3_dd
I860_pform = _idaapi.I860_pform
I860_pfsub = _idaapi.I860_pfsub
I860_pftrunc = _idaapi.I860_pftrunc
I860_pfzchkl = _idaapi.I860_pfzchkl
I860_pfzchks = _idaapi.I860_pfzchks
I860_pst_d = _idaapi.I860_pst_d
I860_scyc = _idaapi.I860_scyc
I860_shl = _idaapi.I860_shl
I860_shr = _idaapi.I860_shr
I860_shra = _idaapi.I860_shra
I860_shrd = _idaapi.I860_shrd
I860_st_c = _idaapi.I860_st_c
I860_st = _idaapi.I860_st
I860_stio = _idaapi.I860_stio
I860_subs = _idaapi.I860_subs
I860_subu = _idaapi.I860_subu
I860_trap = _idaapi.I860_trap
I860_unlock = _idaapi.I860_unlock
I860_xor = _idaapi.I860_xor
I860_xorh = _idaapi.I860_xorh
I860_r2p1 = _idaapi.I860_r2p1
I860_r2pt = _idaapi.I860_r2pt
I860_r2ap1 = _idaapi.I860_r2ap1
I860_r2apt = _idaapi.I860_r2apt
I860_i2p1 = _idaapi.I860_i2p1
I860_i2pt = _idaapi.I860_i2pt
I860_i2ap1 = _idaapi.I860_i2ap1
I860_i2apt = _idaapi.I860_i2apt
I860_rat1p2 = _idaapi.I860_rat1p2
I860_m12apm = _idaapi.I860_m12apm
I860_ra1p2 = _idaapi.I860_ra1p2
I860_m12ttpa = _idaapi.I860_m12ttpa
I860_iat1p2 = _idaapi.I860_iat1p2
I860_m12tpm = _idaapi.I860_m12tpm
I860_ia1p2 = _idaapi.I860_ia1p2
I860_m12tpa = _idaapi.I860_m12tpa
I860_r2s1 = _idaapi.I860_r2s1
I860_r2st = _idaapi.I860_r2st
I860_r2as1 = _idaapi.I860_r2as1
I860_r2ast = _idaapi.I860_r2ast
I860_i2s1 = _idaapi.I860_i2s1
I860_i2st = _idaapi.I860_i2st
I860_i2as1 = _idaapi.I860_i2as1
I860_i2ast = _idaapi.I860_i2ast
I860_rat1s2 = _idaapi.I860_rat1s2
I860_m12asm = _idaapi.I860_m12asm
I860_ra1s2 = _idaapi.I860_ra1s2
I860_m12ttsa = _idaapi.I860_m12ttsa
I860_iat1s2 = _idaapi.I860_iat1s2
I860_m12tsm = _idaapi.I860_m12tsm
I860_ia1s2 = _idaapi.I860_ia1s2
I860_m12tsa = _idaapi.I860_m12tsa
I860_mr2p1 = _idaapi.I860_mr2p1
I860_mr2pt = _idaapi.I860_mr2pt
I860_mr2mp1 = _idaapi.I860_mr2mp1
I860_mr2mpt = _idaapi.I860_mr2mpt
I860_mi2p1 = _idaapi.I860_mi2p1
I860_mi2pt = _idaapi.I860_mi2pt
I860_mi2mp1 = _idaapi.I860_mi2mp1
I860_mi2mpt = _idaapi.I860_mi2mpt
I860_mrmt1p2 = _idaapi.I860_mrmt1p2
I860_mm12mpm = _idaapi.I860_mm12mpm
I860_mrm1p2 = _idaapi.I860_mrm1p2
I860_mm12ttpm = _idaapi.I860_mm12ttpm
I860_mimt1p2 = _idaapi.I860_mimt1p2
I860_mm12tpm = _idaapi.I860_mm12tpm
I860_mim1p2 = _idaapi.I860_mim1p2
I860_mr2s1 = _idaapi.I860_mr2s1
I860_mr2st = _idaapi.I860_mr2st
I860_mr2ms1 = _idaapi.I860_mr2ms1
I860_mr2mst = _idaapi.I860_mr2mst
I860_mi2s1 = _idaapi.I860_mi2s1
I860_mi2st = _idaapi.I860_mi2st
I860_mi2ms1 = _idaapi.I860_mi2ms1
I860_mi2mst = _idaapi.I860_mi2mst
I860_mrmt1s2 = _idaapi.I860_mrmt1s2
I860_mm12msm = _idaapi.I860_mm12msm
I860_mrm1s2 = _idaapi.I860_mrm1s2
I860_mm12ttsm = _idaapi.I860_mm12ttsm
I860_mimt1s2 = _idaapi.I860_mimt1s2
I860_mm12tsm = _idaapi.I860_mm12tsm
I860_mim1s2 = _idaapi.I860_mim1s2
I860_last = _idaapi.I860_last
I51_null = _idaapi.I51_null
I51_acall = _idaapi.I51_acall
I51_add = _idaapi.I51_add
I51_addc = _idaapi.I51_addc
I51_ajmp = _idaapi.I51_ajmp
I51_anl = _idaapi.I51_anl
I51_cjne = _idaapi.I51_cjne
I51_clr = _idaapi.I51_clr
I51_cpl = _idaapi.I51_cpl
I51_da = _idaapi.I51_da
I51_dec = _idaapi.I51_dec
I51_div = _idaapi.I51_div
I51_djnz = _idaapi.I51_djnz
I51_inc = _idaapi.I51_inc
I51_jb = _idaapi.I51_jb
I51_jbc = _idaapi.I51_jbc
I51_jc = _idaapi.I51_jc
I51_jmp = _idaapi.I51_jmp
I51_jnb = _idaapi.I51_jnb
I51_jnc = _idaapi.I51_jnc
I51_jnz = _idaapi.I51_jnz
I51_jz = _idaapi.I51_jz
I51_lcall = _idaapi.I51_lcall
I51_ljmp = _idaapi.I51_ljmp
I51_mov = _idaapi.I51_mov
I51_movc = _idaapi.I51_movc
I51_movx = _idaapi.I51_movx
I51_mul = _idaapi.I51_mul
I51_nop = _idaapi.I51_nop
I51_orl = _idaapi.I51_orl
I51_pop = _idaapi.I51_pop
I51_push = _idaapi.I51_push
I51_ret = _idaapi.I51_ret
I51_reti = _idaapi.I51_reti
I51_rl = _idaapi.I51_rl
I51_rlc = _idaapi.I51_rlc
I51_rr = _idaapi.I51_rr
I51_rrc = _idaapi.I51_rrc
I51_setb = _idaapi.I51_setb
I51_sjmp = _idaapi.I51_sjmp
I51_subb = _idaapi.I51_subb
I51_swap = _idaapi.I51_swap
I51_xch = _idaapi.I51_xch
I51_xchd = _idaapi.I51_xchd
I51_xrl = _idaapi.I51_xrl
I51_jsle = _idaapi.I51_jsle
I51_jsg = _idaapi.I51_jsg
I51_jle = _idaapi.I51_jle
I51_jg = _idaapi.I51_jg
I51_jsl = _idaapi.I51_jsl
I51_jsge = _idaapi.I51_jsge
I51_je = _idaapi.I51_je
I51_jne = _idaapi.I51_jne
I51_trap = _idaapi.I51_trap
I51_ejmp = _idaapi.I51_ejmp
I51_ecall = _idaapi.I51_ecall
I51_eret = _idaapi.I51_eret
I51_movh = _idaapi.I51_movh
I51_movz = _idaapi.I51_movz
I51_movs = _idaapi.I51_movs
I51_srl = _idaapi.I51_srl
I51_sra = _idaapi.I51_sra
I51_sll = _idaapi.I51_sll
I51_sub = _idaapi.I51_sub
I51_cmp = _idaapi.I51_cmp
I51_emov = _idaapi.I51_emov
I51_last = _idaapi.I51_last
TMS_null = _idaapi.TMS_null
TMS_abs = _idaapi.TMS_abs
TMS_adcb = _idaapi.TMS_adcb
TMS_add = _idaapi.TMS_add
TMS_addb = _idaapi.TMS_addb
TMS_addc = _idaapi.TMS_addc
TMS_adds = _idaapi.TMS_adds
TMS_addt = _idaapi.TMS_addt
TMS_adrk = _idaapi.TMS_adrk
TMS_and = _idaapi.TMS_and
TMS_andb = _idaapi.TMS_andb
TMS_apac = _idaapi.TMS_apac
TMS_apl = _idaapi.TMS_apl
TMS_apl2 = _idaapi.TMS_apl2
TMS_b = _idaapi.TMS_b
TMS_bacc = _idaapi.TMS_bacc
TMS_baccd = _idaapi.TMS_baccd
TMS_banz = _idaapi.TMS_banz
TMS_banzd = _idaapi.TMS_banzd
TMS_bcnd = _idaapi.TMS_bcnd
TMS_bcndd = _idaapi.TMS_bcndd
TMS_bd = _idaapi.TMS_bd
TMS_bit = _idaapi.TMS_bit
TMS_bitt = _idaapi.TMS_bitt
TMS_bldd = _idaapi.TMS_bldd
TMS_bldp = _idaapi.TMS_bldp
TMS_blpd = _idaapi.TMS_blpd
TMS_bsar = _idaapi.TMS_bsar
TMS_cala = _idaapi.TMS_cala
TMS_calad = _idaapi.TMS_calad
TMS_call = _idaapi.TMS_call
TMS_calld = _idaapi.TMS_calld
TMS_cc = _idaapi.TMS_cc
TMS_ccd = _idaapi.TMS_ccd
TMS_clrc = _idaapi.TMS_clrc
TMS_cmpl = _idaapi.TMS_cmpl
TMS_cmpr = _idaapi.TMS_cmpr
TMS_cpl = _idaapi.TMS_cpl
TMS_cpl2 = _idaapi.TMS_cpl2
TMS_crgt = _idaapi.TMS_crgt
TMS_crlt = _idaapi.TMS_crlt
TMS_dmov = _idaapi.TMS_dmov
TMS_estop = _idaapi.TMS_estop
TMS_exar = _idaapi.TMS_exar
TMS_idle = _idaapi.TMS_idle
TMS_idle2 = _idaapi.TMS_idle2
TMS_in = _idaapi.TMS_in
TMS_intr = _idaapi.TMS_intr
TMS_lacb = _idaapi.TMS_lacb
TMS_lacc = _idaapi.TMS_lacc
TMS_lacl = _idaapi.TMS_lacl
TMS_lact = _idaapi.TMS_lact
TMS_lamm = _idaapi.TMS_lamm
TMS_lar = _idaapi.TMS_lar
TMS_ldp = _idaapi.TMS_ldp
TMS_lmmr = _idaapi.TMS_lmmr
TMS_lph = _idaapi.TMS_lph
TMS_lst = _idaapi.TMS_lst
TMS_lt = _idaapi.TMS_lt
TMS_lta = _idaapi.TMS_lta
TMS_ltd = _idaapi.TMS_ltd
TMS_ltp = _idaapi.TMS_ltp
TMS_lts = _idaapi.TMS_lts
TMS_mac = _idaapi.TMS_mac
TMS_macd = _idaapi.TMS_macd
TMS_madd = _idaapi.TMS_madd
TMS_mads = _idaapi.TMS_mads
TMS_mar = _idaapi.TMS_mar
TMS_mpy = _idaapi.TMS_mpy
TMS_mpya = _idaapi.TMS_mpya
TMS_mpys = _idaapi.TMS_mpys
TMS_mpyu = _idaapi.TMS_mpyu
TMS_neg = _idaapi.TMS_neg
TMS_nmi = _idaapi.TMS_nmi
TMS_nop = _idaapi.TMS_nop
TMS_norm = _idaapi.TMS_norm
TMS_opl = _idaapi.TMS_opl
TMS_opl2 = _idaapi.TMS_opl2
TMS_or = _idaapi.TMS_or
TMS_orb = _idaapi.TMS_orb
TMS_out = _idaapi.TMS_out
TMS_pac = _idaapi.TMS_pac
TMS_pop = _idaapi.TMS_pop
TMS_popd = _idaapi.TMS_popd
TMS_pshd = _idaapi.TMS_pshd
TMS_push = _idaapi.TMS_push
TMS_ret = _idaapi.TMS_ret
TMS_retc = _idaapi.TMS_retc
TMS_retcd = _idaapi.TMS_retcd
TMS_retd = _idaapi.TMS_retd
TMS_rete = _idaapi.TMS_rete
TMS_reti = _idaapi.TMS_reti
TMS_rol = _idaapi.TMS_rol
TMS_rolb = _idaapi.TMS_rolb
TMS_ror = _idaapi.TMS_ror
TMS_rorb = _idaapi.TMS_rorb
TMS_rpt = _idaapi.TMS_rpt
TMS_rptb = _idaapi.TMS_rptb
TMS_rptz = _idaapi.TMS_rptz
TMS_sacb = _idaapi.TMS_sacb
TMS_sach = _idaapi.TMS_sach
TMS_sacl = _idaapi.TMS_sacl
TMS_samm = _idaapi.TMS_samm
TMS_sar = _idaapi.TMS_sar
TMS_sath = _idaapi.TMS_sath
TMS_satl = _idaapi.TMS_satl
TMS_sbb = _idaapi.TMS_sbb
TMS_sbbb = _idaapi.TMS_sbbb
TMS_sbrk = _idaapi.TMS_sbrk
TMS_setc = _idaapi.TMS_setc
TMS_sfl = _idaapi.TMS_sfl
TMS_sflb = _idaapi.TMS_sflb
TMS_sfr = _idaapi.TMS_sfr
TMS_sfrb = _idaapi.TMS_sfrb
TMS_smmr = _idaapi.TMS_smmr
TMS_spac = _idaapi.TMS_spac
TMS_sph = _idaapi.TMS_sph
TMS_spl = _idaapi.TMS_spl
TMS_splk = _idaapi.TMS_splk
TMS_spm = _idaapi.TMS_spm
TMS_sqra = _idaapi.TMS_sqra
TMS_sqrs = _idaapi.TMS_sqrs
TMS_sst = _idaapi.TMS_sst
TMS_sub = _idaapi.TMS_sub
TMS_subb = _idaapi.TMS_subb
TMS_subc = _idaapi.TMS_subc
TMS_subs = _idaapi.TMS_subs
TMS_subt = _idaapi.TMS_subt
TMS_tblr = _idaapi.TMS_tblr
TMS_tblw = _idaapi.TMS_tblw
TMS_trap = _idaapi.TMS_trap
TMS_xc = _idaapi.TMS_xc
TMS_xor = _idaapi.TMS_xor
TMS_xorb = _idaapi.TMS_xorb
TMS_xpl = _idaapi.TMS_xpl
TMS_xpl2 = _idaapi.TMS_xpl2
TMS_zalr = _idaapi.TMS_zalr
TMS_zap = _idaapi.TMS_zap
TMS_zpr = _idaapi.TMS_zpr
TMS2_abs = _idaapi.TMS2_abs
TMS2_add = _idaapi.TMS2_add
TMS2_addc = _idaapi.TMS2_addc
TMS2_addh = _idaapi.TMS2_addh
TMS2_addk = _idaapi.TMS2_addk
TMS2_adds = _idaapi.TMS2_adds
TMS2_addt = _idaapi.TMS2_addt
TMS2_adlk = _idaapi.TMS2_adlk
TMS2_adrk = _idaapi.TMS2_adrk
TMS2_and = _idaapi.TMS2_and
TMS2_andk = _idaapi.TMS2_andk
TMS2_apac = _idaapi.TMS2_apac
TMS2_b = _idaapi.TMS2_b
TMS2_bacc = _idaapi.TMS2_bacc
TMS2_banz = _idaapi.TMS2_banz
TMS2_bbnz = _idaapi.TMS2_bbnz
TMS2_bbz = _idaapi.TMS2_bbz
TMS2_bc = _idaapi.TMS2_bc
TMS2_bgez = _idaapi.TMS2_bgez
TMS2_bgz = _idaapi.TMS2_bgz
TMS2_bioz = _idaapi.TMS2_bioz
TMS2_bit = _idaapi.TMS2_bit
TMS2_bitt = _idaapi.TMS2_bitt
TMS2_blez = _idaapi.TMS2_blez
TMS2_blkd = _idaapi.TMS2_blkd
TMS2_blkp = _idaapi.TMS2_blkp
TMS2_blz = _idaapi.TMS2_blz
TMS2_bnc = _idaapi.TMS2_bnc
TMS2_bnv = _idaapi.TMS2_bnv
TMS2_bnz = _idaapi.TMS2_bnz
TMS2_bv = _idaapi.TMS2_bv
TMS2_bz = _idaapi.TMS2_bz
TMS2_cala = _idaapi.TMS2_cala
TMS2_call = _idaapi.TMS2_call
TMS2_cmpl = _idaapi.TMS2_cmpl
TMS2_cmpr = _idaapi.TMS2_cmpr
TMS2_cnfd = _idaapi.TMS2_cnfd
TMS2_cnfp = _idaapi.TMS2_cnfp
TMS2_conf = _idaapi.TMS2_conf
TMS2_dint = _idaapi.TMS2_dint
TMS2_dmov = _idaapi.TMS2_dmov
TMS2_eint = _idaapi.TMS2_eint
TMS2_fort = _idaapi.TMS2_fort
TMS2_idle = _idaapi.TMS2_idle
TMS2_in = _idaapi.TMS2_in
TMS2_lac = _idaapi.TMS2_lac
TMS2_lack = _idaapi.TMS2_lack
TMS2_lact = _idaapi.TMS2_lact
TMS2_lalk = _idaapi.TMS2_lalk
TMS2_lar = _idaapi.TMS2_lar
TMS2_lark = _idaapi.TMS2_lark
TMS2_larp = _idaapi.TMS2_larp
TMS2_ldp = _idaapi.TMS2_ldp
TMS2_ldpk = _idaapi.TMS2_ldpk
TMS2_lph = _idaapi.TMS2_lph
TMS2_lrlk = _idaapi.TMS2_lrlk
TMS2_lst = _idaapi.TMS2_lst
TMS2_lst1 = _idaapi.TMS2_lst1
TMS2_lt = _idaapi.TMS2_lt
TMS2_lta = _idaapi.TMS2_lta
TMS2_ltd = _idaapi.TMS2_ltd
TMS2_ltp = _idaapi.TMS2_ltp
TMS2_lts = _idaapi.TMS2_lts
TMS2_mac = _idaapi.TMS2_mac
TMS2_macd = _idaapi.TMS2_macd
TMS2_mar = _idaapi.TMS2_mar
TMS2_mpy = _idaapi.TMS2_mpy
TMS2_mpya = _idaapi.TMS2_mpya
TMS2_mpyk = _idaapi.TMS2_mpyk
TMS2_mpys = _idaapi.TMS2_mpys
TMS2_mpyu = _idaapi.TMS2_mpyu
TMS2_neg = _idaapi.TMS2_neg
TMS2_nop = _idaapi.TMS2_nop
TMS2_norm = _idaapi.TMS2_norm
TMS2_or = _idaapi.TMS2_or
TMS2_ork = _idaapi.TMS2_ork
TMS2_out = _idaapi.TMS2_out
TMS2_pac = _idaapi.TMS2_pac
TMS2_pop = _idaapi.TMS2_pop
TMS2_popd = _idaapi.TMS2_popd
TMS2_pshd = _idaapi.TMS2_pshd
TMS2_push = _idaapi.TMS2_push
TMS2_rc = _idaapi.TMS2_rc
TMS2_ret = _idaapi.TMS2_ret
TMS2_rfsm = _idaapi.TMS2_rfsm
TMS2_rhm = _idaapi.TMS2_rhm
TMS2_rol = _idaapi.TMS2_rol
TMS2_ror = _idaapi.TMS2_ror
TMS2_rovm = _idaapi.TMS2_rovm
TMS2_rpt = _idaapi.TMS2_rpt
TMS2_rptk = _idaapi.TMS2_rptk
TMS2_rsxm = _idaapi.TMS2_rsxm
TMS2_rtc = _idaapi.TMS2_rtc
TMS2_rtxm = _idaapi.TMS2_rtxm
TMS2_rxf = _idaapi.TMS2_rxf
TMS2_sach = _idaapi.TMS2_sach
TMS2_sacl = _idaapi.TMS2_sacl
TMS2_sar = _idaapi.TMS2_sar
TMS2_sblk = _idaapi.TMS2_sblk
TMS2_sbrk = _idaapi.TMS2_sbrk
TMS2_sc = _idaapi.TMS2_sc
TMS2_sfl = _idaapi.TMS2_sfl
TMS2_sfr = _idaapi.TMS2_sfr
TMS2_sfsm = _idaapi.TMS2_sfsm
TMS2_shm = _idaapi.TMS2_shm
TMS2_sovm = _idaapi.TMS2_sovm
TMS2_spac = _idaapi.TMS2_spac
TMS2_sph = _idaapi.TMS2_sph
TMS2_spl = _idaapi.TMS2_spl
TMS2_spm = _idaapi.TMS2_spm
TMS2_sqra = _idaapi.TMS2_sqra
TMS2_sqrs = _idaapi.TMS2_sqrs
TMS2_sst = _idaapi.TMS2_sst
TMS2_sst1 = _idaapi.TMS2_sst1
TMS2_ssxm = _idaapi.TMS2_ssxm
TMS2_stc = _idaapi.TMS2_stc
TMS2_stxm = _idaapi.TMS2_stxm
TMS2_sub = _idaapi.TMS2_sub
TMS2_subb = _idaapi.TMS2_subb
TMS2_subc = _idaapi.TMS2_subc
TMS2_subh = _idaapi.TMS2_subh
TMS2_subk = _idaapi.TMS2_subk
TMS2_subs = _idaapi.TMS2_subs
TMS2_subt = _idaapi.TMS2_subt
TMS2_sxf = _idaapi.TMS2_sxf
TMS2_tblr = _idaapi.TMS2_tblr
TMS2_tblw = _idaapi.TMS2_tblw
TMS2_trap = _idaapi.TMS2_trap
TMS2_xor = _idaapi.TMS2_xor
TMS2_xork = _idaapi.TMS2_xork
TMS2_zac = _idaapi.TMS2_zac
TMS2_zalh = _idaapi.TMS2_zalh
TMS2_zalr = _idaapi.TMS2_zalr
TMS2_zals = _idaapi.TMS2_zals
TMS_last = _idaapi.TMS_last
M65_null = _idaapi.M65_null
M65_adc = _idaapi.M65_adc
M65_anc = _idaapi.M65_anc
M65_and = _idaapi.M65_and
M65_ane = _idaapi.M65_ane
M65_arr = _idaapi.M65_arr
M65_asl = _idaapi.M65_asl
M65_asr = _idaapi.M65_asr
M65_bcc = _idaapi.M65_bcc
M65_bcs = _idaapi.M65_bcs
M65_beq = _idaapi.M65_beq
M65_bit = _idaapi.M65_bit
M65_bmi = _idaapi.M65_bmi
M65_bne = _idaapi.M65_bne
M65_bpl = _idaapi.M65_bpl
M65_brk = _idaapi.M65_brk
M65_bvc = _idaapi.M65_bvc
M65_bvs = _idaapi.M65_bvs
M65_clc = _idaapi.M65_clc
M65_cld = _idaapi.M65_cld
M65_cli = _idaapi.M65_cli
M65_clv = _idaapi.M65_clv
M65_cmp = _idaapi.M65_cmp
M65_cpx = _idaapi.M65_cpx
M65_cpy = _idaapi.M65_cpy
M65_dcp = _idaapi.M65_dcp
M65_dec = _idaapi.M65_dec
M65_dex = _idaapi.M65_dex
M65_dey = _idaapi.M65_dey
M65_eor = _idaapi.M65_eor
M65_inc = _idaapi.M65_inc
M65_inx = _idaapi.M65_inx
M65_iny = _idaapi.M65_iny
M65_isb = _idaapi.M65_isb
M65_jmp = _idaapi.M65_jmp
M65_jmpi = _idaapi.M65_jmpi
M65_jsr = _idaapi.M65_jsr
M65_lae = _idaapi.M65_lae
M65_lax = _idaapi.M65_lax
M65_lda = _idaapi.M65_lda
M65_ldx = _idaapi.M65_ldx
M65_ldy = _idaapi.M65_ldy
M65_lsr = _idaapi.M65_lsr
M65_lxa = _idaapi.M65_lxa
M65_nop = _idaapi.M65_nop
M65_ora = _idaapi.M65_ora
M65_pha = _idaapi.M65_pha
M65_php = _idaapi.M65_php
M65_pla = _idaapi.M65_pla
M65_plp = _idaapi.M65_plp
M65_rla = _idaapi.M65_rla
M65_rol = _idaapi.M65_rol
M65_ror = _idaapi.M65_ror
M65_rra = _idaapi.M65_rra
M65_rti = _idaapi.M65_rti
M65_rts = _idaapi.M65_rts
M65_sax = _idaapi.M65_sax
M65_sbc = _idaapi.M65_sbc
M65_sbx = _idaapi.M65_sbx
M65_sec = _idaapi.M65_sec
M65_sed = _idaapi.M65_sed
M65_sei = _idaapi.M65_sei
M65_sha = _idaapi.M65_sha
M65_shs = _idaapi.M65_shs
M65_shx = _idaapi.M65_shx
M65_shy = _idaapi.M65_shy
M65_slo = _idaapi.M65_slo
M65_sre = _idaapi.M65_sre
M65_sta = _idaapi.M65_sta
M65_stx = _idaapi.M65_stx
M65_sty = _idaapi.M65_sty
M65_tax = _idaapi.M65_tax
M65_tay = _idaapi.M65_tay
M65_tsx = _idaapi.M65_tsx
M65_txa = _idaapi.M65_txa
M65_txs = _idaapi.M65_txs
M65_tya = _idaapi.M65_tya
M65_bbr0 = _idaapi.M65_bbr0
M65_bbr1 = _idaapi.M65_bbr1
M65_bbr2 = _idaapi.M65_bbr2
M65_bbr3 = _idaapi.M65_bbr3
M65_bbr4 = _idaapi.M65_bbr4
M65_bbr5 = _idaapi.M65_bbr5
M65_bbr6 = _idaapi.M65_bbr6
M65_bbr7 = _idaapi.M65_bbr7
M65_bbs0 = _idaapi.M65_bbs0
M65_bbs1 = _idaapi.M65_bbs1
M65_bbs2 = _idaapi.M65_bbs2
M65_bbs3 = _idaapi.M65_bbs3
M65_bbs4 = _idaapi.M65_bbs4
M65_bbs5 = _idaapi.M65_bbs5
M65_bbs6 = _idaapi.M65_bbs6
M65_bbs7 = _idaapi.M65_bbs7
M65_rmb0 = _idaapi.M65_rmb0
M65_rmb1 = _idaapi.M65_rmb1
M65_rmb2 = _idaapi.M65_rmb2
M65_rmb3 = _idaapi.M65_rmb3
M65_rmb4 = _idaapi.M65_rmb4
M65_rmb5 = _idaapi.M65_rmb5
M65_rmb6 = _idaapi.M65_rmb6
M65_rmb7 = _idaapi.M65_rmb7
M65_smb0 = _idaapi.M65_smb0
M65_smb1 = _idaapi.M65_smb1
M65_smb2 = _idaapi.M65_smb2
M65_smb3 = _idaapi.M65_smb3
M65_smb4 = _idaapi.M65_smb4
M65_smb5 = _idaapi.M65_smb5
M65_smb6 = _idaapi.M65_smb6
M65_smb7 = _idaapi.M65_smb7
M65_stz = _idaapi.M65_stz
M65_tsb = _idaapi.M65_tsb
M65_trb = _idaapi.M65_trb
M65_phy = _idaapi.M65_phy
M65_ply = _idaapi.M65_ply
M65_phx = _idaapi.M65_phx
M65_plx = _idaapi.M65_plx
M65_bra = _idaapi.M65_bra
M65_last = _idaapi.M65_last
M65816_null = _idaapi.M65816_null
M65816_adc = _idaapi.M65816_adc
M65816_and = _idaapi.M65816_and
M65816_asl = _idaapi.M65816_asl
M65816_bcc = _idaapi.M65816_bcc
M65816_bcs = _idaapi.M65816_bcs
M65816_beq = _idaapi.M65816_beq
M65816_bit = _idaapi.M65816_bit
M65816_bmi = _idaapi.M65816_bmi
M65816_bne = _idaapi.M65816_bne
M65816_bpl = _idaapi.M65816_bpl
M65816_bra = _idaapi.M65816_bra
M65816_brk = _idaapi.M65816_brk
M65816_brl = _idaapi.M65816_brl
M65816_bvc = _idaapi.M65816_bvc
M65816_bvs = _idaapi.M65816_bvs
M65816_clc = _idaapi.M65816_clc
M65816_cld = _idaapi.M65816_cld
M65816_cli = _idaapi.M65816_cli
M65816_clv = _idaapi.M65816_clv
M65816_cmp = _idaapi.M65816_cmp
M65816_cop = _idaapi.M65816_cop
M65816_cpx = _idaapi.M65816_cpx
M65816_cpy = _idaapi.M65816_cpy
M65816_dec = _idaapi.M65816_dec
M65816_dex = _idaapi.M65816_dex
M65816_dey = _idaapi.M65816_dey
M65816_eor = _idaapi.M65816_eor
M65816_inc = _idaapi.M65816_inc
M65816_inx = _idaapi.M65816_inx
M65816_iny = _idaapi.M65816_iny
M65816_jml = _idaapi.M65816_jml
M65816_jmp = _idaapi.M65816_jmp
M65816_jsl = _idaapi.M65816_jsl
M65816_jsr = _idaapi.M65816_jsr
M65816_lda = _idaapi.M65816_lda
M65816_ldx = _idaapi.M65816_ldx
M65816_ldy = _idaapi.M65816_ldy
M65816_lsr = _idaapi.M65816_lsr
M65816_mvn = _idaapi.M65816_mvn
M65816_mvp = _idaapi.M65816_mvp
M65816_nop = _idaapi.M65816_nop
M65816_ora = _idaapi.M65816_ora
M65816_pea = _idaapi.M65816_pea
M65816_pei = _idaapi.M65816_pei
M65816_per = _idaapi.M65816_per
M65816_pha = _idaapi.M65816_pha
M65816_phb = _idaapi.M65816_phb
M65816_phd = _idaapi.M65816_phd
M65816_phk = _idaapi.M65816_phk
M65816_php = _idaapi.M65816_php
M65816_phx = _idaapi.M65816_phx
M65816_phy = _idaapi.M65816_phy
M65816_pla = _idaapi.M65816_pla
M65816_plb = _idaapi.M65816_plb
M65816_pld = _idaapi.M65816_pld
M65816_plp = _idaapi.M65816_plp
M65816_plx = _idaapi.M65816_plx
M65816_ply = _idaapi.M65816_ply
M65816_rep = _idaapi.M65816_rep
M65816_rol = _idaapi.M65816_rol
M65816_ror = _idaapi.M65816_ror
M65816_rti = _idaapi.M65816_rti
M65816_rtl = _idaapi.M65816_rtl
M65816_rts = _idaapi.M65816_rts
M65816_sbc = _idaapi.M65816_sbc
M65816_sec = _idaapi.M65816_sec
M65816_sed = _idaapi.M65816_sed
M65816_sei = _idaapi.M65816_sei
M65816_sep = _idaapi.M65816_sep
M65816_sta = _idaapi.M65816_sta
M65816_stp = _idaapi.M65816_stp
M65816_stx = _idaapi.M65816_stx
M65816_sty = _idaapi.M65816_sty
M65816_stz = _idaapi.M65816_stz
M65816_tax = _idaapi.M65816_tax
M65816_tay = _idaapi.M65816_tay
M65816_tcd = _idaapi.M65816_tcd
M65816_tcs = _idaapi.M65816_tcs
M65816_tdc = _idaapi.M65816_tdc
M65816_trb = _idaapi.M65816_trb
M65816_tsb = _idaapi.M65816_tsb
M65816_tsc = _idaapi.M65816_tsc
M65816_tsx = _idaapi.M65816_tsx
M65816_txa = _idaapi.M65816_txa
M65816_txs = _idaapi.M65816_txs
M65816_txy = _idaapi.M65816_txy
M65816_tya = _idaapi.M65816_tya
M65816_tyx = _idaapi.M65816_tyx
M65816_wai = _idaapi.M65816_wai
M65816_wdm = _idaapi.M65816_wdm
M65816_xba = _idaapi.M65816_xba
M65816_xce = _idaapi.M65816_xce
M65816_last = _idaapi.M65816_last
pdp_null = _idaapi.pdp_null
pdp_halt = _idaapi.pdp_halt
pdp_wait = _idaapi.pdp_wait
pdp_rti = _idaapi.pdp_rti
pdp_bpt = _idaapi.pdp_bpt
pdp_iot = _idaapi.pdp_iot
pdp_reset = _idaapi.pdp_reset
pdp_rtt = _idaapi.pdp_rtt
pdp_mfpt = _idaapi.pdp_mfpt
pdp_jmp = _idaapi.pdp_jmp
pdp_rts = _idaapi.pdp_rts
pdp_spl = _idaapi.pdp_spl
pdp_nop = _idaapi.pdp_nop
pdp_clc = _idaapi.pdp_clc
pdp_clv = _idaapi.pdp_clv
pdp_clz = _idaapi.pdp_clz
pdp_cln = _idaapi.pdp_cln
pdp_ccc = _idaapi.pdp_ccc
pdp_sec = _idaapi.pdp_sec
pdp_sev = _idaapi.pdp_sev
pdp_sez = _idaapi.pdp_sez
pdp_sen = _idaapi.pdp_sen
pdp_scc = _idaapi.pdp_scc
pdp_swab = _idaapi.pdp_swab
pdp_br = _idaapi.pdp_br
pdp_bne = _idaapi.pdp_bne
pdp_beq = _idaapi.pdp_beq
pdp_bge = _idaapi.pdp_bge
pdp_blt = _idaapi.pdp_blt
pdp_bgt = _idaapi.pdp_bgt
pdp_ble = _idaapi.pdp_ble
pdp_jsr = _idaapi.pdp_jsr
pdp_clr = _idaapi.pdp_clr
pdp_com = _idaapi.pdp_com
pdp_inc = _idaapi.pdp_inc
pdp_dec = _idaapi.pdp_dec
pdp_neg = _idaapi.pdp_neg
pdp_adc = _idaapi.pdp_adc
pdp_sbc = _idaapi.pdp_sbc
pdp_tst = _idaapi.pdp_tst
pdp_ror = _idaapi.pdp_ror
pdp_rol = _idaapi.pdp_rol
pdp_asr = _idaapi.pdp_asr
pdp_asl = _idaapi.pdp_asl
pdp_mark = _idaapi.pdp_mark
pdp_mfpi = _idaapi.pdp_mfpi
pdp_mtpi = _idaapi.pdp_mtpi
pdp_sxt = _idaapi.pdp_sxt
pdp_mov = _idaapi.pdp_mov
pdp_cmp = _idaapi.pdp_cmp
pdp_bit = _idaapi.pdp_bit
pdp_bic = _idaapi.pdp_bic
pdp_bis = _idaapi.pdp_bis
pdp_add = _idaapi.pdp_add
pdp_sub = _idaapi.pdp_sub
pdp_mul = _idaapi.pdp_mul
pdp_div = _idaapi.pdp_div
pdp_ash = _idaapi.pdp_ash
pdp_ashc = _idaapi.pdp_ashc
pdp_xor = _idaapi.pdp_xor
pdp_fadd = _idaapi.pdp_fadd
pdp_fsub = _idaapi.pdp_fsub
pdp_fmul = _idaapi.pdp_fmul
pdp_fdiv = _idaapi.pdp_fdiv
pdp_sob = _idaapi.pdp_sob
pdp_bpl = _idaapi.pdp_bpl
pdp_bmi = _idaapi.pdp_bmi
pdp_bhi = _idaapi.pdp_bhi
pdp_blos = _idaapi.pdp_blos
pdp_bvc = _idaapi.pdp_bvc
pdp_bvs = _idaapi.pdp_bvs
pdp_bcc = _idaapi.pdp_bcc
pdp_bcs = _idaapi.pdp_bcs
pdp_emt = _idaapi.pdp_emt
pdp_trap = _idaapi.pdp_trap
pdp_mtps = _idaapi.pdp_mtps
pdp_mfpd = _idaapi.pdp_mfpd
pdp_mtpd = _idaapi.pdp_mtpd
pdp_mfps = _idaapi.pdp_mfps
pdp_cfcc = _idaapi.pdp_cfcc
pdp_setf = _idaapi.pdp_setf
pdp_seti = _idaapi.pdp_seti
pdp_setd = _idaapi.pdp_setd
pdp_setl = _idaapi.pdp_setl
pdp_ldfps = _idaapi.pdp_ldfps
pdp_stfps = _idaapi.pdp_stfps
pdp_stst = _idaapi.pdp_stst
pdp_clrd = _idaapi.pdp_clrd
pdp_tstd = _idaapi.pdp_tstd
pdp_absd = _idaapi.pdp_absd
pdp_negd = _idaapi.pdp_negd
pdp_muld = _idaapi.pdp_muld
pdp_modd = _idaapi.pdp_modd
pdp_addd = _idaapi.pdp_addd
pdp_ldd = _idaapi.pdp_ldd
pdp_subd = _idaapi.pdp_subd
pdp_cmpd = _idaapi.pdp_cmpd
pdp_std = _idaapi.pdp_std
pdp_divd = _idaapi.pdp_divd
pdp_stexp = _idaapi.pdp_stexp
pdp_stcdi = _idaapi.pdp_stcdi
pdp_stcdf = _idaapi.pdp_stcdf
pdp_ldexp = _idaapi.pdp_ldexp
pdp_ldcif = _idaapi.pdp_ldcif
pdp_ldcfd = _idaapi.pdp_ldcfd
pdp_call = _idaapi.pdp_call
pdp_return = _idaapi.pdp_return
pdp_compcc = _idaapi.pdp_compcc
pdp_last = _idaapi.pdp_last
mc_null = _idaapi.mc_null
mc_abcd = _idaapi.mc_abcd
mc_add = _idaapi.mc_add
mc_adda = _idaapi.mc_adda
mc_addi = _idaapi.mc_addi
mc_addq = _idaapi.mc_addq
mc_addx = _idaapi.mc_addx
mc_and = _idaapi.mc_and
mc_andi = _idaapi.mc_andi
mc_asl = _idaapi.mc_asl
mc_asr = _idaapi.mc_asr
mc_b = _idaapi.mc_b
mc_bchg = _idaapi.mc_bchg
mc_bclr = _idaapi.mc_bclr
mc_bftst = _idaapi.mc_bftst
mc_bfchg = _idaapi.mc_bfchg
mc_bfclr = _idaapi.mc_bfclr
mc_bfset = _idaapi.mc_bfset
mc_bfextu = _idaapi.mc_bfextu
mc_bfexts = _idaapi.mc_bfexts
mc_bfffo = _idaapi.mc_bfffo
mc_bfins = _idaapi.mc_bfins
mc_bgnd = _idaapi.mc_bgnd
mc_bkpt = _idaapi.mc_bkpt
mc_bra = _idaapi.mc_bra
mc_bset = _idaapi.mc_bset
mc_bsr = _idaapi.mc_bsr
mc_btst = _idaapi.mc_btst
mc_callm = _idaapi.mc_callm
mc_cas = _idaapi.mc_cas
mc_cas2 = _idaapi.mc_cas2
mc_chk = _idaapi.mc_chk
mc_chk2 = _idaapi.mc_chk2
mc_cinv = _idaapi.mc_cinv
mc_clr = _idaapi.mc_clr
mc_cmp = _idaapi.mc_cmp
mc_cmp2 = _idaapi.mc_cmp2
mc_cmpa = _idaapi.mc_cmpa
mc_cmpi = _idaapi.mc_cmpi
mc_cmpm = _idaapi.mc_cmpm
mc_cpush = _idaapi.mc_cpush
mc_db = _idaapi.mc_db
mc_divs = _idaapi.mc_divs
mc_divsl = _idaapi.mc_divsl
mc_divu = _idaapi.mc_divu
mc_divul = _idaapi.mc_divul
mc_eor = _idaapi.mc_eor
mc_eori = _idaapi.mc_eori
mc_exg = _idaapi.mc_exg
mc_ext = _idaapi.mc_ext
mc_extb = _idaapi.mc_extb
mc_fabs = _idaapi.mc_fabs
mc_facos = _idaapi.mc_facos
mc_fadd = _idaapi.mc_fadd
mc_fasin = _idaapi.mc_fasin
mc_fatan = _idaapi.mc_fatan
mc_fatanh = _idaapi.mc_fatanh
mc_fb = _idaapi.mc_fb
mc_fcmp = _idaapi.mc_fcmp
mc_fcos = _idaapi.mc_fcos
mc_fcosh = _idaapi.mc_fcosh
mc_fdabs = _idaapi.mc_fdabs
mc_fdadd = _idaapi.mc_fdadd
mc_fdb = _idaapi.mc_fdb
mc_fddiv = _idaapi.mc_fddiv
mc_fdiv = _idaapi.mc_fdiv
mc_fdmove = _idaapi.mc_fdmove
mc_fdmul = _idaapi.mc_fdmul
mc_fdneg = _idaapi.mc_fdneg
mc_fdsqrt = _idaapi.mc_fdsqrt
mc_fdsub = _idaapi.mc_fdsub
mc_fetox = _idaapi.mc_fetox
mc_fetoxm1 = _idaapi.mc_fetoxm1
mc_fgetexp = _idaapi.mc_fgetexp
mc_fgetman = _idaapi.mc_fgetman
mc_fint = _idaapi.mc_fint
mc_fintrz = _idaapi.mc_fintrz
mc_flog2 = _idaapi.mc_flog2
mc_flog10 = _idaapi.mc_flog10
mc_flogn = _idaapi.mc_flogn
mc_flognp1 = _idaapi.mc_flognp1
mc_fmod = _idaapi.mc_fmod
mc_fmove = _idaapi.mc_fmove
mc_fmovecr = _idaapi.mc_fmovecr
mc_fmovem = _idaapi.mc_fmovem
mc_fmul = _idaapi.mc_fmul
mc_fneg = _idaapi.mc_fneg
mc_fnop = _idaapi.mc_fnop
mc_frem = _idaapi.mc_frem
mc_frestore = _idaapi.mc_frestore
mc_fs = _idaapi.mc_fs
mc_fsabs = _idaapi.mc_fsabs
mc_fsadd = _idaapi.mc_fsadd
mc_fsave = _idaapi.mc_fsave
mc_fscale = _idaapi.mc_fscale
mc_fsdiv = _idaapi.mc_fsdiv
mc_fsgldiv = _idaapi.mc_fsgldiv
mc_fsglmul = _idaapi.mc_fsglmul
mc_fsin = _idaapi.mc_fsin
mc_fsincos = _idaapi.mc_fsincos
mc_fsinh = _idaapi.mc_fsinh
mc_fsmove = _idaapi.mc_fsmove
mc_fsmul = _idaapi.mc_fsmul
mc_fsneg = _idaapi.mc_fsneg
mc_fsqrt = _idaapi.mc_fsqrt
mc_fssqrt = _idaapi.mc_fssqrt
mc_fssub = _idaapi.mc_fssub
mc_fsub = _idaapi.mc_fsub
mc_ftan = _idaapi.mc_ftan
mc_ftanh = _idaapi.mc_ftanh
mc_ftentox = _idaapi.mc_ftentox
mc_ftrap = _idaapi.mc_ftrap
mc_ftst = _idaapi.mc_ftst
mc_ftwotox = _idaapi.mc_ftwotox
mc_halt = _idaapi.mc_halt
mc_illegal = _idaapi.mc_illegal
mc_jmp = _idaapi.mc_jmp
mc_jsr = _idaapi.mc_jsr
mc_lea = _idaapi.mc_lea
mc_link = _idaapi.mc_link
mc_lpstop = _idaapi.mc_lpstop
mc_lsl = _idaapi.mc_lsl
mc_lsr = _idaapi.mc_lsr
mc_mac = _idaapi.mc_mac
mc_macl = _idaapi.mc_macl
mc_move = _idaapi.mc_move
mc_move16 = _idaapi.mc_move16
mc_movea = _idaapi.mc_movea
mc_movec = _idaapi.mc_movec
mc_movem = _idaapi.mc_movem
mc_movep = _idaapi.mc_movep
mc_moveq = _idaapi.mc_moveq
mc_moves = _idaapi.mc_moves
mc_msac = _idaapi.mc_msac
mc_msacl = _idaapi.mc_msacl
mc_muls = _idaapi.mc_muls
mc_mulu = _idaapi.mc_mulu
mc_nbcd = _idaapi.mc_nbcd
mc_neg = _idaapi.mc_neg
mc_negx = _idaapi.mc_negx
mc_nop = _idaapi.mc_nop
mc_not = _idaapi.mc_not
mc_or = _idaapi.mc_or
mc_ori = _idaapi.mc_ori
mc_pack = _idaapi.mc_pack
mc_pea = _idaapi.mc_pea
mc_pb = _idaapi.mc_pb
mc_pdb = _idaapi.mc_pdb
mc_pflush = _idaapi.mc_pflush
mc_pflushr = _idaapi.mc_pflushr
mc_ploadr = _idaapi.mc_ploadr
mc_ploadw = _idaapi.mc_ploadw
mc_pmove = _idaapi.mc_pmove
mc_prestore = _idaapi.mc_prestore
mc_psave = _idaapi.mc_psave
mc_ps = _idaapi.mc_ps
mc_ptestr = _idaapi.mc_ptestr
mc_ptestw = _idaapi.mc_ptestw
mc_ptrap = _idaapi.mc_ptrap
mc_pulse = _idaapi.mc_pulse
mc_pvalid = _idaapi.mc_pvalid
mc_rol = _idaapi.mc_rol
mc_ror = _idaapi.mc_ror
mc_roxl = _idaapi.mc_roxl
mc_roxr = _idaapi.mc_roxr
mc_reset = _idaapi.mc_reset
mc_rtd = _idaapi.mc_rtd
mc_rte = _idaapi.mc_rte
mc_rtm = _idaapi.mc_rtm
mc_rtr = _idaapi.mc_rtr
mc_rts = _idaapi.mc_rts
mc_sbcd = _idaapi.mc_sbcd
mc_s = _idaapi.mc_s
mc_stop = _idaapi.mc_stop
mc_sub = _idaapi.mc_sub
mc_suba = _idaapi.mc_suba
mc_subi = _idaapi.mc_subi
mc_subq = _idaapi.mc_subq
mc_subx = _idaapi.mc_subx
mc_swap = _idaapi.mc_swap
mc_tas = _idaapi.mc_tas
mc_tbl = _idaapi.mc_tbl
mc_trap = _idaapi.mc_trap
mc_trapv = _idaapi.mc_trapv
mc_tst = _idaapi.mc_tst
mc_unlk = _idaapi.mc_unlk
mc_unpk = _idaapi.mc_unpk
mc_wddata = _idaapi.mc_wddata
mc_wdebug = _idaapi.mc_wdebug
mc_atrap = _idaapi.mc_atrap
mc_bitrev = _idaapi.mc_bitrev
mc_byterev = _idaapi.mc_byterev
mc_ff1 = _idaapi.mc_ff1
mc_intouch = _idaapi.mc_intouch
mc_mov3q = _idaapi.mc_mov3q
mc_mvs = _idaapi.mc_mvs
mc_mvz = _idaapi.mc_mvz
mc_sats = _idaapi.mc_sats
mc_movclr = _idaapi.mc_movclr
mc_maaac = _idaapi.mc_maaac
mc_masac = _idaapi.mc_masac
mc_msaac = _idaapi.mc_msaac
mc_mssac = _idaapi.mc_mssac
mc_remsl = _idaapi.mc_remsl
mc_remul = _idaapi.mc_remul
mc_last = _idaapi.mc_last
mc8_null = _idaapi.mc8_null
mc8_aba = _idaapi.mc8_aba
mc8_ab = _idaapi.mc8_ab
mc8_adc = _idaapi.mc8_adc
mc8_add = _idaapi.mc8_add
mc8_addd = _idaapi.mc8_addd
mc8_ais = _idaapi.mc8_ais
mc8_aix = _idaapi.mc8_aix
mc8_and = _idaapi.mc8_and
mc8_andcc = _idaapi.mc8_andcc
mc8_asr = _idaapi.mc8_asr
mc8_bcc = _idaapi.mc8_bcc
mc8_bclr = _idaapi.mc8_bclr
mc8_bcs = _idaapi.mc8_bcs
mc8_beq = _idaapi.mc8_beq
mc8_bge = _idaapi.mc8_bge
mc8_bgt = _idaapi.mc8_bgt
mc8_bhcc = _idaapi.mc8_bhcc
mc8_bhcs = _idaapi.mc8_bhcs
mc8_bhi = _idaapi.mc8_bhi
mc8_bhs = _idaapi.mc8_bhs
mc8_bih = _idaapi.mc8_bih
mc8_bil = _idaapi.mc8_bil
mc8_bit = _idaapi.mc8_bit
mc8_ble = _idaapi.mc8_ble
mc8_blo = _idaapi.mc8_blo
mc8_bls = _idaapi.mc8_bls
mc8_blt = _idaapi.mc8_blt
mc8_bmc = _idaapi.mc8_bmc
mc8_bmi = _idaapi.mc8_bmi
mc8_bms = _idaapi.mc8_bms
mc8_bne = _idaapi.mc8_bne
mc8_bpl = _idaapi.mc8_bpl
mc8_bra = _idaapi.mc8_bra
mc8_brclr = _idaapi.mc8_brclr
mc8_brn = _idaapi.mc8_brn
mc8_brset = _idaapi.mc8_brset
mc8_bset = _idaapi.mc8_bset
mc8_bsr = _idaapi.mc8_bsr
mc8_bvc = _idaapi.mc8_bvc
mc8_bvs = _idaapi.mc8_bvs
mc8_cba = _idaapi.mc8_cba
mc8_cbeq = _idaapi.mc8_cbeq
mc8_clc = _idaapi.mc8_clc
mc8_cli = _idaapi.mc8_cli
mc8_clr = _idaapi.mc8_clr
mc8_clv = _idaapi.mc8_clv
mc8_cmp = _idaapi.mc8_cmp
mc8_com = _idaapi.mc8_com
mc8_cp = _idaapi.mc8_cp
mc8_cpd = _idaapi.mc8_cpd
mc8_cphx = _idaapi.mc8_cphx
mc8_cpx = _idaapi.mc8_cpx
mc8_cwai = _idaapi.mc8_cwai
mc8_daa = _idaapi.mc8_daa
mc8_dbnz = _idaapi.mc8_dbnz
mc8_de = _idaapi.mc8_de
mc8_dec = _idaapi.mc8_dec
mc8_des = _idaapi.mc8_des
mc8_div = _idaapi.mc8_div
mc8_eor = _idaapi.mc8_eor
mc8_exg = _idaapi.mc8_exg
mc8_fdiv = _idaapi.mc8_fdiv
mc8_idiv = _idaapi.mc8_idiv
mc8_in = _idaapi.mc8_in
mc8_inc = _idaapi.mc8_inc
mc8_ins = _idaapi.mc8_ins
mc8_jmp = _idaapi.mc8_jmp
mc8_jsr = _idaapi.mc8_jsr
mc8_ld = _idaapi.mc8_ld
mc8_lda = _idaapi.mc8_lda
mc8_ldd = _idaapi.mc8_ldd
mc8_ldhx = _idaapi.mc8_ldhx
mc8_lds = _idaapi.mc8_lds
mc8_ldx = _idaapi.mc8_ldx
mc8_lea = _idaapi.mc8_lea
mc8_lsl = _idaapi.mc8_lsl
mc8_lsld = _idaapi.mc8_lsld
mc8_lsr = _idaapi.mc8_lsr
mc8_lsrd = _idaapi.mc8_lsrd
mc8_mov = _idaapi.mc8_mov
mc8_mul = _idaapi.mc8_mul
mc8_neg = _idaapi.mc8_neg
mc8_nop = _idaapi.mc8_nop
mc8_nsa = _idaapi.mc8_nsa
mc8_ora = _idaapi.mc8_ora
mc8_orcc = _idaapi.mc8_orcc
mc8_psh = _idaapi.mc8_psh
mc8_psha = _idaapi.mc8_psha
mc8_pshb = _idaapi.mc8_pshb
mc8_pshh = _idaapi.mc8_pshh
mc8_pshx = _idaapi.mc8_pshx
mc8_pul = _idaapi.mc8_pul
mc8_pula = _idaapi.mc8_pula
mc8_pulb = _idaapi.mc8_pulb
mc8_pulh = _idaapi.mc8_pulh
mc8_pulx = _idaapi.mc8_pulx
mc8_rol = _idaapi.mc8_rol
mc8_ror = _idaapi.mc8_ror
mc8_rsp = _idaapi.mc8_rsp
mc8_rti = _idaapi.mc8_rti
mc8_rts = _idaapi.mc8_rts
mc8_sba = _idaapi.mc8_sba
mc8_sbc = _idaapi.mc8_sbc
mc8_sec = _idaapi.mc8_sec
mc8_sei = _idaapi.mc8_sei
mc8_sev = _idaapi.mc8_sev
mc8_sex = _idaapi.mc8_sex
mc8_slp = _idaapi.mc8_slp
mc8_st = _idaapi.mc8_st
mc8_sta = _idaapi.mc8_sta
mc8_std = _idaapi.mc8_std
mc8_sthx = _idaapi.mc8_sthx
mc8_stop = _idaapi.mc8_stop
mc8_sts = _idaapi.mc8_sts
mc8_stx = _idaapi.mc8_stx
mc8_sub = _idaapi.mc8_sub
mc8_subd = _idaapi.mc8_subd
mc8_swi = _idaapi.mc8_swi
mc8_sync = _idaapi.mc8_sync
mc8_tab = _idaapi.mc8_tab
mc8_tap = _idaapi.mc8_tap
mc8_tax = _idaapi.mc8_tax
mc8_tba = _idaapi.mc8_tba
mc8_test = _idaapi.mc8_test
mc8_tfr = _idaapi.mc8_tfr
mc8_tpa = _idaapi.mc8_tpa
mc8_ts = _idaapi.mc8_ts
mc8_tst = _idaapi.mc8_tst
mc8_tsx = _idaapi.mc8_tsx
mc8_txa = _idaapi.mc8_txa
mc8_txs = _idaapi.mc8_txs
mc8_tys = _idaapi.mc8_tys
mc8_wai = _idaapi.mc8_wai
mc8_wait = _idaapi.mc8_wait
mc8_xgd = _idaapi.mc8_xgd
mc8_1 = _idaapi.mc8_1
mc8_2 = _idaapi.mc8_2
mc8_os9 = _idaapi.mc8_os9
mc8_aim = _idaapi.mc8_aim
mc8_oim = _idaapi.mc8_oim
mc8_eim = _idaapi.mc8_eim
mc8_tim = _idaapi.mc8_tim
mc8_bgnd = _idaapi.mc8_bgnd
mc8_call = _idaapi.mc8_call
mc8_rtc = _idaapi.mc8_rtc
mc8_skip1 = _idaapi.mc8_skip1
mc8_skip2 = _idaapi.mc8_skip2
mc8_last = _idaapi.mc8_last
j_nop = _idaapi.j_nop
j_aconst_null = _idaapi.j_aconst_null
j_iconst_m1 = _idaapi.j_iconst_m1
j_iconst_0 = _idaapi.j_iconst_0
j_iconst_1 = _idaapi.j_iconst_1
j_iconst_2 = _idaapi.j_iconst_2
j_iconst_3 = _idaapi.j_iconst_3
j_iconst_4 = _idaapi.j_iconst_4
j_iconst_5 = _idaapi.j_iconst_5
j_lconst_0 = _idaapi.j_lconst_0
j_lconst_1 = _idaapi.j_lconst_1
j_fconst_0 = _idaapi.j_fconst_0
j_fconst_1 = _idaapi.j_fconst_1
j_fconst_2 = _idaapi.j_fconst_2
j_dconst_0 = _idaapi.j_dconst_0
j_dconst_1 = _idaapi.j_dconst_1
j_bipush = _idaapi.j_bipush
j_sipush = _idaapi.j_sipush
j_ldc = _idaapi.j_ldc
j_ldcw = _idaapi.j_ldcw
j_ldc2w = _idaapi.j_ldc2w
j_iload = _idaapi.j_iload
j_lload = _idaapi.j_lload
j_fload = _idaapi.j_fload
j_dload = _idaapi.j_dload
j_aload = _idaapi.j_aload
j_iload_0 = _idaapi.j_iload_0
j_iload_1 = _idaapi.j_iload_1
j_iload_2 = _idaapi.j_iload_2
j_iload_3 = _idaapi.j_iload_3
j_lload_0 = _idaapi.j_lload_0
j_lload_1 = _idaapi.j_lload_1
j_lload_2 = _idaapi.j_lload_2
j_lload_3 = _idaapi.j_lload_3
j_fload_0 = _idaapi.j_fload_0
j_fload_1 = _idaapi.j_fload_1
j_fload_2 = _idaapi.j_fload_2
j_fload_3 = _idaapi.j_fload_3
j_dload_0 = _idaapi.j_dload_0
j_dload_1 = _idaapi.j_dload_1
j_dload_2 = _idaapi.j_dload_2
j_dload_3 = _idaapi.j_dload_3
j_aload_0 = _idaapi.j_aload_0
j_aload_1 = _idaapi.j_aload_1
j_aload_2 = _idaapi.j_aload_2
j_aload_3 = _idaapi.j_aload_3
j_iaload = _idaapi.j_iaload
j_laload = _idaapi.j_laload
j_faload = _idaapi.j_faload
j_daload = _idaapi.j_daload
j_aaload = _idaapi.j_aaload
j_baload = _idaapi.j_baload
j_caload = _idaapi.j_caload
j_saload = _idaapi.j_saload
j_istore = _idaapi.j_istore
j_lstore = _idaapi.j_lstore
j_fstore = _idaapi.j_fstore
j_dstore = _idaapi.j_dstore
j_astore = _idaapi.j_astore
j_istore_0 = _idaapi.j_istore_0
j_istore_1 = _idaapi.j_istore_1
j_istore_2 = _idaapi.j_istore_2
j_istore_3 = _idaapi.j_istore_3
j_lstore_0 = _idaapi.j_lstore_0
j_lstore_1 = _idaapi.j_lstore_1
j_lstore_2 = _idaapi.j_lstore_2
j_lstore_3 = _idaapi.j_lstore_3
j_fstore_0 = _idaapi.j_fstore_0
j_fstore_1 = _idaapi.j_fstore_1
j_fstore_2 = _idaapi.j_fstore_2
j_fstore_3 = _idaapi.j_fstore_3
j_dstore_0 = _idaapi.j_dstore_0
j_dstore_1 = _idaapi.j_dstore_1
j_dstore_2 = _idaapi.j_dstore_2
j_dstore_3 = _idaapi.j_dstore_3
j_astore_0 = _idaapi.j_astore_0
j_astore_1 = _idaapi.j_astore_1
j_astore_2 = _idaapi.j_astore_2
j_astore_3 = _idaapi.j_astore_3
j_iastore = _idaapi.j_iastore
j_lastore = _idaapi.j_lastore
j_fastore = _idaapi.j_fastore
j_dastore = _idaapi.j_dastore
j_aastore = _idaapi.j_aastore
j_bastore = _idaapi.j_bastore
j_castore = _idaapi.j_castore
j_sastore = _idaapi.j_sastore
j_pop = _idaapi.j_pop
j_pop2 = _idaapi.j_pop2
j_dup = _idaapi.j_dup
j_dup_x1 = _idaapi.j_dup_x1
j_dup_x2 = _idaapi.j_dup_x2
j_dup2 = _idaapi.j_dup2
j_dup2_x1 = _idaapi.j_dup2_x1
j_dup2_x2 = _idaapi.j_dup2_x2
j_swap = _idaapi.j_swap
j_iadd = _idaapi.j_iadd
j_ladd = _idaapi.j_ladd
j_fadd = _idaapi.j_fadd
j_dadd = _idaapi.j_dadd
j_isub = _idaapi.j_isub
j_lsub = _idaapi.j_lsub
j_fsub = _idaapi.j_fsub
j_dsub = _idaapi.j_dsub
j_imul = _idaapi.j_imul
j_lmul = _idaapi.j_lmul
j_fmul = _idaapi.j_fmul
j_dmul = _idaapi.j_dmul
j_idiv = _idaapi.j_idiv
j_ldiv = _idaapi.j_ldiv
j_fdiv = _idaapi.j_fdiv
j_ddiv = _idaapi.j_ddiv
j_irem = _idaapi.j_irem
j_lrem = _idaapi.j_lrem
j_frem = _idaapi.j_frem
j_drem = _idaapi.j_drem
j_ineg = _idaapi.j_ineg
j_lneg = _idaapi.j_lneg
j_fneg = _idaapi.j_fneg
j_dneg = _idaapi.j_dneg
j_ishl = _idaapi.j_ishl
j_lshl = _idaapi.j_lshl
j_ishr = _idaapi.j_ishr
j_lshr = _idaapi.j_lshr
j_iushr = _idaapi.j_iushr
j_lushr = _idaapi.j_lushr
j_iand = _idaapi.j_iand
j_land = _idaapi.j_land
j_ior = _idaapi.j_ior
j_lor = _idaapi.j_lor
j_ixor = _idaapi.j_ixor
j_lxor = _idaapi.j_lxor
j_iinc = _idaapi.j_iinc
j_i2l = _idaapi.j_i2l
j_i2f = _idaapi.j_i2f
j_i2d = _idaapi.j_i2d
j_l2i = _idaapi.j_l2i
j_l2f = _idaapi.j_l2f
j_l2d = _idaapi.j_l2d
j_f2i = _idaapi.j_f2i
j_f2l = _idaapi.j_f2l
j_f2d = _idaapi.j_f2d
j_d2i = _idaapi.j_d2i
j_d2l = _idaapi.j_d2l
j_d2f = _idaapi.j_d2f
j_i2b = _idaapi.j_i2b
j_i2c = _idaapi.j_i2c
j_i2s = _idaapi.j_i2s
j_lcmp = _idaapi.j_lcmp
j_fcmpl = _idaapi.j_fcmpl
j_fcmpg = _idaapi.j_fcmpg
j_dcmpl = _idaapi.j_dcmpl
j_dcmpg = _idaapi.j_dcmpg
j_ifeq = _idaapi.j_ifeq
j_ifne = _idaapi.j_ifne
j_iflt = _idaapi.j_iflt
j_ifge = _idaapi.j_ifge
j_ifgt = _idaapi.j_ifgt
j_ifle = _idaapi.j_ifle
j_if_icmpeq = _idaapi.j_if_icmpeq
j_if_icmpne = _idaapi.j_if_icmpne
j_if_icmplt = _idaapi.j_if_icmplt
j_if_icmpge = _idaapi.j_if_icmpge
j_if_icmpgt = _idaapi.j_if_icmpgt
j_if_icmple = _idaapi.j_if_icmple
j_if_acmpeq = _idaapi.j_if_acmpeq
j_if_acmpne = _idaapi.j_if_acmpne
j_goto = _idaapi.j_goto
j_jsr = _idaapi.j_jsr
j_ret = _idaapi.j_ret
j_tableswitch = _idaapi.j_tableswitch
j_lookupswitch = _idaapi.j_lookupswitch
j_ireturn = _idaapi.j_ireturn
j_lreturn = _idaapi.j_lreturn
j_freturn = _idaapi.j_freturn
j_dreturn = _idaapi.j_dreturn
j_areturn = _idaapi.j_areturn
j_return = _idaapi.j_return
j_getstatic = _idaapi.j_getstatic
j_putstatic = _idaapi.j_putstatic
j_getfield = _idaapi.j_getfield
j_putfield = _idaapi.j_putfield
j_invokevirtual = _idaapi.j_invokevirtual
j_invokespecial = _idaapi.j_invokespecial
j_invokestatic = _idaapi.j_invokestatic
j_invokeinterface = _idaapi.j_invokeinterface
j_invokedynamic = _idaapi.j_invokedynamic
j_new = _idaapi.j_new
j_newarray = _idaapi.j_newarray
j_anewarray = _idaapi.j_anewarray
j_arraylength = _idaapi.j_arraylength
j_athrow = _idaapi.j_athrow
j_checkcast = _idaapi.j_checkcast
j_instanceof = _idaapi.j_instanceof
j_monitorenter = _idaapi.j_monitorenter
j_monitorexit = _idaapi.j_monitorexit
j_wide = _idaapi.j_wide
j_multianewarray = _idaapi.j_multianewarray
j_ifnull = _idaapi.j_ifnull
j_ifnonnull = _idaapi.j_ifnonnull
j_goto_w = _idaapi.j_goto_w
j_jsr_w = _idaapi.j_jsr_w
j_breakpoint = _idaapi.j_breakpoint
j_lastnorm = _idaapi.j_lastnorm
j_a_invokesuper = _idaapi.j_a_invokesuper
j_a_invokevirtualobject = _idaapi.j_a_invokevirtualobject
j_a_invokeignored = _idaapi.j_a_invokeignored
j_a_software = _idaapi.j_a_software
j_a_hardware = _idaapi.j_a_hardware
j_last = _idaapi.j_last
j_ldc_quick = _idaapi.j_ldc_quick
j_ldcw_quick = _idaapi.j_ldcw_quick
j_ldc2w_quick = _idaapi.j_ldc2w_quick
j_getfield_quick = _idaapi.j_getfield_quick
j_putfield_quick = _idaapi.j_putfield_quick
j_getfield2_quick = _idaapi.j_getfield2_quick
j_putfield2_quick = _idaapi.j_putfield2_quick
j_getstatic_quick = _idaapi.j_getstatic_quick
j_putstatic_quick = _idaapi.j_putstatic_quick
j_getstatic2_quick = _idaapi.j_getstatic2_quick
j_putstatic2_quick = _idaapi.j_putstatic2_quick
j_invokevirtual_quick = _idaapi.j_invokevirtual_quick
j_invokenonvirtual_quick = _idaapi.j_invokenonvirtual_quick
j_invokesuper_quick = _idaapi.j_invokesuper_quick
j_invokestatic_quick = _idaapi.j_invokestatic_quick
j_invokeinterface_quick = _idaapi.j_invokeinterface_quick
j_invokevirtualobject_quick = _idaapi.j_invokevirtualobject_quick
j_invokeignored_quick = _idaapi.j_invokeignored_quick
j_new_quick = _idaapi.j_new_quick
j_anewarray_quick = _idaapi.j_anewarray_quick
j_multianewarray_quick = _idaapi.j_multianewarray_quick
j_checkcast_quick = _idaapi.j_checkcast_quick
j_instanceof_quick = _idaapi.j_instanceof_quick
j_invokevirtual_quick_w = _idaapi.j_invokevirtual_quick_w
j_getfield_quick_w = _idaapi.j_getfield_quick_w
j_putfield_quick_w = _idaapi.j_putfield_quick_w
j_quick_last = _idaapi.j_quick_last
ARM_null = _idaapi.ARM_null
ARM_ret = _idaapi.ARM_ret
ARM_nop = _idaapi.ARM_nop
ARM_b = _idaapi.ARM_b
ARM_bl = _idaapi.ARM_bl
ARM_asr = _idaapi.ARM_asr
ARM_lsl = _idaapi.ARM_lsl
ARM_lsr = _idaapi.ARM_lsr
ARM_ror = _idaapi.ARM_ror
ARM_neg = _idaapi.ARM_neg
ARM_and = _idaapi.ARM_and
ARM_eor = _idaapi.ARM_eor
ARM_sub = _idaapi.ARM_sub
ARM_rsb = _idaapi.ARM_rsb
ARM_add = _idaapi.ARM_add
ARM_adc = _idaapi.ARM_adc
ARM_sbc = _idaapi.ARM_sbc
ARM_rsc = _idaapi.ARM_rsc
ARM_tst = _idaapi.ARM_tst
ARM_teq = _idaapi.ARM_teq
ARM_cmp = _idaapi.ARM_cmp
ARM_cmn = _idaapi.ARM_cmn
ARM_orr = _idaapi.ARM_orr
ARM_mov = _idaapi.ARM_mov
ARM_bic = _idaapi.ARM_bic
ARM_mvn = _idaapi.ARM_mvn
ARM_mrs = _idaapi.ARM_mrs
ARM_msr = _idaapi.ARM_msr
ARM_mul = _idaapi.ARM_mul
ARM_mla = _idaapi.ARM_mla
ARM_ldr = _idaapi.ARM_ldr
ARM_ldrpc = _idaapi.ARM_ldrpc
ARM_str = _idaapi.ARM_str
ARM_ldm = _idaapi.ARM_ldm
ARM_stm = _idaapi.ARM_stm
ARM_swp = _idaapi.ARM_swp
ARM_svc = _idaapi.ARM_svc
ARM_smull = _idaapi.ARM_smull
ARM_smlal = _idaapi.ARM_smlal
ARM_umull = _idaapi.ARM_umull
ARM_umlal = _idaapi.ARM_umlal
ARM_bx = _idaapi.ARM_bx
ARM_pop = _idaapi.ARM_pop
ARM_push = _idaapi.ARM_push
ARM_adr = _idaapi.ARM_adr
ARM_bkpt = _idaapi.ARM_bkpt
ARM_blx1 = _idaapi.ARM_blx1
ARM_blx2 = _idaapi.ARM_blx2
ARM_clz = _idaapi.ARM_clz
ARM_ldrd = _idaapi.ARM_ldrd
ARM_pld = _idaapi.ARM_pld
ARM_qadd = _idaapi.ARM_qadd
ARM_qdadd = _idaapi.ARM_qdadd
ARM_qdsub = _idaapi.ARM_qdsub
ARM_qsub = _idaapi.ARM_qsub
ARM_smlabb = _idaapi.ARM_smlabb
ARM_smlatb = _idaapi.ARM_smlatb
ARM_smlabt = _idaapi.ARM_smlabt
ARM_smlatt = _idaapi.ARM_smlatt
ARM_smlalbb = _idaapi.ARM_smlalbb
ARM_smlaltb = _idaapi.ARM_smlaltb
ARM_smlalbt = _idaapi.ARM_smlalbt
ARM_smlaltt = _idaapi.ARM_smlaltt
ARM_smlawb = _idaapi.ARM_smlawb
ARM_smulwb = _idaapi.ARM_smulwb
ARM_smlawt = _idaapi.ARM_smlawt
ARM_smulwt = _idaapi.ARM_smulwt
ARM_smulbb = _idaapi.ARM_smulbb
ARM_smultb = _idaapi.ARM_smultb
ARM_smulbt = _idaapi.ARM_smulbt
ARM_smultt = _idaapi.ARM_smultt
ARM_strd = _idaapi.ARM_strd
xScale_mia = _idaapi.xScale_mia
xScale_miaph = _idaapi.xScale_miaph
xScale_miabb = _idaapi.xScale_miabb
xScale_miabt = _idaapi.xScale_miabt
xScale_miatb = _idaapi.xScale_miatb
xScale_miatt = _idaapi.xScale_miatt
xScale_mar = _idaapi.xScale_mar
xScale_mra = _idaapi.xScale_mra
ARM_movl = _idaapi.ARM_movl
ARM_adrl = _idaapi.ARM_adrl
ARM_swbkpt = _idaapi.ARM_swbkpt
ARM_cdp = _idaapi.ARM_cdp
ARM_cdp2 = _idaapi.ARM_cdp2
ARM_ldc = _idaapi.ARM_ldc
ARM_ldc2 = _idaapi.ARM_ldc2
ARM_stc = _idaapi.ARM_stc
ARM_stc2 = _idaapi.ARM_stc2
ARM_mrc = _idaapi.ARM_mrc
ARM_mrc2 = _idaapi.ARM_mrc2
ARM_mcr = _idaapi.ARM_mcr
ARM_mcr2 = _idaapi.ARM_mcr2
ARM_mcrr = _idaapi.ARM_mcrr
ARM_mrrc = _idaapi.ARM_mrrc
ARM_fabsd = _idaapi.ARM_fabsd
ARM_fabss = _idaapi.ARM_fabss
ARM_faddd = _idaapi.ARM_faddd
ARM_fadds = _idaapi.ARM_fadds
ARM_fcmpd = _idaapi.ARM_fcmpd
ARM_fcmps = _idaapi.ARM_fcmps
ARM_fcmped = _idaapi.ARM_fcmped
ARM_fcmpes = _idaapi.ARM_fcmpes
ARM_fcmpezd = _idaapi.ARM_fcmpezd
ARM_fcmpezs = _idaapi.ARM_fcmpezs
ARM_fcmpzd = _idaapi.ARM_fcmpzd
ARM_fcmpzs = _idaapi.ARM_fcmpzs
ARM_fcpyd = _idaapi.ARM_fcpyd
ARM_fcpys = _idaapi.ARM_fcpys
ARM_fcvtsd = _idaapi.ARM_fcvtsd
ARM_fcvtds = _idaapi.ARM_fcvtds
ARM_fdivd = _idaapi.ARM_fdivd
ARM_fdivs = _idaapi.ARM_fdivs
ARM_fldd = _idaapi.ARM_fldd
ARM_flds = _idaapi.ARM_flds
ARM_fldmd = _idaapi.ARM_fldmd
ARM_fldms = _idaapi.ARM_fldms
ARM_fldmx = _idaapi.ARM_fldmx
ARM_fmacd = _idaapi.ARM_fmacd
ARM_fmacs = _idaapi.ARM_fmacs
ARM_fmscd = _idaapi.ARM_fmscd
ARM_fmscs = _idaapi.ARM_fmscs
ARM_fmstat = _idaapi.ARM_fmstat
ARM_fmuld = _idaapi.ARM_fmuld
ARM_fmuls = _idaapi.ARM_fmuls
ARM_fnegd = _idaapi.ARM_fnegd
ARM_fnegs = _idaapi.ARM_fnegs
ARM_fnmacd = _idaapi.ARM_fnmacd
ARM_fnmacs = _idaapi.ARM_fnmacs
ARM_fnmscd = _idaapi.ARM_fnmscd
ARM_fnmscs = _idaapi.ARM_fnmscs
ARM_fnmuld = _idaapi.ARM_fnmuld
ARM_fnmuls = _idaapi.ARM_fnmuls
ARM_fsitod = _idaapi.ARM_fsitod
ARM_fsitos = _idaapi.ARM_fsitos
ARM_fsqrtd = _idaapi.ARM_fsqrtd
ARM_fsqrts = _idaapi.ARM_fsqrts
ARM_fstd = _idaapi.ARM_fstd
ARM_fsts = _idaapi.ARM_fsts
ARM_fstmd = _idaapi.ARM_fstmd
ARM_fstms = _idaapi.ARM_fstms
ARM_fstmx = _idaapi.ARM_fstmx
ARM_fsubd = _idaapi.ARM_fsubd
ARM_fsubs = _idaapi.ARM_fsubs
ARM_ftosid = _idaapi.ARM_ftosid
ARM_ftosis = _idaapi.ARM_ftosis
ARM_ftosizd = _idaapi.ARM_ftosizd
ARM_ftosizs = _idaapi.ARM_ftosizs
ARM_ftouid = _idaapi.ARM_ftouid
ARM_ftouis = _idaapi.ARM_ftouis
ARM_ftouizd = _idaapi.ARM_ftouizd
ARM_ftouizs = _idaapi.ARM_ftouizs
ARM_fuitod = _idaapi.ARM_fuitod
ARM_fuitos = _idaapi.ARM_fuitos
ARM_fmdhr = _idaapi.ARM_fmdhr
ARM_fmrdh = _idaapi.ARM_fmrdh
ARM_fmdlr = _idaapi.ARM_fmdlr
ARM_fmrdl = _idaapi.ARM_fmrdl
ARM_fmxr = _idaapi.ARM_fmxr
ARM_fmrx = _idaapi.ARM_fmrx
ARM_fmsr = _idaapi.ARM_fmsr
ARM_fmrs = _idaapi.ARM_fmrs
ARM_fmdrr = _idaapi.ARM_fmdrr
ARM_fmrrd = _idaapi.ARM_fmrrd
ARM_fmsrr = _idaapi.ARM_fmsrr
ARM_fmrrs = _idaapi.ARM_fmrrs
ARM_bxj = _idaapi.ARM_bxj
ARM_mcrr2 = _idaapi.ARM_mcrr2
ARM_mrrc2 = _idaapi.ARM_mrrc2
ARM_cps = _idaapi.ARM_cps
ARM_cpsid = _idaapi.ARM_cpsid
ARM_cpsie = _idaapi.ARM_cpsie
ARM_ldrex = _idaapi.ARM_ldrex
ARM_pkhbt = _idaapi.ARM_pkhbt
ARM_pkhtb = _idaapi.ARM_pkhtb
ARM_qadd16 = _idaapi.ARM_qadd16
ARM_qadd8 = _idaapi.ARM_qadd8
ARM_qaddsubx = _idaapi.ARM_qaddsubx
ARM_qsub16 = _idaapi.ARM_qsub16
ARM_qsub8 = _idaapi.ARM_qsub8
ARM_qsubaddx = _idaapi.ARM_qsubaddx
ARM_rev = _idaapi.ARM_rev
ARM_rev16 = _idaapi.ARM_rev16
ARM_revsh = _idaapi.ARM_revsh
ARM_rfe = _idaapi.ARM_rfe
ARM_sadd16 = _idaapi.ARM_sadd16
ARM_sadd8 = _idaapi.ARM_sadd8
ARM_saddsubx = _idaapi.ARM_saddsubx
ARM_sel = _idaapi.ARM_sel
ARM_setend = _idaapi.ARM_setend
ARM_shadd16 = _idaapi.ARM_shadd16
ARM_shadd8 = _idaapi.ARM_shadd8
ARM_shaddsubx = _idaapi.ARM_shaddsubx
ARM_shsub16 = _idaapi.ARM_shsub16
ARM_shsub8 = _idaapi.ARM_shsub8
ARM_shsubaddx = _idaapi.ARM_shsubaddx
ARM_smlad = _idaapi.ARM_smlad
ARM_smladx = _idaapi.ARM_smladx
ARM_smuad = _idaapi.ARM_smuad
ARM_smuadx = _idaapi.ARM_smuadx
ARM_smlald = _idaapi.ARM_smlald
ARM_smlaldx = _idaapi.ARM_smlaldx
ARM_smlsd = _idaapi.ARM_smlsd
ARM_smlsdx = _idaapi.ARM_smlsdx
ARM_smusd = _idaapi.ARM_smusd
ARM_smusdx = _idaapi.ARM_smusdx
ARM_smlsld = _idaapi.ARM_smlsld
ARM_smlsldx = _idaapi.ARM_smlsldx
ARM_smmla = _idaapi.ARM_smmla
ARM_smmlar = _idaapi.ARM_smmlar
ARM_smmul = _idaapi.ARM_smmul
ARM_smmulr = _idaapi.ARM_smmulr
ARM_smmls = _idaapi.ARM_smmls
ARM_smmlsr = _idaapi.ARM_smmlsr
ARM_srs = _idaapi.ARM_srs
ARM_ssat = _idaapi.ARM_ssat
ARM_ssat16 = _idaapi.ARM_ssat16
ARM_ssub16 = _idaapi.ARM_ssub16
ARM_ssub8 = _idaapi.ARM_ssub8
ARM_ssubaddx = _idaapi.ARM_ssubaddx
ARM_strex = _idaapi.ARM_strex
ARM_sxtab = _idaapi.ARM_sxtab
ARM_sxtb = _idaapi.ARM_sxtb
ARM_sxtab16 = _idaapi.ARM_sxtab16
ARM_sxtb16 = _idaapi.ARM_sxtb16
ARM_sxtah = _idaapi.ARM_sxtah
ARM_sxth = _idaapi.ARM_sxth
ARM_uadd16 = _idaapi.ARM_uadd16
ARM_uadd8 = _idaapi.ARM_uadd8
ARM_uaddsubx = _idaapi.ARM_uaddsubx
ARM_uhadd16 = _idaapi.ARM_uhadd16
ARM_uhadd8 = _idaapi.ARM_uhadd8
ARM_uhaddsubx = _idaapi.ARM_uhaddsubx
ARM_uhsub16 = _idaapi.ARM_uhsub16
ARM_uhsub8 = _idaapi.ARM_uhsub8
ARM_uhsubaddx = _idaapi.ARM_uhsubaddx
ARM_umaal = _idaapi.ARM_umaal
ARM_uqadd16 = _idaapi.ARM_uqadd16
ARM_uqadd8 = _idaapi.ARM_uqadd8
ARM_uqaddsubx = _idaapi.ARM_uqaddsubx
ARM_uqsub16 = _idaapi.ARM_uqsub16
ARM_uqsub8 = _idaapi.ARM_uqsub8
ARM_uqsubaddx = _idaapi.ARM_uqsubaddx
ARM_usada8 = _idaapi.ARM_usada8
ARM_usad8 = _idaapi.ARM_usad8
ARM_usat = _idaapi.ARM_usat
ARM_usat16 = _idaapi.ARM_usat16
ARM_usub16 = _idaapi.ARM_usub16
ARM_usub8 = _idaapi.ARM_usub8
ARM_usubaddx = _idaapi.ARM_usubaddx
ARM_uxtab = _idaapi.ARM_uxtab
ARM_uxtb = _idaapi.ARM_uxtb
ARM_uxtab16 = _idaapi.ARM_uxtab16
ARM_uxtb16 = _idaapi.ARM_uxtb16
ARM_uxtah = _idaapi.ARM_uxtah
ARM_uxth = _idaapi.ARM_uxth
ARM_clrex = _idaapi.ARM_clrex
ARM_ldrexb = _idaapi.ARM_ldrexb
ARM_ldrexd = _idaapi.ARM_ldrexd
ARM_ldrexh = _idaapi.ARM_ldrexh
ARM_strexb = _idaapi.ARM_strexb
ARM_strexd = _idaapi.ARM_strexd
ARM_strexh = _idaapi.ARM_strexh
ARM_yield = _idaapi.ARM_yield
ARM_sev = _idaapi.ARM_sev
ARM_wfe = _idaapi.ARM_wfe
ARM_wfi = _idaapi.ARM_wfi
ARM_smc = _idaapi.ARM_smc
ARM_orn = _idaapi.ARM_orn
ARM_movt = _idaapi.ARM_movt
ARM_sbfx = _idaapi.ARM_sbfx
ARM_ubfx = _idaapi.ARM_ubfx
ARM_bfi = _idaapi.ARM_bfi
ARM_bfc = _idaapi.ARM_bfc
ARM_tbb = _idaapi.ARM_tbb
ARM_tbh = _idaapi.ARM_tbh
ARM_pli = _idaapi.ARM_pli
ARM_rbit = _idaapi.ARM_rbit
ARM_it = _idaapi.ARM_it
ARM_mls = _idaapi.ARM_mls
ARM_sdiv = _idaapi.ARM_sdiv
ARM_udiv = _idaapi.ARM_udiv
ARM_cbz = _idaapi.ARM_cbz
ARM_cbnz = _idaapi.ARM_cbnz
ARM_dsb = _idaapi.ARM_dsb
ARM_dmb = _idaapi.ARM_dmb
ARM_isb = _idaapi.ARM_isb
ARM_dbg = _idaapi.ARM_dbg
ARM_und = _idaapi.ARM_und
ARM_rrx = _idaapi.ARM_rrx
ARM_enterx = _idaapi.ARM_enterx
ARM_leavex = _idaapi.ARM_leavex
ARM_chka = _idaapi.ARM_chka
ARM_hb = _idaapi.ARM_hb
ARM_hbl = _idaapi.ARM_hbl
ARM_hblp = _idaapi.ARM_hblp
ARM_hbp = _idaapi.ARM_hbp
ARM_vaba = _idaapi.ARM_vaba
ARM_vabal = _idaapi.ARM_vabal
ARM_vabd = _idaapi.ARM_vabd
ARM_vabdl = _idaapi.ARM_vabdl
ARM_vabs = _idaapi.ARM_vabs
ARM_vacge = _idaapi.ARM_vacge
ARM_vacgt = _idaapi.ARM_vacgt
ARM_vacle = _idaapi.ARM_vacle
ARM_vaclt = _idaapi.ARM_vaclt
ARM_vadd = _idaapi.ARM_vadd
ARM_vaddhn = _idaapi.ARM_vaddhn
ARM_vaddl = _idaapi.ARM_vaddl
ARM_vaddw = _idaapi.ARM_vaddw
ARM_vand = _idaapi.ARM_vand
ARM_vbic = _idaapi.ARM_vbic
ARM_vbif = _idaapi.ARM_vbif
ARM_vbit = _idaapi.ARM_vbit
ARM_vbsl = _idaapi.ARM_vbsl
ARM_vceq = _idaapi.ARM_vceq
ARM_vcge = _idaapi.ARM_vcge
ARM_vcgt = _idaapi.ARM_vcgt
ARM_vcle = _idaapi.ARM_vcle
ARM_vcls = _idaapi.ARM_vcls
ARM_vclt = _idaapi.ARM_vclt
ARM_vclz = _idaapi.ARM_vclz
ARM_vcmp = _idaapi.ARM_vcmp
ARM_vcmpe = _idaapi.ARM_vcmpe
ARM_vcnt = _idaapi.ARM_vcnt
ARM_vcvt = _idaapi.ARM_vcvt
ARM_vcvtr = _idaapi.ARM_vcvtr
ARM_vcvtb = _idaapi.ARM_vcvtb
ARM_vcvtt = _idaapi.ARM_vcvtt
ARM_vdiv = _idaapi.ARM_vdiv
ARM_vdup = _idaapi.ARM_vdup
ARM_veor = _idaapi.ARM_veor
ARM_vext = _idaapi.ARM_vext
ARM_vfma = _idaapi.ARM_vfma
ARM_vfms = _idaapi.ARM_vfms
ARM_vfnma = _idaapi.ARM_vfnma
ARM_vfnms = _idaapi.ARM_vfnms
ARM_vhadd = _idaapi.ARM_vhadd
ARM_vhsub = _idaapi.ARM_vhsub
ARM_vld1 = _idaapi.ARM_vld1
ARM_vld2 = _idaapi.ARM_vld2
ARM_vld3 = _idaapi.ARM_vld3
ARM_vld4 = _idaapi.ARM_vld4
ARM_vldm = _idaapi.ARM_vldm
ARM_vldr = _idaapi.ARM_vldr
ARM_vmax = _idaapi.ARM_vmax
ARM_vmin = _idaapi.ARM_vmin
ARM_vmla = _idaapi.ARM_vmla
ARM_vmlal = _idaapi.ARM_vmlal
ARM_vmls = _idaapi.ARM_vmls
ARM_vmlsl = _idaapi.ARM_vmlsl
ARM_vmov = _idaapi.ARM_vmov
ARM_vmovl = _idaapi.ARM_vmovl
ARM_vmovn = _idaapi.ARM_vmovn
ARM_vmrs = _idaapi.ARM_vmrs
ARM_vmsr = _idaapi.ARM_vmsr
ARM_vmul = _idaapi.ARM_vmul
ARM_vmull = _idaapi.ARM_vmull
ARM_vmvn = _idaapi.ARM_vmvn
ARM_vneg = _idaapi.ARM_vneg
ARM_vnmla = _idaapi.ARM_vnmla
ARM_vnmls = _idaapi.ARM_vnmls
ARM_vnmul = _idaapi.ARM_vnmul
ARM_vorn = _idaapi.ARM_vorn
ARM_vorr = _idaapi.ARM_vorr
ARM_vpadal = _idaapi.ARM_vpadal
ARM_vpadd = _idaapi.ARM_vpadd
ARM_vpaddl = _idaapi.ARM_vpaddl
ARM_vpmax = _idaapi.ARM_vpmax
ARM_vpmin = _idaapi.ARM_vpmin
ARM_vpop = _idaapi.ARM_vpop
ARM_vpush = _idaapi.ARM_vpush
ARM_vqabs = _idaapi.ARM_vqabs
ARM_vqadd = _idaapi.ARM_vqadd
ARM_vqdmlal = _idaapi.ARM_vqdmlal
ARM_vqdmlsl = _idaapi.ARM_vqdmlsl
ARM_vqdmulh = _idaapi.ARM_vqdmulh
ARM_vqdmull = _idaapi.ARM_vqdmull
ARM_vqmovn = _idaapi.ARM_vqmovn
ARM_vqmovun = _idaapi.ARM_vqmovun
ARM_vqneg = _idaapi.ARM_vqneg
ARM_vqrdmulh = _idaapi.ARM_vqrdmulh
ARM_vqrshl = _idaapi.ARM_vqrshl
ARM_vqrshrn = _idaapi.ARM_vqrshrn
ARM_vqrshrun = _idaapi.ARM_vqrshrun
ARM_vqshl = _idaapi.ARM_vqshl
ARM_vqshlu = _idaapi.ARM_vqshlu
ARM_vqshrn = _idaapi.ARM_vqshrn
ARM_vqshrun = _idaapi.ARM_vqshrun
ARM_vqsub = _idaapi.ARM_vqsub
ARM_vraddhn = _idaapi.ARM_vraddhn
ARM_vrecpe = _idaapi.ARM_vrecpe
ARM_vrecps = _idaapi.ARM_vrecps
ARM_vrev16 = _idaapi.ARM_vrev16
ARM_vrev32 = _idaapi.ARM_vrev32
ARM_vrev64 = _idaapi.ARM_vrev64
ARM_vrhadd = _idaapi.ARM_vrhadd
ARM_vrshl = _idaapi.ARM_vrshl
ARM_vrshr = _idaapi.ARM_vrshr
ARM_vrshrn = _idaapi.ARM_vrshrn
ARM_vrsqrte = _idaapi.ARM_vrsqrte
ARM_vrsqrts = _idaapi.ARM_vrsqrts
ARM_vrsra = _idaapi.ARM_vrsra
ARM_vrsubhn = _idaapi.ARM_vrsubhn
ARM_vshl = _idaapi.ARM_vshl
ARM_vshll = _idaapi.ARM_vshll
ARM_vshr = _idaapi.ARM_vshr
ARM_vshrn = _idaapi.ARM_vshrn
ARM_vsli = _idaapi.ARM_vsli
ARM_vsqrt = _idaapi.ARM_vsqrt
ARM_vsra = _idaapi.ARM_vsra
ARM_vsri = _idaapi.ARM_vsri
ARM_vst1 = _idaapi.ARM_vst1
ARM_vst2 = _idaapi.ARM_vst2
ARM_vst3 = _idaapi.ARM_vst3
ARM_vst4 = _idaapi.ARM_vst4
ARM_vstm = _idaapi.ARM_vstm
ARM_vstr = _idaapi.ARM_vstr
ARM_vsub = _idaapi.ARM_vsub
ARM_vsubhn = _idaapi.ARM_vsubhn
ARM_vsubl = _idaapi.ARM_vsubl
ARM_vsubw = _idaapi.ARM_vsubw
ARM_vswp = _idaapi.ARM_vswp
ARM_vtbl = _idaapi.ARM_vtbl
ARM_vtbx = _idaapi.ARM_vtbx
ARM_vtrn = _idaapi.ARM_vtrn
ARM_vtst = _idaapi.ARM_vtst
ARM_vuzp = _idaapi.ARM_vuzp
ARM_vzip = _idaapi.ARM_vzip
ARM_eret = _idaapi.ARM_eret
ARM_hvc = _idaapi.ARM_hvc
ARM_lda = _idaapi.ARM_lda
ARM_stl = _idaapi.ARM_stl
ARM_ldaex = _idaapi.ARM_ldaex
ARM_stlex = _idaapi.ARM_stlex
ARM_vsel = _idaapi.ARM_vsel
ARM_vmaxnm = _idaapi.ARM_vmaxnm
ARM_vminnm = _idaapi.ARM_vminnm
ARM_vcvta = _idaapi.ARM_vcvta
ARM_vcvtn = _idaapi.ARM_vcvtn
ARM_vcvtp = _idaapi.ARM_vcvtp
ARM_vcvtm = _idaapi.ARM_vcvtm
ARM_vrintx = _idaapi.ARM_vrintx
ARM_vrintr = _idaapi.ARM_vrintr
ARM_vrintz = _idaapi.ARM_vrintz
ARM_vrinta = _idaapi.ARM_vrinta
ARM_vrintn = _idaapi.ARM_vrintn
ARM_vrintp = _idaapi.ARM_vrintp
ARM_vrintm = _idaapi.ARM_vrintm
ARM_aesd = _idaapi.ARM_aesd
ARM_aese = _idaapi.ARM_aese
ARM_aesimc = _idaapi.ARM_aesimc
ARM_aesmc = _idaapi.ARM_aesmc
ARM_sha1c = _idaapi.ARM_sha1c
ARM_sha1m = _idaapi.ARM_sha1m
ARM_sha1p = _idaapi.ARM_sha1p
ARM_sha1h = _idaapi.ARM_sha1h
ARM_sha1su0 = _idaapi.ARM_sha1su0
ARM_sha1su1 = _idaapi.ARM_sha1su1
ARM_sha256h = _idaapi.ARM_sha256h
ARM_sha256h2 = _idaapi.ARM_sha256h2
ARM_sha256su0 = _idaapi.ARM_sha256su0
ARM_sha256su1 = _idaapi.ARM_sha256su1
ARM_dcps1 = _idaapi.ARM_dcps1
ARM_dcps2 = _idaapi.ARM_dcps2
ARM_dcps3 = _idaapi.ARM_dcps3
ARM_hlt = _idaapi.ARM_hlt
ARM_sevl = _idaapi.ARM_sevl
ARM_tbz = _idaapi.ARM_tbz
ARM_tbnz = _idaapi.ARM_tbnz
ARM_br = _idaapi.ARM_br
ARM_blr = _idaapi.ARM_blr
ARM_ldur = _idaapi.ARM_ldur
ARM_stur = _idaapi.ARM_stur
ARM_ldp = _idaapi.ARM_ldp
ARM_stp = _idaapi.ARM_stp
ARM_ldnp = _idaapi.ARM_ldnp
ARM_stnp = _idaapi.ARM_stnp
ARM_ldtr = _idaapi.ARM_ldtr
ARM_sttr = _idaapi.ARM_sttr
ARM_ldxr = _idaapi.ARM_ldxr
ARM_stxr = _idaapi.ARM_stxr
ARM_ldxp = _idaapi.ARM_ldxp
ARM_stxp = _idaapi.ARM_stxp
ARM_ldar = _idaapi.ARM_ldar
ARM_stlr = _idaapi.ARM_stlr
ARM_ldaxr = _idaapi.ARM_ldaxr
ARM_stlxr = _idaapi.ARM_stlxr
ARM_ldaxp = _idaapi.ARM_ldaxp
ARM_stlxp = _idaapi.ARM_stlxp
ARM_prfm = _idaapi.ARM_prfm
ARM_prfum = _idaapi.ARM_prfum
ARM_movi = _idaapi.ARM_movi
ARM_mvni = _idaapi.ARM_mvni
ARM_movz = _idaapi.ARM_movz
ARM_movn = _idaapi.ARM_movn
ARM_movk = _idaapi.ARM_movk
ARM_adrp = _idaapi.ARM_adrp
ARM_bfm = _idaapi.ARM_bfm
ARM_sbfm = _idaapi.ARM_sbfm
ARM_ubfm = _idaapi.ARM_ubfm
ARM_bfxil = _idaapi.ARM_bfxil
ARM_sbfiz = _idaapi.ARM_sbfiz
ARM_ubfiz = _idaapi.ARM_ubfiz
ARM_extr = _idaapi.ARM_extr
ARM_sxtw = _idaapi.ARM_sxtw
ARM_uxtw = _idaapi.ARM_uxtw
ARM_eon = _idaapi.ARM_eon
ARM_not = _idaapi.ARM_not
ARM_cls = _idaapi.ARM_cls
ARM_rev32 = _idaapi.ARM_rev32
ARM_csel = _idaapi.ARM_csel
ARM_csinc = _idaapi.ARM_csinc
ARM_csinv = _idaapi.ARM_csinv
ARM_csneg = _idaapi.ARM_csneg
ARM_cset = _idaapi.ARM_cset
ARM_csetm = _idaapi.ARM_csetm
ARM_cinc = _idaapi.ARM_cinc
ARM_cinv = _idaapi.ARM_cinv
ARM_cneg = _idaapi.ARM_cneg
ARM_ngc = _idaapi.ARM_ngc
ARM_ccmn = _idaapi.ARM_ccmn
ARM_ccmp = _idaapi.ARM_ccmp
ARM_madd = _idaapi.ARM_madd
ARM_msub = _idaapi.ARM_msub
ARM_mneg = _idaapi.ARM_mneg
ARM_smaddl = _idaapi.ARM_smaddl
ARM_smsubl = _idaapi.ARM_smsubl
ARM_smnegl = _idaapi.ARM_smnegl
ARM_smulh = _idaapi.ARM_smulh
ARM_umaddl = _idaapi.ARM_umaddl
ARM_umsubl = _idaapi.ARM_umsubl
ARM_umnegl = _idaapi.ARM_umnegl
ARM_umulh = _idaapi.ARM_umulh
ARM_drps = _idaapi.ARM_drps
ARM_sys = _idaapi.ARM_sys
ARM_sysl = _idaapi.ARM_sysl
ARM_ic = _idaapi.ARM_ic
ARM_dc = _idaapi.ARM_dc
ARM_at = _idaapi.ARM_at
ARM_tlbi = _idaapi.ARM_tlbi
ARM_hint = _idaapi.ARM_hint
ARM_brk = _idaapi.ARM_brk
ARM_uaba = _idaapi.ARM_uaba
ARM_saba = _idaapi.ARM_saba
ARM_uabal = _idaapi.ARM_uabal
ARM_uabal2 = _idaapi.ARM_uabal2
ARM_sabal = _idaapi.ARM_sabal
ARM_sabal2 = _idaapi.ARM_sabal2
ARM_uabd = _idaapi.ARM_uabd
ARM_sabd = _idaapi.ARM_sabd
ARM_fabd = _idaapi.ARM_fabd
ARM_uabdl = _idaapi.ARM_uabdl
ARM_uabdl2 = _idaapi.ARM_uabdl2
ARM_sabdl = _idaapi.ARM_sabdl
ARM_sabdl2 = _idaapi.ARM_sabdl2
ARM_abs = _idaapi.ARM_abs
ARM_fabs = _idaapi.ARM_fabs
ARM_facge = _idaapi.ARM_facge
ARM_facgt = _idaapi.ARM_facgt
ARM_facle = _idaapi.ARM_facle
ARM_faclt = _idaapi.ARM_faclt
ARM_fadd = _idaapi.ARM_fadd
ARM_addhn = _idaapi.ARM_addhn
ARM_addhn2 = _idaapi.ARM_addhn2
ARM_uaddl = _idaapi.ARM_uaddl
ARM_uaddl2 = _idaapi.ARM_uaddl2
ARM_saddl = _idaapi.ARM_saddl
ARM_saddl2 = _idaapi.ARM_saddl2
ARM_uaddw = _idaapi.ARM_uaddw
ARM_uaddw2 = _idaapi.ARM_uaddw2
ARM_saddw = _idaapi.ARM_saddw
ARM_saddw2 = _idaapi.ARM_saddw2
ARM_bif = _idaapi.ARM_bif
ARM_bit = _idaapi.ARM_bit
ARM_bsl = _idaapi.ARM_bsl
ARM_cmeq = _idaapi.ARM_cmeq
ARM_fcmeq = _idaapi.ARM_fcmeq
ARM_cmhs = _idaapi.ARM_cmhs
ARM_cmge = _idaapi.ARM_cmge
ARM_fcmge = _idaapi.ARM_fcmge
ARM_cmhi = _idaapi.ARM_cmhi
ARM_cmgt = _idaapi.ARM_cmgt
ARM_fcmgt = _idaapi.ARM_fcmgt
ARM_cmls = _idaapi.ARM_cmls
ARM_cmle = _idaapi.ARM_cmle
ARM_fcmle = _idaapi.ARM_fcmle
ARM_cmlo = _idaapi.ARM_cmlo
ARM_cmlt = _idaapi.ARM_cmlt
ARM_fcmlt = _idaapi.ARM_fcmlt
ARM_fcmp = _idaapi.ARM_fcmp
ARM_fcmpe = _idaapi.ARM_fcmpe
ARM_fccmp = _idaapi.ARM_fccmp
ARM_fccmpe = _idaapi.ARM_fccmpe
ARM_fcsel = _idaapi.ARM_fcsel
ARM_cnt = _idaapi.ARM_cnt
ARM_fcvt = _idaapi.ARM_fcvt
ARM_fcvtzs = _idaapi.ARM_fcvtzs
ARM_fcvtas = _idaapi.ARM_fcvtas
ARM_fcvtns = _idaapi.ARM_fcvtns
ARM_fcvtps = _idaapi.ARM_fcvtps
ARM_fcvtms = _idaapi.ARM_fcvtms
ARM_fcvtzu = _idaapi.ARM_fcvtzu
ARM_fcvtau = _idaapi.ARM_fcvtau
ARM_fcvtnu = _idaapi.ARM_fcvtnu
ARM_fcvtpu = _idaapi.ARM_fcvtpu
ARM_fcvtmu = _idaapi.ARM_fcvtmu
ARM_ucvtf = _idaapi.ARM_ucvtf
ARM_scvtf = _idaapi.ARM_scvtf
ARM_fcvtn = _idaapi.ARM_fcvtn
ARM_fcvtn2 = _idaapi.ARM_fcvtn2
ARM_fcvtl = _idaapi.ARM_fcvtl
ARM_fcvtl2 = _idaapi.ARM_fcvtl2
ARM_fcvtxn = _idaapi.ARM_fcvtxn
ARM_fcvtxn2 = _idaapi.ARM_fcvtxn2
ARM_frinta = _idaapi.ARM_frinta
ARM_frinti = _idaapi.ARM_frinti
ARM_frintm = _idaapi.ARM_frintm
ARM_frintn = _idaapi.ARM_frintn
ARM_frintp = _idaapi.ARM_frintp
ARM_frintx = _idaapi.ARM_frintx
ARM_frintz = _idaapi.ARM_frintz
ARM_fmadd = _idaapi.ARM_fmadd
ARM_fmsub = _idaapi.ARM_fmsub
ARM_fnmadd = _idaapi.ARM_fnmadd
ARM_fnmsub = _idaapi.ARM_fnmsub
ARM_fdiv = _idaapi.ARM_fdiv
ARM_dup = _idaapi.ARM_dup
ARM_ins = _idaapi.ARM_ins
ARM_ext = _idaapi.ARM_ext
ARM_uhadd = _idaapi.ARM_uhadd
ARM_shadd = _idaapi.ARM_shadd
ARM_uhsub = _idaapi.ARM_uhsub
ARM_shsub = _idaapi.ARM_shsub
ARM_ld1 = _idaapi.ARM_ld1
ARM_ld2 = _idaapi.ARM_ld2
ARM_ld3 = _idaapi.ARM_ld3
ARM_ld4 = _idaapi.ARM_ld4
ARM_ld1r = _idaapi.ARM_ld1r
ARM_ld2r = _idaapi.ARM_ld2r
ARM_ld3r = _idaapi.ARM_ld3r
ARM_ld4r = _idaapi.ARM_ld4r
ARM_umax = _idaapi.ARM_umax
ARM_smax = _idaapi.ARM_smax
ARM_fmax = _idaapi.ARM_fmax
ARM_fmaxnm = _idaapi.ARM_fmaxnm
ARM_umin = _idaapi.ARM_umin
ARM_smin = _idaapi.ARM_smin
ARM_fmin = _idaapi.ARM_fmin
ARM_fminnm = _idaapi.ARM_fminnm
ARM_fmla = _idaapi.ARM_fmla
ARM_umlal2 = _idaapi.ARM_umlal2
ARM_smlal2 = _idaapi.ARM_smlal2
ARM_fmls = _idaapi.ARM_fmls
ARM_umlsl = _idaapi.ARM_umlsl
ARM_umlsl2 = _idaapi.ARM_umlsl2
ARM_smlsl = _idaapi.ARM_smlsl
ARM_smlsl2 = _idaapi.ARM_smlsl2
ARM_umov = _idaapi.ARM_umov
ARM_smov = _idaapi.ARM_smov
ARM_fmov = _idaapi.ARM_fmov
ARM_uxtl = _idaapi.ARM_uxtl
ARM_uxtl2 = _idaapi.ARM_uxtl2
ARM_sxtl = _idaapi.ARM_sxtl
ARM_sxtl2 = _idaapi.ARM_sxtl2
ARM_xtn = _idaapi.ARM_xtn
ARM_xtn2 = _idaapi.ARM_xtn2
ARM_fmul = _idaapi.ARM_fmul
ARM_pmul = _idaapi.ARM_pmul
ARM_fmulx = _idaapi.ARM_fmulx
ARM_fnmul = _idaapi.ARM_fnmul
ARM_umull2 = _idaapi.ARM_umull2
ARM_smull2 = _idaapi.ARM_smull2
ARM_pmull = _idaapi.ARM_pmull
ARM_pmull2 = _idaapi.ARM_pmull2
ARM_fneg = _idaapi.ARM_fneg
ARM_uadalp = _idaapi.ARM_uadalp
ARM_sadalp = _idaapi.ARM_sadalp
ARM_addp = _idaapi.ARM_addp
ARM_faddp = _idaapi.ARM_faddp
ARM_uaddlp = _idaapi.ARM_uaddlp
ARM_saddlp = _idaapi.ARM_saddlp
ARM_umaxp = _idaapi.ARM_umaxp
ARM_smaxp = _idaapi.ARM_smaxp
ARM_fmaxp = _idaapi.ARM_fmaxp
ARM_fmaxnmp = _idaapi.ARM_fmaxnmp
ARM_uminp = _idaapi.ARM_uminp
ARM_sminp = _idaapi.ARM_sminp
ARM_fminp = _idaapi.ARM_fminp
ARM_fminnmp = _idaapi.ARM_fminnmp
ARM_sqabs = _idaapi.ARM_sqabs
ARM_uqadd = _idaapi.ARM_uqadd
ARM_sqadd = _idaapi.ARM_sqadd
ARM_suqadd = _idaapi.ARM_suqadd
ARM_usqadd = _idaapi.ARM_usqadd
ARM_sqdmlal = _idaapi.ARM_sqdmlal
ARM_sqdmlal2 = _idaapi.ARM_sqdmlal2
ARM_sqdmlsl = _idaapi.ARM_sqdmlsl
ARM_sqdmlsl2 = _idaapi.ARM_sqdmlsl2
ARM_sqdmulh = _idaapi.ARM_sqdmulh
ARM_sqdmull = _idaapi.ARM_sqdmull
ARM_sqdmull2 = _idaapi.ARM_sqdmull2
ARM_uqxtn = _idaapi.ARM_uqxtn
ARM_uqxtn2 = _idaapi.ARM_uqxtn2
ARM_sqxtn = _idaapi.ARM_sqxtn
ARM_sqxtn2 = _idaapi.ARM_sqxtn2
ARM_sqxtun = _idaapi.ARM_sqxtun
ARM_sqxtun2 = _idaapi.ARM_sqxtun2
ARM_sqneg = _idaapi.ARM_sqneg
ARM_sqrdmulh = _idaapi.ARM_sqrdmulh
ARM_uqrshl = _idaapi.ARM_uqrshl
ARM_sqrshl = _idaapi.ARM_sqrshl
ARM_uqrshrn = _idaapi.ARM_uqrshrn
ARM_uqrshrn2 = _idaapi.ARM_uqrshrn2
ARM_sqrshrn = _idaapi.ARM_sqrshrn
ARM_sqrshrn2 = _idaapi.ARM_sqrshrn2
ARM_sqrshrun = _idaapi.ARM_sqrshrun
ARM_sqrshrun2 = _idaapi.ARM_sqrshrun2
ARM_uqshl = _idaapi.ARM_uqshl
ARM_sqshl = _idaapi.ARM_sqshl
ARM_sqshlu = _idaapi.ARM_sqshlu
ARM_uqshrn = _idaapi.ARM_uqshrn
ARM_uqshrn2 = _idaapi.ARM_uqshrn2
ARM_sqshrn = _idaapi.ARM_sqshrn
ARM_sqshrn2 = _idaapi.ARM_sqshrn2
ARM_sqshrun = _idaapi.ARM_sqshrun
ARM_sqshrun2 = _idaapi.ARM_sqshrun2
ARM_uqsub = _idaapi.ARM_uqsub
ARM_sqsub = _idaapi.ARM_sqsub
ARM_raddhn = _idaapi.ARM_raddhn
ARM_raddhn2 = _idaapi.ARM_raddhn2
ARM_urecpe = _idaapi.ARM_urecpe
ARM_frecpe = _idaapi.ARM_frecpe
ARM_frecps = _idaapi.ARM_frecps
ARM_frecpx = _idaapi.ARM_frecpx
ARM_rev64 = _idaapi.ARM_rev64
ARM_urhadd = _idaapi.ARM_urhadd
ARM_srhadd = _idaapi.ARM_srhadd
ARM_urshl = _idaapi.ARM_urshl
ARM_srshl = _idaapi.ARM_srshl
ARM_urshr = _idaapi.ARM_urshr
ARM_srshr = _idaapi.ARM_srshr
ARM_rshrn = _idaapi.ARM_rshrn
ARM_rshrn2 = _idaapi.ARM_rshrn2
ARM_ursqrte = _idaapi.ARM_ursqrte
ARM_frsqrte = _idaapi.ARM_frsqrte
ARM_frsqrts = _idaapi.ARM_frsqrts
ARM_ursra = _idaapi.ARM_ursra
ARM_srsra = _idaapi.ARM_srsra
ARM_rsubhn = _idaapi.ARM_rsubhn
ARM_rsubhn2 = _idaapi.ARM_rsubhn2
ARM_ushl = _idaapi.ARM_ushl
ARM_sshl = _idaapi.ARM_sshl
ARM_ushll = _idaapi.ARM_ushll
ARM_ushll2 = _idaapi.ARM_ushll2
ARM_sshll = _idaapi.ARM_sshll
ARM_sshll2 = _idaapi.ARM_sshll2
ARM_ushr = _idaapi.ARM_ushr
ARM_sshr = _idaapi.ARM_sshr
ARM_shrn = _idaapi.ARM_shrn
ARM_shrn2 = _idaapi.ARM_shrn2
ARM_shl = _idaapi.ARM_shl
ARM_shll = _idaapi.ARM_shll
ARM_shll2 = _idaapi.ARM_shll2
ARM_sli = _idaapi.ARM_sli
ARM_fsqrt = _idaapi.ARM_fsqrt
ARM_usra = _idaapi.ARM_usra
ARM_ssra = _idaapi.ARM_ssra
ARM_sri = _idaapi.ARM_sri
ARM_st1 = _idaapi.ARM_st1
ARM_st2 = _idaapi.ARM_st2
ARM_st3 = _idaapi.ARM_st3
ARM_st4 = _idaapi.ARM_st4
ARM_fsub = _idaapi.ARM_fsub
ARM_subhn = _idaapi.ARM_subhn
ARM_subhn2 = _idaapi.ARM_subhn2
ARM_usubl = _idaapi.ARM_usubl
ARM_usubl2 = _idaapi.ARM_usubl2
ARM_ssubl = _idaapi.ARM_ssubl
ARM_ssubl2 = _idaapi.ARM_ssubl2
ARM_usubw = _idaapi.ARM_usubw
ARM_usubw2 = _idaapi.ARM_usubw2
ARM_ssubw = _idaapi.ARM_ssubw
ARM_ssubw2 = _idaapi.ARM_ssubw2
ARM_tbl = _idaapi.ARM_tbl
ARM_tbx = _idaapi.ARM_tbx
ARM_trn1 = _idaapi.ARM_trn1
ARM_trn2 = _idaapi.ARM_trn2
ARM_cmtst = _idaapi.ARM_cmtst
ARM_uzp1 = _idaapi.ARM_uzp1
ARM_uzp2 = _idaapi.ARM_uzp2
ARM_zip1 = _idaapi.ARM_zip1
ARM_zip2 = _idaapi.ARM_zip2
ARM_addv = _idaapi.ARM_addv
ARM_uaddlv = _idaapi.ARM_uaddlv
ARM_saddlv = _idaapi.ARM_saddlv
ARM_umaxv = _idaapi.ARM_umaxv
ARM_smaxv = _idaapi.ARM_smaxv
ARM_fmaxv = _idaapi.ARM_fmaxv
ARM_fmaxnmv = _idaapi.ARM_fmaxnmv
ARM_uminv = _idaapi.ARM_uminv
ARM_sminv = _idaapi.ARM_sminv
ARM_fminv = _idaapi.ARM_fminv
ARM_fminnmv = _idaapi.ARM_fminnmv
ARM_last = _idaapi.ARM_last
TMS6_null = _idaapi.TMS6_null
TMS6_abs = _idaapi.TMS6_abs
TMS6_add = _idaapi.TMS6_add
TMS6_addu = _idaapi.TMS6_addu
TMS6_addab = _idaapi.TMS6_addab
TMS6_addah = _idaapi.TMS6_addah
TMS6_addaw = _idaapi.TMS6_addaw
TMS6_addk = _idaapi.TMS6_addk
TMS6_add2 = _idaapi.TMS6_add2
TMS6_and = _idaapi.TMS6_and
TMS6_b = _idaapi.TMS6_b
TMS6_clr = _idaapi.TMS6_clr
TMS6_cmpeq = _idaapi.TMS6_cmpeq
TMS6_cmpgt = _idaapi.TMS6_cmpgt
TMS6_cmpgtu = _idaapi.TMS6_cmpgtu
TMS6_cmplt = _idaapi.TMS6_cmplt
TMS6_cmpltu = _idaapi.TMS6_cmpltu
TMS6_ext = _idaapi.TMS6_ext
TMS6_extu = _idaapi.TMS6_extu
TMS6_idle = _idaapi.TMS6_idle
TMS6_ldb = _idaapi.TMS6_ldb
TMS6_ldbu = _idaapi.TMS6_ldbu
TMS6_ldh = _idaapi.TMS6_ldh
TMS6_ldhu = _idaapi.TMS6_ldhu
TMS6_ldw = _idaapi.TMS6_ldw
TMS6_lmbd = _idaapi.TMS6_lmbd
TMS6_mpy = _idaapi.TMS6_mpy
TMS6_mpyu = _idaapi.TMS6_mpyu
TMS6_mpyus = _idaapi.TMS6_mpyus
TMS6_mpysu = _idaapi.TMS6_mpysu
TMS6_mpyh = _idaapi.TMS6_mpyh
TMS6_mpyhu = _idaapi.TMS6_mpyhu
TMS6_mpyhus = _idaapi.TMS6_mpyhus
TMS6_mpyhsu = _idaapi.TMS6_mpyhsu
TMS6_mpyhl = _idaapi.TMS6_mpyhl
TMS6_mpyhlu = _idaapi.TMS6_mpyhlu
TMS6_mpyhuls = _idaapi.TMS6_mpyhuls
TMS6_mpyhslu = _idaapi.TMS6_mpyhslu
TMS6_mpylh = _idaapi.TMS6_mpylh
TMS6_mpylhu = _idaapi.TMS6_mpylhu
TMS6_mpyluhs = _idaapi.TMS6_mpyluhs
TMS6_mpylshu = _idaapi.TMS6_mpylshu
TMS6_mv = _idaapi.TMS6_mv
TMS6_mvc = _idaapi.TMS6_mvc
TMS6_mvk = _idaapi.TMS6_mvk
TMS6_mvkh = _idaapi.TMS6_mvkh
TMS6_mvklh = _idaapi.TMS6_mvklh
TMS6_neg = _idaapi.TMS6_neg
TMS6_nop = _idaapi.TMS6_nop
TMS6_norm = _idaapi.TMS6_norm
TMS6_not = _idaapi.TMS6_not
TMS6_or = _idaapi.TMS6_or
TMS6_sadd = _idaapi.TMS6_sadd
TMS6_sat = _idaapi.TMS6_sat
TMS6_set = _idaapi.TMS6_set
TMS6_shl = _idaapi.TMS6_shl
TMS6_shr = _idaapi.TMS6_shr
TMS6_shru = _idaapi.TMS6_shru
TMS6_smpy = _idaapi.TMS6_smpy
TMS6_smpyhl = _idaapi.TMS6_smpyhl
TMS6_smpylh = _idaapi.TMS6_smpylh
TMS6_smpyh = _idaapi.TMS6_smpyh
TMS6_sshl = _idaapi.TMS6_sshl
TMS6_ssub = _idaapi.TMS6_ssub
TMS6_stb = _idaapi.TMS6_stb
TMS6_stbu = _idaapi.TMS6_stbu
TMS6_sth = _idaapi.TMS6_sth
TMS6_sthu = _idaapi.TMS6_sthu
TMS6_stw = _idaapi.TMS6_stw
TMS6_sub = _idaapi.TMS6_sub
TMS6_subu = _idaapi.TMS6_subu
TMS6_subab = _idaapi.TMS6_subab
TMS6_subah = _idaapi.TMS6_subah
TMS6_subaw = _idaapi.TMS6_subaw
TMS6_subc = _idaapi.TMS6_subc
TMS6_sub2 = _idaapi.TMS6_sub2
TMS6_xor = _idaapi.TMS6_xor
TMS6_zero = _idaapi.TMS6_zero
TMS6_abs2 = _idaapi.TMS6_abs2
TMS6_absdp = _idaapi.TMS6_absdp
TMS6_abssp = _idaapi.TMS6_abssp
TMS6_add4 = _idaapi.TMS6_add4
TMS6_addad = _idaapi.TMS6_addad
TMS6_adddp = _idaapi.TMS6_adddp
TMS6_addkpc = _idaapi.TMS6_addkpc
TMS6_addsp = _idaapi.TMS6_addsp
TMS6_addsub = _idaapi.TMS6_addsub
TMS6_addsub2 = _idaapi.TMS6_addsub2
TMS6_andn = _idaapi.TMS6_andn
TMS6_avg2 = _idaapi.TMS6_avg2
TMS6_avgu4 = _idaapi.TMS6_avgu4
TMS6_bdec = _idaapi.TMS6_bdec
TMS6_bitc4 = _idaapi.TMS6_bitc4
TMS6_bitr = _idaapi.TMS6_bitr
TMS6_bnop = _idaapi.TMS6_bnop
TMS6_bpos = _idaapi.TMS6_bpos
TMS6_callp = _idaapi.TMS6_callp
TMS6_cmpeq2 = _idaapi.TMS6_cmpeq2
TMS6_cmpeq4 = _idaapi.TMS6_cmpeq4
TMS6_cmpeqdp = _idaapi.TMS6_cmpeqdp
TMS6_cmpeqsp = _idaapi.TMS6_cmpeqsp
TMS6_cmpgt2 = _idaapi.TMS6_cmpgt2
TMS6_cmpgtdp = _idaapi.TMS6_cmpgtdp
TMS6_cmpgtsp = _idaapi.TMS6_cmpgtsp
TMS6_cmpgtu4 = _idaapi.TMS6_cmpgtu4
TMS6_cmplt2 = _idaapi.TMS6_cmplt2
TMS6_cmpltdp = _idaapi.TMS6_cmpltdp
TMS6_cmpltsp = _idaapi.TMS6_cmpltsp
TMS6_cmpltu4 = _idaapi.TMS6_cmpltu4
TMS6_cmpy = _idaapi.TMS6_cmpy
TMS6_cmpyr = _idaapi.TMS6_cmpyr
TMS6_cmpyr1 = _idaapi.TMS6_cmpyr1
TMS6_ddotp4 = _idaapi.TMS6_ddotp4
TMS6_ddotph2 = _idaapi.TMS6_ddotph2
TMS6_ddotph2r = _idaapi.TMS6_ddotph2r
TMS6_ddotpl2 = _idaapi.TMS6_ddotpl2
TMS6_ddotpl2r = _idaapi.TMS6_ddotpl2r
TMS6_deal = _idaapi.TMS6_deal
TMS6_dint = _idaapi.TMS6_dint
TMS6_dmv = _idaapi.TMS6_dmv
TMS6_dotp2 = _idaapi.TMS6_dotp2
TMS6_dotpn2 = _idaapi.TMS6_dotpn2
TMS6_dotpnrsu2 = _idaapi.TMS6_dotpnrsu2
TMS6_dotpnrus2 = _idaapi.TMS6_dotpnrus2
TMS6_dotprsu2 = _idaapi.TMS6_dotprsu2
TMS6_dotprus2 = _idaapi.TMS6_dotprus2
TMS6_dotpsu4 = _idaapi.TMS6_dotpsu4
TMS6_dotpu4 = _idaapi.TMS6_dotpu4
TMS6_dotpus4 = _idaapi.TMS6_dotpus4
TMS6_dpack2 = _idaapi.TMS6_dpack2
TMS6_dpackx2 = _idaapi.TMS6_dpackx2
TMS6_dpint = _idaapi.TMS6_dpint
TMS6_dpsp = _idaapi.TMS6_dpsp
TMS6_dptrunc = _idaapi.TMS6_dptrunc
TMS6_gmpy = _idaapi.TMS6_gmpy
TMS6_gmpy4 = _idaapi.TMS6_gmpy4
TMS6_intdp = _idaapi.TMS6_intdp
TMS6_intdpu = _idaapi.TMS6_intdpu
TMS6_intsp = _idaapi.TMS6_intsp
TMS6_intspu = _idaapi.TMS6_intspu
TMS6_lddw = _idaapi.TMS6_lddw
TMS6_ldndw = _idaapi.TMS6_ldndw
TMS6_ldnw = _idaapi.TMS6_ldnw
TMS6_max2 = _idaapi.TMS6_max2
TMS6_maxu4 = _idaapi.TMS6_maxu4
TMS6_min2 = _idaapi.TMS6_min2
TMS6_minu4 = _idaapi.TMS6_minu4
TMS6_mpy2 = _idaapi.TMS6_mpy2
TMS6_mpy2ir = _idaapi.TMS6_mpy2ir
TMS6_mpy32 = _idaapi.TMS6_mpy32
TMS6_mpy32su = _idaapi.TMS6_mpy32su
TMS6_mpy32u = _idaapi.TMS6_mpy32u
TMS6_mpy32us = _idaapi.TMS6_mpy32us
TMS6_mpydp = _idaapi.TMS6_mpydp
TMS6_mpyhi = _idaapi.TMS6_mpyhi
TMS6_mpyhir = _idaapi.TMS6_mpyhir
TMS6_mpyi = _idaapi.TMS6_mpyi
TMS6_mpyid = _idaapi.TMS6_mpyid
TMS6_mpyih = _idaapi.TMS6_mpyih
TMS6_mpyihr = _idaapi.TMS6_mpyihr
TMS6_mpyil = _idaapi.TMS6_mpyil
TMS6_mpyilr = _idaapi.TMS6_mpyilr
TMS6_mpyli = _idaapi.TMS6_mpyli
TMS6_mpylir = _idaapi.TMS6_mpylir
TMS6_mpysp = _idaapi.TMS6_mpysp
TMS6_mpysp2dp = _idaapi.TMS6_mpysp2dp
TMS6_mpyspdp = _idaapi.TMS6_mpyspdp
TMS6_mpysu4 = _idaapi.TMS6_mpysu4
TMS6_mpyu4 = _idaapi.TMS6_mpyu4
TMS6_mpyus4 = _idaapi.TMS6_mpyus4
TMS6_mvd = _idaapi.TMS6_mvd
TMS6_mvkl = _idaapi.TMS6_mvkl
TMS6_pack2 = _idaapi.TMS6_pack2
TMS6_packh2 = _idaapi.TMS6_packh2
TMS6_packh4 = _idaapi.TMS6_packh4
TMS6_packhl2 = _idaapi.TMS6_packhl2
TMS6_packl4 = _idaapi.TMS6_packl4
TMS6_packlh2 = _idaapi.TMS6_packlh2
TMS6_rcpdp = _idaapi.TMS6_rcpdp
TMS6_rcpsp = _idaapi.TMS6_rcpsp
TMS6_rint = _idaapi.TMS6_rint
TMS6_rotl = _idaapi.TMS6_rotl
TMS6_rpack2 = _idaapi.TMS6_rpack2
TMS6_rsqrdp = _idaapi.TMS6_rsqrdp
TMS6_rsqrsp = _idaapi.TMS6_rsqrsp
TMS6_sadd2 = _idaapi.TMS6_sadd2
TMS6_saddsu2 = _idaapi.TMS6_saddsu2
TMS6_saddsub = _idaapi.TMS6_saddsub
TMS6_saddsub2 = _idaapi.TMS6_saddsub2
TMS6_saddu4 = _idaapi.TMS6_saddu4
TMS6_saddus2 = _idaapi.TMS6_saddus2
TMS6_shfl = _idaapi.TMS6_shfl
TMS6_shfl3 = _idaapi.TMS6_shfl3
TMS6_shlmb = _idaapi.TMS6_shlmb
TMS6_shr2 = _idaapi.TMS6_shr2
TMS6_shrmb = _idaapi.TMS6_shrmb
TMS6_shru2 = _idaapi.TMS6_shru2
TMS6_smpy2 = _idaapi.TMS6_smpy2
TMS6_smpy32 = _idaapi.TMS6_smpy32
TMS6_spack2 = _idaapi.TMS6_spack2
TMS6_spacku4 = _idaapi.TMS6_spacku4
TMS6_spdp = _idaapi.TMS6_spdp
TMS6_spint = _idaapi.TMS6_spint
TMS6_spkernel = _idaapi.TMS6_spkernel
TMS6_spkernelr = _idaapi.TMS6_spkernelr
TMS6_sploop = _idaapi.TMS6_sploop
TMS6_sploopd = _idaapi.TMS6_sploopd
TMS6_sploopw = _idaapi.TMS6_sploopw
TMS6_spmask = _idaapi.TMS6_spmask
TMS6_spmaskr = _idaapi.TMS6_spmaskr
TMS6_sptrunc = _idaapi.TMS6_sptrunc
TMS6_sshvl = _idaapi.TMS6_sshvl
TMS6_sshvr = _idaapi.TMS6_sshvr
TMS6_ssub2 = _idaapi.TMS6_ssub2
TMS6_stdw = _idaapi.TMS6_stdw
TMS6_stndw = _idaapi.TMS6_stndw
TMS6_stnw = _idaapi.TMS6_stnw
TMS6_sub4 = _idaapi.TMS6_sub4
TMS6_subabs4 = _idaapi.TMS6_subabs4
TMS6_subdp = _idaapi.TMS6_subdp
TMS6_subsp = _idaapi.TMS6_subsp
TMS6_swap2 = _idaapi.TMS6_swap2
TMS6_swap4 = _idaapi.TMS6_swap4
TMS6_swe = _idaapi.TMS6_swe
TMS6_swenr = _idaapi.TMS6_swenr
TMS6_unpkhu4 = _idaapi.TMS6_unpkhu4
TMS6_unpklu4 = _idaapi.TMS6_unpklu4
TMS6_xormpy = _idaapi.TMS6_xormpy
TMS6_xpnd2 = _idaapi.TMS6_xpnd2
TMS6_xpnd4 = _idaapi.TMS6_xpnd4
TMS6_last = _idaapi.TMS6_last
I196_null = _idaapi.I196_null
I196_add2 = _idaapi.I196_add2
I196_add3 = _idaapi.I196_add3
I196_addb2 = _idaapi.I196_addb2
I196_addb3 = _idaapi.I196_addb3
I196_addc = _idaapi.I196_addc
I196_addcb = _idaapi.I196_addcb
I196_and2 = _idaapi.I196_and2
I196_and3 = _idaapi.I196_and3
I196_andb2 = _idaapi.I196_andb2
I196_andb3 = _idaapi.I196_andb3
I196_bmov = _idaapi.I196_bmov
I196_bmovi = _idaapi.I196_bmovi
I196_br = _idaapi.I196_br
I196_clr = _idaapi.I196_clr
I196_clrb = _idaapi.I196_clrb
I196_clrc = _idaapi.I196_clrc
I196_clrvt = _idaapi.I196_clrvt
I196_cmp = _idaapi.I196_cmp
I196_cmpb = _idaapi.I196_cmpb
I196_cmpl = _idaapi.I196_cmpl
I196_dec = _idaapi.I196_dec
I196_decb = _idaapi.I196_decb
I196_di = _idaapi.I196_di
I196_div = _idaapi.I196_div
I196_divb = _idaapi.I196_divb
I196_divu = _idaapi.I196_divu
I196_divub = _idaapi.I196_divub
I196_djnz = _idaapi.I196_djnz
I196_djnzw = _idaapi.I196_djnzw
I196_dpts = _idaapi.I196_dpts
I196_ei = _idaapi.I196_ei
I196_epts = _idaapi.I196_epts
I196_ext = _idaapi.I196_ext
I196_extb = _idaapi.I196_extb
I196_idlpd = _idaapi.I196_idlpd
I196_inc = _idaapi.I196_inc
I196_incb = _idaapi.I196_incb
I196_jbc = _idaapi.I196_jbc
I196_jbs = _idaapi.I196_jbs
I196_jc = _idaapi.I196_jc
I196_je = _idaapi.I196_je
I196_jge = _idaapi.I196_jge
I196_jgt = _idaapi.I196_jgt
I196_jh = _idaapi.I196_jh
I196_jle = _idaapi.I196_jle
I196_jlt = _idaapi.I196_jlt
I196_jnc = _idaapi.I196_jnc
I196_jne = _idaapi.I196_jne
I196_jnh = _idaapi.I196_jnh
I196_jnst = _idaapi.I196_jnst
I196_jnv = _idaapi.I196_jnv
I196_jnvt = _idaapi.I196_jnvt
I196_jst = _idaapi.I196_jst
I196_jv = _idaapi.I196_jv
I196_jvt = _idaapi.I196_jvt
I196_lcall = _idaapi.I196_lcall
I196_ld = _idaapi.I196_ld
I196_ldb = _idaapi.I196_ldb
I196_ldbse = _idaapi.I196_ldbse
I196_ldbze = _idaapi.I196_ldbze
I196_ljmp = _idaapi.I196_ljmp
I196_mul2 = _idaapi.I196_mul2
I196_mul3 = _idaapi.I196_mul3
I196_mulb2 = _idaapi.I196_mulb2
I196_mulb3 = _idaapi.I196_mulb3
I196_mulu2 = _idaapi.I196_mulu2
I196_mulu3 = _idaapi.I196_mulu3
I196_mulub2 = _idaapi.I196_mulub2
I196_mulub3 = _idaapi.I196_mulub3
I196_neg = _idaapi.I196_neg
I196_negb = _idaapi.I196_negb
I196_nop = _idaapi.I196_nop
I196_norml = _idaapi.I196_norml
I196_not = _idaapi.I196_not
I196_notb = _idaapi.I196_notb
I196_or = _idaapi.I196_or
I196_orb = _idaapi.I196_orb
I196_pop = _idaapi.I196_pop
I196_popa = _idaapi.I196_popa
I196_popf = _idaapi.I196_popf
I196_push = _idaapi.I196_push
I196_pusha = _idaapi.I196_pusha
I196_pushf = _idaapi.I196_pushf
I196_ret = _idaapi.I196_ret
I196_rst = _idaapi.I196_rst
I196_scall = _idaapi.I196_scall
I196_setc = _idaapi.I196_setc
I196_shl = _idaapi.I196_shl
I196_shlb = _idaapi.I196_shlb
I196_shll = _idaapi.I196_shll
I196_shr = _idaapi.I196_shr
I196_shra = _idaapi.I196_shra
I196_shrab = _idaapi.I196_shrab
I196_shral = _idaapi.I196_shral
I196_shrb = _idaapi.I196_shrb
I196_shrl = _idaapi.I196_shrl
I196_sjmp = _idaapi.I196_sjmp
I196_skip = _idaapi.I196_skip
I196_st = _idaapi.I196_st
I196_stb = _idaapi.I196_stb
I196_sub2 = _idaapi.I196_sub2
I196_sub3 = _idaapi.I196_sub3
I196_subb2 = _idaapi.I196_subb2
I196_subb3 = _idaapi.I196_subb3
I196_subc = _idaapi.I196_subc
I196_subcb = _idaapi.I196_subcb
I196_tijmp = _idaapi.I196_tijmp
I196_trap = _idaapi.I196_trap
I196_xch = _idaapi.I196_xch
I196_xchb = _idaapi.I196_xchb
I196_xor = _idaapi.I196_xor
I196_xorb = _idaapi.I196_xorb
I196_ebmovi = _idaapi.I196_ebmovi
I196_ebr = _idaapi.I196_ebr
I196_ecall = _idaapi.I196_ecall
I196_ejmp = _idaapi.I196_ejmp
I196_eld = _idaapi.I196_eld
I196_eldb = _idaapi.I196_eldb
I196_est = _idaapi.I196_est
I196_estb = _idaapi.I196_estb
I196_last = _idaapi.I196_last
SH3_null = _idaapi.SH3_null
SH3_add = _idaapi.SH3_add
SH3_addc = _idaapi.SH3_addc
SH3_addv = _idaapi.SH3_addv
SH3_and = _idaapi.SH3_and
SH3_and_b = _idaapi.SH3_and_b
SH3_bf = _idaapi.SH3_bf
SH3_bf_s = _idaapi.SH3_bf_s
SH3_bra = _idaapi.SH3_bra
SH3_braf = _idaapi.SH3_braf
SH3_bsr = _idaapi.SH3_bsr
SH3_bsrf = _idaapi.SH3_bsrf
SH3_bt = _idaapi.SH3_bt
SH3_bt_s = _idaapi.SH3_bt_s
SH3_clrmac = _idaapi.SH3_clrmac
SH3_clrs = _idaapi.SH3_clrs
SH3_clrt = _idaapi.SH3_clrt
SH3_cmp_eq = _idaapi.SH3_cmp_eq
SH3_cmp_ge = _idaapi.SH3_cmp_ge
SH3_cmp_gt = _idaapi.SH3_cmp_gt
SH3_cmp_hi = _idaapi.SH3_cmp_hi
SH3_cmp_hs = _idaapi.SH3_cmp_hs
SH3_cmp_pl = _idaapi.SH3_cmp_pl
SH3_cmp_pz = _idaapi.SH3_cmp_pz
SH3_cmp_str = _idaapi.SH3_cmp_str
SH3_div0s = _idaapi.SH3_div0s
SH3_div0u = _idaapi.SH3_div0u
SH3_div1 = _idaapi.SH3_div1
SH3_dmuls_l = _idaapi.SH3_dmuls_l
SH3_dmulu_l = _idaapi.SH3_dmulu_l
SH3_dt = _idaapi.SH3_dt
SH3_exts_b = _idaapi.SH3_exts_b
SH3_exts_w = _idaapi.SH3_exts_w
SH3_extu_b = _idaapi.SH3_extu_b
SH3_extu_w = _idaapi.SH3_extu_w
SH3_jmp = _idaapi.SH3_jmp
SH3_jsr = _idaapi.SH3_jsr
SH3_ldc = _idaapi.SH3_ldc
SH3_ldc_l = _idaapi.SH3_ldc_l
SH3_lds = _idaapi.SH3_lds
SH3_lds_l = _idaapi.SH3_lds_l
SH3_ldtlb = _idaapi.SH3_ldtlb
SH3_mac_w = _idaapi.SH3_mac_w
SH3_mac_l = _idaapi.SH3_mac_l
SH3_mov = _idaapi.SH3_mov
SH3_mov_b = _idaapi.SH3_mov_b
SH3_mov_w = _idaapi.SH3_mov_w
SH3_mov_l = _idaapi.SH3_mov_l
SH3_movi = _idaapi.SH3_movi
SH3_movi_w = _idaapi.SH3_movi_w
SH3_movi_l = _idaapi.SH3_movi_l
SH3_movp_b = _idaapi.SH3_movp_b
SH3_movp_w = _idaapi.SH3_movp_w
SH3_movp_l = _idaapi.SH3_movp_l
SH3_movs_b = _idaapi.SH3_movs_b
SH3_movs_w = _idaapi.SH3_movs_w
SH3_movs_l = _idaapi.SH3_movs_l
SH3_mova = _idaapi.SH3_mova
SH3_movt = _idaapi.SH3_movt
SH3_mul = _idaapi.SH3_mul
SH3_muls = _idaapi.SH3_muls
SH3_mulu = _idaapi.SH3_mulu
SH3_neg = _idaapi.SH3_neg
SH3_negc = _idaapi.SH3_negc
SH3_nop = _idaapi.SH3_nop
SH3_not = _idaapi.SH3_not
SH3_or = _idaapi.SH3_or
SH3_or_b = _idaapi.SH3_or_b
SH3_pref = _idaapi.SH3_pref
SH3_rotcl = _idaapi.SH3_rotcl
SH3_rotcr = _idaapi.SH3_rotcr
SH3_rotl = _idaapi.SH3_rotl
SH3_rotr = _idaapi.SH3_rotr
SH3_rte = _idaapi.SH3_rte
SH3_rts = _idaapi.SH3_rts
SH3_sets = _idaapi.SH3_sets
SH3_sett = _idaapi.SH3_sett
SH3_shad = _idaapi.SH3_shad
SH3_shal = _idaapi.SH3_shal
SH3_shar = _idaapi.SH3_shar
SH3_shld = _idaapi.SH3_shld
SH3_shll = _idaapi.SH3_shll
SH3_shll2 = _idaapi.SH3_shll2
SH3_shll8 = _idaapi.SH3_shll8
SH3_shll16 = _idaapi.SH3_shll16
SH3_shlr = _idaapi.SH3_shlr
SH3_shlr2 = _idaapi.SH3_shlr2
SH3_shlr8 = _idaapi.SH3_shlr8
SH3_shlr16 = _idaapi.SH3_shlr16
SH3_sleep = _idaapi.SH3_sleep
SH3_stc = _idaapi.SH3_stc
SH3_stc_l = _idaapi.SH3_stc_l
SH3_sts = _idaapi.SH3_sts
SH3_sts_l = _idaapi.SH3_sts_l
SH3_sub = _idaapi.SH3_sub
SH3_subc = _idaapi.SH3_subc
SH3_subv = _idaapi.SH3_subv
SH3_swap_b = _idaapi.SH3_swap_b
SH3_swap_w = _idaapi.SH3_swap_w
SH3_tas_b = _idaapi.SH3_tas_b
SH3_trapa = _idaapi.SH3_trapa
SH3_tst = _idaapi.SH3_tst
SH3_tst_b = _idaapi.SH3_tst_b
SH3_xor = _idaapi.SH3_xor
SH3_xor_b = _idaapi.SH3_xor_b
SH3_xtrct = _idaapi.SH3_xtrct
SH4_fabs = _idaapi.SH4_fabs
SH4_fadd = _idaapi.SH4_fadd
SH4_fcmp_eq = _idaapi.SH4_fcmp_eq
SH4_fcmp_gt = _idaapi.SH4_fcmp_gt
SH4_fcnvds = _idaapi.SH4_fcnvds
SH4_fcnvsd = _idaapi.SH4_fcnvsd
SH4_fdiv = _idaapi.SH4_fdiv
SH4_fipr = _idaapi.SH4_fipr
SH4_fldi0 = _idaapi.SH4_fldi0
SH4_fldi1 = _idaapi.SH4_fldi1
SH4_flds = _idaapi.SH4_flds
SH4_float = _idaapi.SH4_float
SH4_fmac = _idaapi.SH4_fmac
SH4_fmov = _idaapi.SH4_fmov
SH4_fmov_s = _idaapi.SH4_fmov_s
SH4_fmovex = _idaapi.SH4_fmovex
SH4_fmul = _idaapi.SH4_fmul
SH4_fneg = _idaapi.SH4_fneg
SH4_frchg = _idaapi.SH4_frchg
SH4_fschg = _idaapi.SH4_fschg
SH4_fsqrt = _idaapi.SH4_fsqrt
SH4_fsts = _idaapi.SH4_fsts
SH4_fsub = _idaapi.SH4_fsub
SH4_ftrc = _idaapi.SH4_ftrc
SH4_ftrv = _idaapi.SH4_ftrv
SH4_ftstn = _idaapi.SH4_ftstn
SH4_movca_l = _idaapi.SH4_movca_l
SH4_ocbi = _idaapi.SH4_ocbi
SH4_ocbp = _idaapi.SH4_ocbp
SH4_ocbwb = _idaapi.SH4_ocbwb
SH4_fsca = _idaapi.SH4_fsca
SH2a_band_b = _idaapi.SH2a_band_b
SH2a_bandnot_b = _idaapi.SH2a_bandnot_b
SH2a_bclr = _idaapi.SH2a_bclr
SH2a_bclr_b = _idaapi.SH2a_bclr_b
SH2a_bld = _idaapi.SH2a_bld
SH2a_bld_b = _idaapi.SH2a_bld_b
SH2a_bldnot_b = _idaapi.SH2a_bldnot_b
SH2a_bor_b = _idaapi.SH2a_bor_b
SH2a_bornot_b = _idaapi.SH2a_bornot_b
SH2a_bset = _idaapi.SH2a_bset
SH2a_bset_b = _idaapi.SH2a_bset_b
SH2a_bst = _idaapi.SH2a_bst
SH2a_bst_b = _idaapi.SH2a_bst_b
SH2a_bxor_b = _idaapi.SH2a_bxor_b
SH2a_clips_b = _idaapi.SH2a_clips_b
SH2a_clips_w = _idaapi.SH2a_clips_w
SH2a_clipu_b = _idaapi.SH2a_clipu_b
SH2a_clipu_w = _idaapi.SH2a_clipu_w
SH2a_divs = _idaapi.SH2a_divs
SH2a_divu = _idaapi.SH2a_divu
SH2a_jsr_n = _idaapi.SH2a_jsr_n
SH2a_ldbank = _idaapi.SH2a_ldbank
SH2a_movi20 = _idaapi.SH2a_movi20
SH2a_movi20s = _idaapi.SH2a_movi20s
SH2a_movml_l = _idaapi.SH2a_movml_l
SH2a_movmu_l = _idaapi.SH2a_movmu_l
SH2a_movrt = _idaapi.SH2a_movrt
SH2a_movu_b = _idaapi.SH2a_movu_b
SH2a_movu_w = _idaapi.SH2a_movu_w
SH2a_mulr = _idaapi.SH2a_mulr
SH2a_nott = _idaapi.SH2a_nott
SH2a_resbank = _idaapi.SH2a_resbank
SH2a_rts_n = _idaapi.SH2a_rts_n
SH2a_rtv_n = _idaapi.SH2a_rtv_n
SH2a_stbank = _idaapi.SH2a_stbank
SH4a_movco_l = _idaapi.SH4a_movco_l
SH4a_movli_l = _idaapi.SH4a_movli_l
SH4a_movua_l = _idaapi.SH4a_movua_l
SH4a_icbi = _idaapi.SH4a_icbi
SH4a_prefi = _idaapi.SH4a_prefi
SH4a_synco = _idaapi.SH4a_synco
SH4a_fsrra = _idaapi.SH4a_fsrra
SH4a_fpchg = _idaapi.SH4a_fpchg
SH4_last = _idaapi.SH4_last
Z8_null = _idaapi.Z8_null
Z8_adc = _idaapi.Z8_adc
Z8_add = _idaapi.Z8_add
Z8_and = _idaapi.Z8_and
Z8_call = _idaapi.Z8_call
Z8_ccf = _idaapi.Z8_ccf
Z8_clr = _idaapi.Z8_clr
Z8_com = _idaapi.Z8_com
Z8_cp = _idaapi.Z8_cp
Z8_da = _idaapi.Z8_da
Z8_dec = _idaapi.Z8_dec
Z8_decw = _idaapi.Z8_decw
Z8_di = _idaapi.Z8_di
Z8_djnz = _idaapi.Z8_djnz
Z8_ei = _idaapi.Z8_ei
Z8_halt = _idaapi.Z8_halt
Z8_inc = _idaapi.Z8_inc
Z8_incw = _idaapi.Z8_incw
Z8_iret = _idaapi.Z8_iret
Z8_jp = _idaapi.Z8_jp
Z8_jpcond = _idaapi.Z8_jpcond
Z8_jr = _idaapi.Z8_jr
Z8_jrcond = _idaapi.Z8_jrcond
Z8_ld = _idaapi.Z8_ld
Z8_ldc = _idaapi.Z8_ldc
Z8_ldci = _idaapi.Z8_ldci
Z8_lde = _idaapi.Z8_lde
Z8_ldei = _idaapi.Z8_ldei
Z8_nop = _idaapi.Z8_nop
Z8_or = _idaapi.Z8_or
Z8_pop = _idaapi.Z8_pop
Z8_push = _idaapi.Z8_push
Z8_rcf = _idaapi.Z8_rcf
Z8_ret = _idaapi.Z8_ret
Z8_rl = _idaapi.Z8_rl
Z8_rlc = _idaapi.Z8_rlc
Z8_rr = _idaapi.Z8_rr
Z8_rrc = _idaapi.Z8_rrc
Z8_sbc = _idaapi.Z8_sbc
Z8_scf = _idaapi.Z8_scf
Z8_sra = _idaapi.Z8_sra
Z8_srp = _idaapi.Z8_srp
Z8_stop = _idaapi.Z8_stop
Z8_sub = _idaapi.Z8_sub
Z8_swap = _idaapi.Z8_swap
Z8_tm = _idaapi.Z8_tm
Z8_tcm = _idaapi.Z8_tcm
Z8_xor = _idaapi.Z8_xor
Z8_wdh = _idaapi.Z8_wdh
Z8_wdt = _idaapi.Z8_wdt
Z8_last = _idaapi.Z8_last
AVR_null = _idaapi.AVR_null
AVR_add = _idaapi.AVR_add
AVR_adc = _idaapi.AVR_adc
AVR_adiw = _idaapi.AVR_adiw
AVR_sub = _idaapi.AVR_sub
AVR_subi = _idaapi.AVR_subi
AVR_sbc = _idaapi.AVR_sbc
AVR_sbci = _idaapi.AVR_sbci
AVR_sbiw = _idaapi.AVR_sbiw
AVR_and = _idaapi.AVR_and
AVR_andi = _idaapi.AVR_andi
AVR_or = _idaapi.AVR_or
AVR_ori = _idaapi.AVR_ori
AVR_eor = _idaapi.AVR_eor
AVR_com = _idaapi.AVR_com
AVR_neg = _idaapi.AVR_neg
AVR_sbr = _idaapi.AVR_sbr
AVR_cbr = _idaapi.AVR_cbr
AVR_inc = _idaapi.AVR_inc
AVR_dec = _idaapi.AVR_dec
AVR_tst = _idaapi.AVR_tst
AVR_clr = _idaapi.AVR_clr
AVR_ser = _idaapi.AVR_ser
AVR_cp = _idaapi.AVR_cp
AVR_cpc = _idaapi.AVR_cpc
AVR_cpi = _idaapi.AVR_cpi
AVR_mul = _idaapi.AVR_mul
AVR_rjmp = _idaapi.AVR_rjmp
AVR_ijmp = _idaapi.AVR_ijmp
AVR_jmp = _idaapi.AVR_jmp
AVR_rcall = _idaapi.AVR_rcall
AVR_icall = _idaapi.AVR_icall
AVR_call = _idaapi.AVR_call
AVR_ret = _idaapi.AVR_ret
AVR_reti = _idaapi.AVR_reti
AVR_cpse = _idaapi.AVR_cpse
AVR_sbrc = _idaapi.AVR_sbrc
AVR_sbrs = _idaapi.AVR_sbrs
AVR_sbic = _idaapi.AVR_sbic
AVR_sbis = _idaapi.AVR_sbis
AVR_brbs = _idaapi.AVR_brbs
AVR_brbc = _idaapi.AVR_brbc
AVR_breq = _idaapi.AVR_breq
AVR_brne = _idaapi.AVR_brne
AVR_brcs = _idaapi.AVR_brcs
AVR_brcc = _idaapi.AVR_brcc
AVR_brsh = _idaapi.AVR_brsh
AVR_brlo = _idaapi.AVR_brlo
AVR_brmi = _idaapi.AVR_brmi
AVR_brpl = _idaapi.AVR_brpl
AVR_brge = _idaapi.AVR_brge
AVR_brlt = _idaapi.AVR_brlt
AVR_brhs = _idaapi.AVR_brhs
AVR_brhc = _idaapi.AVR_brhc
AVR_brts = _idaapi.AVR_brts
AVR_brtc = _idaapi.AVR_brtc
AVR_brvs = _idaapi.AVR_brvs
AVR_brvc = _idaapi.AVR_brvc
AVR_brie = _idaapi.AVR_brie
AVR_brid = _idaapi.AVR_brid
AVR_mov = _idaapi.AVR_mov
AVR_ldi = _idaapi.AVR_ldi
AVR_lds = _idaapi.AVR_lds
AVR_ld = _idaapi.AVR_ld
AVR_ldd = _idaapi.AVR_ldd
AVR_sts = _idaapi.AVR_sts
AVR_st = _idaapi.AVR_st
AVR_std = _idaapi.AVR_std
AVR_lpm = _idaapi.AVR_lpm
AVR_in = _idaapi.AVR_in
AVR_out = _idaapi.AVR_out
AVR_push = _idaapi.AVR_push
AVR_pop = _idaapi.AVR_pop
AVR_lsl = _idaapi.AVR_lsl
AVR_lsr = _idaapi.AVR_lsr
AVR_rol = _idaapi.AVR_rol
AVR_ror = _idaapi.AVR_ror
AVR_asr = _idaapi.AVR_asr
AVR_swap = _idaapi.AVR_swap
AVR_bset = _idaapi.AVR_bset
AVR_bclr = _idaapi.AVR_bclr
AVR_sbi = _idaapi.AVR_sbi
AVR_cbi = _idaapi.AVR_cbi
AVR_bst = _idaapi.AVR_bst
AVR_bld = _idaapi.AVR_bld
AVR_sec = _idaapi.AVR_sec
AVR_clc = _idaapi.AVR_clc
AVR_sen = _idaapi.AVR_sen
AVR_cln = _idaapi.AVR_cln
AVR_sez = _idaapi.AVR_sez
AVR_clz = _idaapi.AVR_clz
AVR_sei = _idaapi.AVR_sei
AVR_cli = _idaapi.AVR_cli
AVR_ses = _idaapi.AVR_ses
AVR_cls = _idaapi.AVR_cls
AVR_sev = _idaapi.AVR_sev
AVR_clv = _idaapi.AVR_clv
AVR_set = _idaapi.AVR_set
AVR_clt = _idaapi.AVR_clt
AVR_seh = _idaapi.AVR_seh
AVR_clh = _idaapi.AVR_clh
AVR_nop = _idaapi.AVR_nop
AVR_sleep = _idaapi.AVR_sleep
AVR_wdr = _idaapi.AVR_wdr
AVR_elpm = _idaapi.AVR_elpm
AVR_espm = _idaapi.AVR_espm
AVR_fmul = _idaapi.AVR_fmul
AVR_fmuls = _idaapi.AVR_fmuls
AVR_fmulsu = _idaapi.AVR_fmulsu
AVR_movw = _idaapi.AVR_movw
AVR_muls = _idaapi.AVR_muls
AVR_mulsu = _idaapi.AVR_mulsu
AVR_spm = _idaapi.AVR_spm
AVR_eicall = _idaapi.AVR_eicall
AVR_eijmp = _idaapi.AVR_eijmp
AVR_des = _idaapi.AVR_des
AVR_lac = _idaapi.AVR_lac
AVR_las = _idaapi.AVR_las
AVR_lat = _idaapi.AVR_lat
AVR_xch = _idaapi.AVR_xch
AVR_last = _idaapi.AVR_last
MIPS_null = _idaapi.MIPS_null
MIPS_add = _idaapi.MIPS_add
MIPS_addu = _idaapi.MIPS_addu
MIPS_and = _idaapi.MIPS_and
MIPS_dadd = _idaapi.MIPS_dadd
MIPS_daddu = _idaapi.MIPS_daddu
MIPS_dsub = _idaapi.MIPS_dsub
MIPS_dsubu = _idaapi.MIPS_dsubu
MIPS_nor = _idaapi.MIPS_nor
MIPS_or = _idaapi.MIPS_or
MIPS_slt = _idaapi.MIPS_slt
MIPS_sltu = _idaapi.MIPS_sltu
MIPS_sub = _idaapi.MIPS_sub
MIPS_subu = _idaapi.MIPS_subu
MIPS_xor = _idaapi.MIPS_xor
MIPS_dsll = _idaapi.MIPS_dsll
MIPS_dsll32 = _idaapi.MIPS_dsll32
MIPS_dsra = _idaapi.MIPS_dsra
MIPS_dsra32 = _idaapi.MIPS_dsra32
MIPS_dsrl = _idaapi.MIPS_dsrl
MIPS_dsrl32 = _idaapi.MIPS_dsrl32
MIPS_sll = _idaapi.MIPS_sll
MIPS_sra = _idaapi.MIPS_sra
MIPS_srl = _idaapi.MIPS_srl
MIPS_dsllv = _idaapi.MIPS_dsllv
MIPS_dsrav = _idaapi.MIPS_dsrav
MIPS_dsrlv = _idaapi.MIPS_dsrlv
MIPS_sllv = _idaapi.MIPS_sllv
MIPS_srav = _idaapi.MIPS_srav
MIPS_srlv = _idaapi.MIPS_srlv
MIPS_addi = _idaapi.MIPS_addi
MIPS_addiu = _idaapi.MIPS_addiu
MIPS_daddi = _idaapi.MIPS_daddi
MIPS_daddiu = _idaapi.MIPS_daddiu
MIPS_slti = _idaapi.MIPS_slti
MIPS_sltiu = _idaapi.MIPS_sltiu
MIPS_andi = _idaapi.MIPS_andi
MIPS_ori = _idaapi.MIPS_ori
MIPS_xori = _idaapi.MIPS_xori
MIPS_teq = _idaapi.MIPS_teq
MIPS_tge = _idaapi.MIPS_tge
MIPS_tgeu = _idaapi.MIPS_tgeu
MIPS_tlt = _idaapi.MIPS_tlt
MIPS_tltu = _idaapi.MIPS_tltu
MIPS_tne = _idaapi.MIPS_tne
MIPS_cfc1 = _idaapi.MIPS_cfc1
MIPS_cfc2 = _idaapi.MIPS_cfc2
MIPS_ctc1 = _idaapi.MIPS_ctc1
MIPS_ctc2 = _idaapi.MIPS_ctc2
MIPS_dmfc0 = _idaapi.MIPS_dmfc0
MIPS_qmfc2 = _idaapi.MIPS_qmfc2
MIPS_dmtc0 = _idaapi.MIPS_dmtc0
MIPS_qmtc2 = _idaapi.MIPS_qmtc2
MIPS_mfc0 = _idaapi.MIPS_mfc0
MIPS_mfc1 = _idaapi.MIPS_mfc1
MIPS_mfc2 = _idaapi.MIPS_mfc2
MIPS_mtc0 = _idaapi.MIPS_mtc0
MIPS_mtc1 = _idaapi.MIPS_mtc1
MIPS_mtc2 = _idaapi.MIPS_mtc2
MIPS_teqi = _idaapi.MIPS_teqi
MIPS_tgei = _idaapi.MIPS_tgei
MIPS_tgeiu = _idaapi.MIPS_tgeiu
MIPS_tlti = _idaapi.MIPS_tlti
MIPS_tltiu = _idaapi.MIPS_tltiu
MIPS_tnei = _idaapi.MIPS_tnei
MIPS_ddiv = _idaapi.MIPS_ddiv
MIPS_ddivu = _idaapi.MIPS_ddivu
MIPS_div = _idaapi.MIPS_div
MIPS_divu = _idaapi.MIPS_divu
MIPS_dmult = _idaapi.MIPS_dmult
MIPS_dmultu = _idaapi.MIPS_dmultu
MIPS_mult = _idaapi.MIPS_mult
MIPS_multu = _idaapi.MIPS_multu
MIPS_mthi = _idaapi.MIPS_mthi
MIPS_mtlo = _idaapi.MIPS_mtlo
MIPS_mfhi = _idaapi.MIPS_mfhi
MIPS_mflo = _idaapi.MIPS_mflo
MIPS_cop0 = _idaapi.MIPS_cop0
MIPS_cop1 = _idaapi.MIPS_cop1
MIPS_cop2 = _idaapi.MIPS_cop2
MIPS_break = _idaapi.MIPS_break
MIPS_syscall = _idaapi.MIPS_syscall
MIPS_bc0f = _idaapi.MIPS_bc0f
MIPS_bc1f = _idaapi.MIPS_bc1f
MIPS_bc2f = _idaapi.MIPS_bc2f
MIPS_bc3f = _idaapi.MIPS_bc3f
MIPS_bc0fl = _idaapi.MIPS_bc0fl
MIPS_bc1fl = _idaapi.MIPS_bc1fl
MIPS_bc2fl = _idaapi.MIPS_bc2fl
MIPS_bc3fl = _idaapi.MIPS_bc3fl
MIPS_bc0t = _idaapi.MIPS_bc0t
MIPS_bc1t = _idaapi.MIPS_bc1t
MIPS_bc2t = _idaapi.MIPS_bc2t
MIPS_bc3t = _idaapi.MIPS_bc3t
MIPS_bc0tl = _idaapi.MIPS_bc0tl
MIPS_bc1tl = _idaapi.MIPS_bc1tl
MIPS_bc2tl = _idaapi.MIPS_bc2tl
MIPS_bc3tl = _idaapi.MIPS_bc3tl
MIPS_bgez = _idaapi.MIPS_bgez
MIPS_bgezal = _idaapi.MIPS_bgezal
MIPS_bgezall = _idaapi.MIPS_bgezall
MIPS_bgezl = _idaapi.MIPS_bgezl
MIPS_bgtz = _idaapi.MIPS_bgtz
MIPS_bgtzl = _idaapi.MIPS_bgtzl
MIPS_blez = _idaapi.MIPS_blez
MIPS_blezl = _idaapi.MIPS_blezl
MIPS_bltz = _idaapi.MIPS_bltz
MIPS_bltzal = _idaapi.MIPS_bltzal
MIPS_bltzall = _idaapi.MIPS_bltzall
MIPS_bltzl = _idaapi.MIPS_bltzl
MIPS_beq = _idaapi.MIPS_beq
MIPS_beql = _idaapi.MIPS_beql
MIPS_bne = _idaapi.MIPS_bne
MIPS_bnel = _idaapi.MIPS_bnel
MIPS_jalr = _idaapi.MIPS_jalr
MIPS_j = _idaapi.MIPS_j
MIPS_jr = _idaapi.MIPS_jr
MIPS_jal = _idaapi.MIPS_jal
MIPS_jalx = _idaapi.MIPS_jalx
MIPS_cache = _idaapi.MIPS_cache
MIPS_lb = _idaapi.MIPS_lb
MIPS_lbu = _idaapi.MIPS_lbu
MIPS_ldl = _idaapi.MIPS_ldl
MIPS_ldr = _idaapi.MIPS_ldr
MIPS_lwl = _idaapi.MIPS_lwl
MIPS_lwr = _idaapi.MIPS_lwr
MIPS_ld = _idaapi.MIPS_ld
MIPS_lld = _idaapi.MIPS_lld
MIPS_ldc1 = _idaapi.MIPS_ldc1
MIPS_ldc2 = _idaapi.MIPS_ldc2
MIPS_ll = _idaapi.MIPS_ll
MIPS_lw = _idaapi.MIPS_lw
MIPS_lwu = _idaapi.MIPS_lwu
MIPS_lh = _idaapi.MIPS_lh
MIPS_lhu = _idaapi.MIPS_lhu
MIPS_lui = _idaapi.MIPS_lui
MIPS_lwc1 = _idaapi.MIPS_lwc1
MIPS_lwc2 = _idaapi.MIPS_lwc2
MIPS_sb = _idaapi.MIPS_sb
MIPS_sdl = _idaapi.MIPS_sdl
MIPS_sdr = _idaapi.MIPS_sdr
MIPS_swl = _idaapi.MIPS_swl
MIPS_swr = _idaapi.MIPS_swr
MIPS_scd = _idaapi.MIPS_scd
MIPS_sd = _idaapi.MIPS_sd
MIPS_sdc1 = _idaapi.MIPS_sdc1
MIPS_sdc2 = _idaapi.MIPS_sdc2
MIPS_sc = _idaapi.MIPS_sc
MIPS_sw = _idaapi.MIPS_sw
MIPS_sh = _idaapi.MIPS_sh
MIPS_swc1 = _idaapi.MIPS_swc1
MIPS_swc2 = _idaapi.MIPS_swc2
MIPS_sync = _idaapi.MIPS_sync
MIPS_eret = _idaapi.MIPS_eret
MIPS_tlbp = _idaapi.MIPS_tlbp
MIPS_tlbr = _idaapi.MIPS_tlbr
MIPS_tlbwi = _idaapi.MIPS_tlbwi
MIPS_tlbwr = _idaapi.MIPS_tlbwr
MIPS_fadd = _idaapi.MIPS_fadd
MIPS_fsub = _idaapi.MIPS_fsub
MIPS_fmul = _idaapi.MIPS_fmul
MIPS_fdiv = _idaapi.MIPS_fdiv
MIPS_fabs = _idaapi.MIPS_fabs
MIPS_fcvt_s = _idaapi.MIPS_fcvt_s
MIPS_fcvt_d = _idaapi.MIPS_fcvt_d
MIPS_fcvt_w = _idaapi.MIPS_fcvt_w
MIPS_fcvt_l = _idaapi.MIPS_fcvt_l
MIPS_fround_l = _idaapi.MIPS_fround_l
MIPS_ftrunc_l = _idaapi.MIPS_ftrunc_l
MIPS_fceil_l = _idaapi.MIPS_fceil_l
MIPS_ffloor_l = _idaapi.MIPS_ffloor_l
MIPS_fround_w = _idaapi.MIPS_fround_w
MIPS_ftrunc_w = _idaapi.MIPS_ftrunc_w
MIPS_fceil_w = _idaapi.MIPS_fceil_w
MIPS_ffloor_w = _idaapi.MIPS_ffloor_w
MIPS_fmov = _idaapi.MIPS_fmov
MIPS_fneg = _idaapi.MIPS_fneg
MIPS_fsqrt = _idaapi.MIPS_fsqrt
MIPS_fc_f = _idaapi.MIPS_fc_f
MIPS_fc_un = _idaapi.MIPS_fc_un
MIPS_fc_eq = _idaapi.MIPS_fc_eq
MIPS_fc_ueq = _idaapi.MIPS_fc_ueq
MIPS_fc_olt = _idaapi.MIPS_fc_olt
MIPS_fc_ult = _idaapi.MIPS_fc_ult
MIPS_fc_ole = _idaapi.MIPS_fc_ole
MIPS_fc_ule = _idaapi.MIPS_fc_ule
MIPS_fc_sf = _idaapi.MIPS_fc_sf
MIPS_fc_ngle = _idaapi.MIPS_fc_ngle
MIPS_fc_seq = _idaapi.MIPS_fc_seq
MIPS_fc_ngl = _idaapi.MIPS_fc_ngl
MIPS_fc_lt = _idaapi.MIPS_fc_lt
MIPS_fc_nge = _idaapi.MIPS_fc_nge
MIPS_fc_le = _idaapi.MIPS_fc_le
MIPS_fc_ngt = _idaapi.MIPS_fc_ngt
MIPS_nop = _idaapi.MIPS_nop
MIPS_mov = _idaapi.MIPS_mov
MIPS_neg = _idaapi.MIPS_neg
MIPS_negu = _idaapi.MIPS_negu
MIPS_bnez = _idaapi.MIPS_bnez
MIPS_bnezl = _idaapi.MIPS_bnezl
MIPS_beqz = _idaapi.MIPS_beqz
MIPS_beqzl = _idaapi.MIPS_beqzl
MIPS_b = _idaapi.MIPS_b
MIPS_bal = _idaapi.MIPS_bal
MIPS_li = _idaapi.MIPS_li
MIPS_la = _idaapi.MIPS_la
MIPS_pref = _idaapi.MIPS_pref
MIPS_ldxc1 = _idaapi.MIPS_ldxc1
MIPS_lwxc1 = _idaapi.MIPS_lwxc1
MIPS_sdxc1 = _idaapi.MIPS_sdxc1
MIPS_swxc1 = _idaapi.MIPS_swxc1
MIPS_madd_s = _idaapi.MIPS_madd_s
MIPS_madd_d = _idaapi.MIPS_madd_d
MIPS_msub_s = _idaapi.MIPS_msub_s
MIPS_msub_d = _idaapi.MIPS_msub_d
MIPS_movf = _idaapi.MIPS_movf
MIPS_movt = _idaapi.MIPS_movt
MIPS_movn = _idaapi.MIPS_movn
MIPS_movz = _idaapi.MIPS_movz
MIPS_fmovf = _idaapi.MIPS_fmovf
MIPS_fmovt = _idaapi.MIPS_fmovt
MIPS_fmovn = _idaapi.MIPS_fmovn
MIPS_fmovz = _idaapi.MIPS_fmovz
MIPS_nmadd_s = _idaapi.MIPS_nmadd_s
MIPS_nmadd_d = _idaapi.MIPS_nmadd_d
MIPS_nmsub_s = _idaapi.MIPS_nmsub_s
MIPS_nmsub_d = _idaapi.MIPS_nmsub_d
MIPS_prefx = _idaapi.MIPS_prefx
MIPS_frecip = _idaapi.MIPS_frecip
MIPS_frsqrt = _idaapi.MIPS_frsqrt
MIPS_lbv = _idaapi.MIPS_lbv
MIPS_lsv = _idaapi.MIPS_lsv
MIPS_llv = _idaapi.MIPS_llv
MIPS_ldv = _idaapi.MIPS_ldv
MIPS_lqv = _idaapi.MIPS_lqv
MIPS_lrv = _idaapi.MIPS_lrv
MIPS_lpv = _idaapi.MIPS_lpv
MIPS_luv = _idaapi.MIPS_luv
MIPS_lhv = _idaapi.MIPS_lhv
MIPS_lfv = _idaapi.MIPS_lfv
MIPS_lwv = _idaapi.MIPS_lwv
MIPS_ltv = _idaapi.MIPS_ltv
MIPS_sbv = _idaapi.MIPS_sbv
MIPS_ssv = _idaapi.MIPS_ssv
MIPS_slv = _idaapi.MIPS_slv
MIPS_sdv = _idaapi.MIPS_sdv
MIPS_sqv = _idaapi.MIPS_sqv
MIPS_srv = _idaapi.MIPS_srv
MIPS_spv = _idaapi.MIPS_spv
MIPS_suv = _idaapi.MIPS_suv
MIPS_shv = _idaapi.MIPS_shv
MIPS_sfv = _idaapi.MIPS_sfv
MIPS_swv = _idaapi.MIPS_swv
MIPS_stv = _idaapi.MIPS_stv
MIPS_vmulf = _idaapi.MIPS_vmulf
MIPS_vmacf = _idaapi.MIPS_vmacf
MIPS_vmulu = _idaapi.MIPS_vmulu
MIPS_vmacu = _idaapi.MIPS_vmacu
MIPS_vrndp = _idaapi.MIPS_vrndp
MIPS_vrndn = _idaapi.MIPS_vrndn
MIPS_vmulq = _idaapi.MIPS_vmulq
MIPS_vmacq = _idaapi.MIPS_vmacq
MIPS_vmudh = _idaapi.MIPS_vmudh
MIPS_vmadh = _idaapi.MIPS_vmadh
MIPS_vmudm = _idaapi.MIPS_vmudm
MIPS_vmadm = _idaapi.MIPS_vmadm
MIPS_vmudn = _idaapi.MIPS_vmudn
MIPS_vmadn = _idaapi.MIPS_vmadn
MIPS_vmudl = _idaapi.MIPS_vmudl
MIPS_vmadl = _idaapi.MIPS_vmadl
MIPS_vadd = _idaapi.MIPS_vadd
MIPS_vsub = _idaapi.MIPS_vsub
MIPS_vsut = _idaapi.MIPS_vsut
MIPS_vabs = _idaapi.MIPS_vabs
MIPS_vaddc = _idaapi.MIPS_vaddc
MIPS_vsubc = _idaapi.MIPS_vsubc
MIPS_vaddb = _idaapi.MIPS_vaddb
MIPS_vsubb = _idaapi.MIPS_vsubb
MIPS_vaccb = _idaapi.MIPS_vaccb
MIPS_vsucb = _idaapi.MIPS_vsucb
MIPS_vsad = _idaapi.MIPS_vsad
MIPS_vsac = _idaapi.MIPS_vsac
MIPS_vsum = _idaapi.MIPS_vsum
MIPS_vsaw = _idaapi.MIPS_vsaw
MIPS_vlt = _idaapi.MIPS_vlt
MIPS_veq = _idaapi.MIPS_veq
MIPS_vne = _idaapi.MIPS_vne
MIPS_vge = _idaapi.MIPS_vge
MIPS_vcl = _idaapi.MIPS_vcl
MIPS_vch = _idaapi.MIPS_vch
MIPS_vcr = _idaapi.MIPS_vcr
MIPS_vmrg = _idaapi.MIPS_vmrg
MIPS_vand = _idaapi.MIPS_vand
MIPS_vnand = _idaapi.MIPS_vnand
MIPS_vor = _idaapi.MIPS_vor
MIPS_vnor = _idaapi.MIPS_vnor
MIPS_vxor = _idaapi.MIPS_vxor
MIPS_vnxor = _idaapi.MIPS_vnxor
MIPS_vnoop = _idaapi.MIPS_vnoop
MIPS_vmov = _idaapi.MIPS_vmov
MIPS_vrcp = _idaapi.MIPS_vrcp
MIPS_vrsq = _idaapi.MIPS_vrsq
MIPS_vrcph = _idaapi.MIPS_vrcph
MIPS_vrsqh = _idaapi.MIPS_vrsqh
MIPS_vrcpl = _idaapi.MIPS_vrcpl
MIPS_vrsql = _idaapi.MIPS_vrsql
MIPS_vinst = _idaapi.MIPS_vinst
MIPS_vextt = _idaapi.MIPS_vextt
MIPS_vinsq = _idaapi.MIPS_vinsq
MIPS_vextq = _idaapi.MIPS_vextq
MIPS_vinsn = _idaapi.MIPS_vinsn
MIPS_vextn = _idaapi.MIPS_vextn
MIPS_cfc0 = _idaapi.MIPS_cfc0
MIPS_ctc0 = _idaapi.MIPS_ctc0
MIPS_mtsa = _idaapi.MIPS_mtsa
MIPS_R5900_first = _idaapi.MIPS_R5900_first
MIPS_mfsa = _idaapi.MIPS_mfsa
MIPS_mtsab = _idaapi.MIPS_mtsab
MIPS_mtsah = _idaapi.MIPS_mtsah
MIPS_fadda = _idaapi.MIPS_fadda
MIPS_fsuba = _idaapi.MIPS_fsuba
MIPS_fmula = _idaapi.MIPS_fmula
MIPS_fmadda = _idaapi.MIPS_fmadda
MIPS_fmsuba = _idaapi.MIPS_fmsuba
MIPS_fmadd = _idaapi.MIPS_fmadd
MIPS_fmsub = _idaapi.MIPS_fmsub
MIPS_fmax = _idaapi.MIPS_fmax
MIPS_fmin = _idaapi.MIPS_fmin
MIPS_plzcw = _idaapi.MIPS_plzcw
MIPS_mthi1 = _idaapi.MIPS_mthi1
MIPS_mtlo1 = _idaapi.MIPS_mtlo1
MIPS_pmthl_lw = _idaapi.MIPS_pmthl_lw
MIPS_pmthi = _idaapi.MIPS_pmthi
MIPS_pmtlo = _idaapi.MIPS_pmtlo
MIPS_div1 = _idaapi.MIPS_div1
MIPS_divu1 = _idaapi.MIPS_divu1
MIPS_pdivw = _idaapi.MIPS_pdivw
MIPS_pdivuw = _idaapi.MIPS_pdivuw
MIPS_pdivbw = _idaapi.MIPS_pdivbw
MIPS_paddw = _idaapi.MIPS_paddw
MIPS_pmaddw = _idaapi.MIPS_pmaddw
MIPS_mult1 = _idaapi.MIPS_mult1
MIPS_multu1 = _idaapi.MIPS_multu1
MIPS_madd1 = _idaapi.MIPS_madd1
MIPS_maddu1 = _idaapi.MIPS_maddu1
MIPS_pmadduw = _idaapi.MIPS_pmadduw
MIPS_psubw = _idaapi.MIPS_psubw
MIPS_pcgtw = _idaapi.MIPS_pcgtw
MIPS_psllvw = _idaapi.MIPS_psllvw
MIPS_pceqw = _idaapi.MIPS_pceqw
MIPS_pmaxw = _idaapi.MIPS_pmaxw
MIPS_psrlvw = _idaapi.MIPS_psrlvw
MIPS_pminw = _idaapi.MIPS_pminw
MIPS_psravw = _idaapi.MIPS_psravw
MIPS_paddh = _idaapi.MIPS_paddh
MIPS_pmsubw = _idaapi.MIPS_pmsubw
MIPS_padsbh = _idaapi.MIPS_padsbh
MIPS_psubh = _idaapi.MIPS_psubh
MIPS_pcgth = _idaapi.MIPS_pcgth
MIPS_pceqh = _idaapi.MIPS_pceqh
MIPS_pmaxh = _idaapi.MIPS_pmaxh
MIPS_pminh = _idaapi.MIPS_pminh
MIPS_paddb = _idaapi.MIPS_paddb
MIPS_psubb = _idaapi.MIPS_psubb
MIPS_pcgtb = _idaapi.MIPS_pcgtb
MIPS_pinth = _idaapi.MIPS_pinth
MIPS_pceqb = _idaapi.MIPS_pceqb
MIPS_pintoh = _idaapi.MIPS_pintoh
MIPS_pmultw = _idaapi.MIPS_pmultw
MIPS_pmultuw = _idaapi.MIPS_pmultuw
MIPS_pcpyld = _idaapi.MIPS_pcpyld
MIPS_pcpyud = _idaapi.MIPS_pcpyud
MIPS_paddsw = _idaapi.MIPS_paddsw
MIPS_pmaddh = _idaapi.MIPS_pmaddh
MIPS_padduw = _idaapi.MIPS_padduw
MIPS_psubsw = _idaapi.MIPS_psubsw
MIPS_phmadh = _idaapi.MIPS_phmadh
MIPS_psubuw = _idaapi.MIPS_psubuw
MIPS_pextlw = _idaapi.MIPS_pextlw
MIPS_pand = _idaapi.MIPS_pand
MIPS_pextuw = _idaapi.MIPS_pextuw
MIPS_por = _idaapi.MIPS_por
MIPS_ppacw = _idaapi.MIPS_ppacw
MIPS_pxor = _idaapi.MIPS_pxor
MIPS_pnor = _idaapi.MIPS_pnor
MIPS_paddsh = _idaapi.MIPS_paddsh
MIPS_pmsubh = _idaapi.MIPS_pmsubh
MIPS_padduh = _idaapi.MIPS_padduh
MIPS_psubsh = _idaapi.MIPS_psubsh
MIPS_phmsbh = _idaapi.MIPS_phmsbh
MIPS_psubuh = _idaapi.MIPS_psubuh
MIPS_pextlh = _idaapi.MIPS_pextlh
MIPS_pextuh = _idaapi.MIPS_pextuh
MIPS_ppach = _idaapi.MIPS_ppach
MIPS_paddsb = _idaapi.MIPS_paddsb
MIPS_paddub = _idaapi.MIPS_paddub
MIPS_psubsb = _idaapi.MIPS_psubsb
MIPS_psubub = _idaapi.MIPS_psubub
MIPS_pextlb = _idaapi.MIPS_pextlb
MIPS_pextub = _idaapi.MIPS_pextub
MIPS_ppacb = _idaapi.MIPS_ppacb
MIPS_qfsrv = _idaapi.MIPS_qfsrv
MIPS_pmulth = _idaapi.MIPS_pmulth
MIPS_pabsw = _idaapi.MIPS_pabsw
MIPS_pabsh = _idaapi.MIPS_pabsh
MIPS_pexoh = _idaapi.MIPS_pexoh
MIPS_pexch = _idaapi.MIPS_pexch
MIPS_prevh = _idaapi.MIPS_prevh
MIPS_pcpyh = _idaapi.MIPS_pcpyh
MIPS_pext5 = _idaapi.MIPS_pext5
MIPS_pexow = _idaapi.MIPS_pexow
MIPS_pexcw = _idaapi.MIPS_pexcw
MIPS_ppac5 = _idaapi.MIPS_ppac5
MIPS_prot3w = _idaapi.MIPS_prot3w
MIPS_psllh = _idaapi.MIPS_psllh
MIPS_psrlh = _idaapi.MIPS_psrlh
MIPS_psrah = _idaapi.MIPS_psrah
MIPS_psllw = _idaapi.MIPS_psllw
MIPS_psrlw = _idaapi.MIPS_psrlw
MIPS_psraw = _idaapi.MIPS_psraw
MIPS_mfhi1 = _idaapi.MIPS_mfhi1
MIPS_mflo1 = _idaapi.MIPS_mflo1
MIPS_pmfhi = _idaapi.MIPS_pmfhi
MIPS_pmflo = _idaapi.MIPS_pmflo
MIPS_pmfhl = _idaapi.MIPS_pmfhl
MIPS_lq = _idaapi.MIPS_lq
MIPS_sq = _idaapi.MIPS_sq
MIPS_lqc2 = _idaapi.MIPS_lqc2
MIPS_sqc2 = _idaapi.MIPS_sqc2
MIPS_madd_r5900 = _idaapi.MIPS_madd_r5900
MIPS_maddu_r5900 = _idaapi.MIPS_maddu_r5900
MIPS_R5900_last = _idaapi.MIPS_R5900_last
MIPS_mult3 = _idaapi.MIPS_mult3
MIPS_multu3 = _idaapi.MIPS_multu3
MIPS_bteqz = _idaapi.MIPS_bteqz
MIPS_btnez = _idaapi.MIPS_btnez
MIPS_cmp = _idaapi.MIPS_cmp
MIPS_cmpi = _idaapi.MIPS_cmpi
MIPS_extend = _idaapi.MIPS_extend
MIPS_move = _idaapi.MIPS_move
MIPS_not = _idaapi.MIPS_not
MIPS_dla = _idaapi.MIPS_dla
MIPS_clo = _idaapi.MIPS_clo
MIPS_clz = _idaapi.MIPS_clz
MIPS_madd = _idaapi.MIPS_madd
MIPS_maddu = _idaapi.MIPS_maddu
MIPS_msub = _idaapi.MIPS_msub
MIPS_msubu = _idaapi.MIPS_msubu
MIPS_mul = _idaapi.MIPS_mul
MIPS_sdbbp = _idaapi.MIPS_sdbbp
MIPS_wait = _idaapi.MIPS_wait
MIPS_alnv_ps = _idaapi.MIPS_alnv_ps
MIPS_deret = _idaapi.MIPS_deret
MIPS_di = _idaapi.MIPS_di
MIPS_ehb = _idaapi.MIPS_ehb
MIPS_ei = _idaapi.MIPS_ei
MIPS_ext = _idaapi.MIPS_ext
MIPS_fcvt_ps = _idaapi.MIPS_fcvt_ps
MIPS_fcvt_s_pl = _idaapi.MIPS_fcvt_s_pl
MIPS_fcvt_s_pu = _idaapi.MIPS_fcvt_s_pu
MIPS_ins = _idaapi.MIPS_ins
MIPS_jalr_hb = _idaapi.MIPS_jalr_hb
MIPS_jr_hb = _idaapi.MIPS_jr_hb
MIPS_luxc1 = _idaapi.MIPS_luxc1
MIPS_madd_ps = _idaapi.MIPS_madd_ps
MIPS_mfhc1 = _idaapi.MIPS_mfhc1
MIPS_mfhc2 = _idaapi.MIPS_mfhc2
MIPS_msub_ps = _idaapi.MIPS_msub_ps
MIPS_mthc1 = _idaapi.MIPS_mthc1
MIPS_mthc2 = _idaapi.MIPS_mthc2
MIPS_nmadd_ps = _idaapi.MIPS_nmadd_ps
MIPS_nmsub_ps = _idaapi.MIPS_nmsub_ps
MIPS_pll = _idaapi.MIPS_pll
MIPS_plu = _idaapi.MIPS_plu
MIPS_pul = _idaapi.MIPS_pul
MIPS_puu = _idaapi.MIPS_puu
MIPS_rdhwr = _idaapi.MIPS_rdhwr
MIPS_rdpgpr = _idaapi.MIPS_rdpgpr
MIPS_rotr = _idaapi.MIPS_rotr
MIPS_rotrv = _idaapi.MIPS_rotrv
MIPS_seb = _idaapi.MIPS_seb
MIPS_seh = _idaapi.MIPS_seh
MIPS_suxc1 = _idaapi.MIPS_suxc1
MIPS_synci = _idaapi.MIPS_synci
MIPS_wrpgpr = _idaapi.MIPS_wrpgpr
MIPS_wsbh = _idaapi.MIPS_wsbh
MIPS_dmfc1 = _idaapi.MIPS_dmfc1
MIPS_dmtc1 = _idaapi.MIPS_dmtc1
MIPS_save = _idaapi.MIPS_save
MIPS_restore = _idaapi.MIPS_restore
MIPS_jalrc = _idaapi.MIPS_jalrc
MIPS_jrc = _idaapi.MIPS_jrc
MIPS_sew = _idaapi.MIPS_sew
MIPS_zeb = _idaapi.MIPS_zeb
MIPS_zeh = _idaapi.MIPS_zeh
MIPS_zew = _idaapi.MIPS_zew
MIPS_ssnop = _idaapi.MIPS_ssnop
MIPS_li_s = _idaapi.MIPS_li_s
MIPS_li_d = _idaapi.MIPS_li_d
MIPS_dneg = _idaapi.MIPS_dneg
MIPS_dnegu = _idaapi.MIPS_dnegu
MIPS_pause = _idaapi.MIPS_pause
MIPS_dclo = _idaapi.MIPS_dclo
MIPS_dclz = _idaapi.MIPS_dclz
MIPS_dext = _idaapi.MIPS_dext
MIPS_dextm = _idaapi.MIPS_dextm
MIPS_dextu = _idaapi.MIPS_dextu
MIPS_dins = _idaapi.MIPS_dins
MIPS_dinsm = _idaapi.MIPS_dinsm
MIPS_dinsu = _idaapi.MIPS_dinsu
MIPS_dmfc2 = _idaapi.MIPS_dmfc2
MIPS_dmtc2 = _idaapi.MIPS_dmtc2
MIPS_drotr = _idaapi.MIPS_drotr
MIPS_drotr32 = _idaapi.MIPS_drotr32
MIPS_drotrv = _idaapi.MIPS_drotrv
MIPS_dsbh = _idaapi.MIPS_dsbh
MIPS_dshd = _idaapi.MIPS_dshd
MIPS_baddu = _idaapi.MIPS_baddu
MIPS_bbit0 = _idaapi.MIPS_bbit0
MIPS_bbit032 = _idaapi.MIPS_bbit032
MIPS_bbit1 = _idaapi.MIPS_bbit1
MIPS_bbit132 = _idaapi.MIPS_bbit132
MIPS_cins = _idaapi.MIPS_cins
MIPS_cins32 = _idaapi.MIPS_cins32
MIPS_dmul = _idaapi.MIPS_dmul
MIPS_dpop = _idaapi.MIPS_dpop
MIPS_exts = _idaapi.MIPS_exts
MIPS_exts32 = _idaapi.MIPS_exts32
MIPS_mtm0 = _idaapi.MIPS_mtm0
MIPS_mtm1 = _idaapi.MIPS_mtm1
MIPS_mtm2 = _idaapi.MIPS_mtm2
MIPS_mtp0 = _idaapi.MIPS_mtp0
MIPS_mtp1 = _idaapi.MIPS_mtp1
MIPS_mtp2 = _idaapi.MIPS_mtp2
MIPS_pop = _idaapi.MIPS_pop
MIPS_saa = _idaapi.MIPS_saa
MIPS_saad = _idaapi.MIPS_saad
MIPS_seq = _idaapi.MIPS_seq
MIPS_seqi = _idaapi.MIPS_seqi
MIPS_sne = _idaapi.MIPS_sne
MIPS_snei = _idaapi.MIPS_snei
MIPS_synciobdma = _idaapi.MIPS_synciobdma
MIPS_syncs = _idaapi.MIPS_syncs
MIPS_syncw = _idaapi.MIPS_syncw
MIPS_syncws = _idaapi.MIPS_syncws
MIPS_uld = _idaapi.MIPS_uld
MIPS_ulw = _idaapi.MIPS_ulw
MIPS_usd = _idaapi.MIPS_usd
MIPS_usw = _idaapi.MIPS_usw
MIPS_v3mulu = _idaapi.MIPS_v3mulu
MIPS_vmm0 = _idaapi.MIPS_vmm0
MIPS_vmulu_cn = _idaapi.MIPS_vmulu_cn
MIPS_dbreak = _idaapi.MIPS_dbreak
MIPS_dret = _idaapi.MIPS_dret
MIPS_mfdr = _idaapi.MIPS_mfdr
MIPS_mtdr = _idaapi.MIPS_mtdr
PSP_bitrev = _idaapi.PSP_bitrev
PSP_max = _idaapi.PSP_max
PSP_min = _idaapi.PSP_min
PSP_mfic = _idaapi.PSP_mfic
PSP_mtic = _idaapi.PSP_mtic
PSP_wsbw = _idaapi.PSP_wsbw
PSP_sleep = _idaapi.PSP_sleep
PSP_lv = _idaapi.PSP_lv
PSP_lvl = _idaapi.PSP_lvl
PSP_lvr = _idaapi.PSP_lvr
PSP_sv = _idaapi.PSP_sv
PSP_svl = _idaapi.PSP_svl
PSP_svr = _idaapi.PSP_svr
PSP_mfv = _idaapi.PSP_mfv
PSP_mtv = _idaapi.PSP_mtv
PSP_mfvc = _idaapi.PSP_mfvc
PSP_mtvc = _idaapi.PSP_mtvc
PSP_bvf = _idaapi.PSP_bvf
PSP_bvt = _idaapi.PSP_bvt
PSP_bvfl = _idaapi.PSP_bvfl
PSP_bvtl = _idaapi.PSP_bvtl
PSP_vnop = _idaapi.PSP_vnop
PSP_vflush = _idaapi.PSP_vflush
PSP_vsync = _idaapi.PSP_vsync
PSP_vabs = _idaapi.PSP_vabs
PSP_vadd = _idaapi.PSP_vadd
PSP_vasin = _idaapi.PSP_vasin
PSP_vavg = _idaapi.PSP_vavg
PSP_vbfy1 = _idaapi.PSP_vbfy1
PSP_vbfy2 = _idaapi.PSP_vbfy2
PSP_vc2i = _idaapi.PSP_vc2i
PSP_vcmovf = _idaapi.PSP_vcmovf
PSP_vcmovt = _idaapi.PSP_vcmovt
PSP_vcmp = _idaapi.PSP_vcmp
PSP_vcos = _idaapi.PSP_vcos
PSP_vcrs = _idaapi.PSP_vcrs
PSP_vcrsp = _idaapi.PSP_vcrsp
PSP_vcst = _idaapi.PSP_vcst
PSP_vdet = _idaapi.PSP_vdet
PSP_vdiv = _idaapi.PSP_vdiv
PSP_vdot = _idaapi.PSP_vdot
PSP_vexp2 = _idaapi.PSP_vexp2
PSP_vf2h = _idaapi.PSP_vf2h
PSP_vf2id = _idaapi.PSP_vf2id
PSP_vf2in = _idaapi.PSP_vf2in
PSP_vf2iu = _idaapi.PSP_vf2iu
PSP_vf2iz = _idaapi.PSP_vf2iz
PSP_vfad = _idaapi.PSP_vfad
PSP_vfim = _idaapi.PSP_vfim
PSP_vh2f = _idaapi.PSP_vh2f
PSP_vhdp = _idaapi.PSP_vhdp
PSP_vhtfm2 = _idaapi.PSP_vhtfm2
PSP_vhtfm3 = _idaapi.PSP_vhtfm3
PSP_vhtfm4 = _idaapi.PSP_vhtfm4
PSP_vi2c = _idaapi.PSP_vi2c
PSP_vi2f = _idaapi.PSP_vi2f
PSP_vi2s = _idaapi.PSP_vi2s
PSP_vi2uc = _idaapi.PSP_vi2uc
PSP_vi2us = _idaapi.PSP_vi2us
PSP_vidt = _idaapi.PSP_vidt
PSP_viim = _idaapi.PSP_viim
PSP_vlgb = _idaapi.PSP_vlgb
PSP_vlog2 = _idaapi.PSP_vlog2
PSP_vmax = _idaapi.PSP_vmax
PSP_vmfvc = _idaapi.PSP_vmfvc
PSP_vmidt = _idaapi.PSP_vmidt
PSP_vmin = _idaapi.PSP_vmin
PSP_vmmov = _idaapi.PSP_vmmov
PSP_vmmul = _idaapi.PSP_vmmul
PSP_vmone = _idaapi.PSP_vmone
PSP_vmov = _idaapi.PSP_vmov
PSP_vmscl = _idaapi.PSP_vmscl
PSP_vmtvc = _idaapi.PSP_vmtvc
PSP_vmul = _idaapi.PSP_vmul
PSP_vmzero = _idaapi.PSP_vmzero
PSP_vneg = _idaapi.PSP_vneg
PSP_vnrcp = _idaapi.PSP_vnrcp
PSP_vnsin = _idaapi.PSP_vnsin
PSP_vocp = _idaapi.PSP_vocp
PSP_vone = _idaapi.PSP_vone
PSP_vpfxd = _idaapi.PSP_vpfxd
PSP_vpfxs = _idaapi.PSP_vpfxs
PSP_vpfxt = _idaapi.PSP_vpfxt
PSP_vqmul = _idaapi.PSP_vqmul
PSP_vrcp = _idaapi.PSP_vrcp
PSP_vrexp2 = _idaapi.PSP_vrexp2
PSP_vrndf1 = _idaapi.PSP_vrndf1
PSP_vrndf2 = _idaapi.PSP_vrndf2
PSP_vrndi = _idaapi.PSP_vrndi
PSP_vrnds = _idaapi.PSP_vrnds
PSP_vrot = _idaapi.PSP_vrot
PSP_vrsq = _idaapi.PSP_vrsq
PSP_vs2i = _idaapi.PSP_vs2i
PSP_vsat0 = _idaapi.PSP_vsat0
PSP_vsat1 = _idaapi.PSP_vsat1
PSP_vsbn = _idaapi.PSP_vsbn
PSP_vsbz = _idaapi.PSP_vsbz
PSP_vscl = _idaapi.PSP_vscl
PSP_vscmp = _idaapi.PSP_vscmp
PSP_vsge = _idaapi.PSP_vsge
PSP_vsgn = _idaapi.PSP_vsgn
PSP_vsin = _idaapi.PSP_vsin
PSP_vslt = _idaapi.PSP_vslt
PSP_vsocp = _idaapi.PSP_vsocp
PSP_vsqrt = _idaapi.PSP_vsqrt
PSP_vsrt1 = _idaapi.PSP_vsrt1
PSP_vsrt2 = _idaapi.PSP_vsrt2
PSP_vsrt3 = _idaapi.PSP_vsrt3
PSP_vsrt4 = _idaapi.PSP_vsrt4
PSP_vsub = _idaapi.PSP_vsub
PSP_vt4444 = _idaapi.PSP_vt4444
PSP_vt5551 = _idaapi.PSP_vt5551
PSP_vt5650 = _idaapi.PSP_vt5650
PSP_vtfm2 = _idaapi.PSP_vtfm2
PSP_vtfm3 = _idaapi.PSP_vtfm3
PSP_vtfm4 = _idaapi.PSP_vtfm4
PSP_vuc2i = _idaapi.PSP_vuc2i
PSP_vus2i = _idaapi.PSP_vus2i
PSP_vwbn = _idaapi.PSP_vwbn
PSP_vzero = _idaapi.PSP_vzero
PSP_mfvme = _idaapi.PSP_mfvme
PSP_mtvme = _idaapi.PSP_mtvme
MIPS_ac0iu = _idaapi.MIPS_ac0iu
MIPS_bs1f = _idaapi.MIPS_bs1f
MIPS_bfins = _idaapi.MIPS_bfins
MIPS_addmiu = _idaapi.MIPS_addmiu
MIPS_sadd = _idaapi.MIPS_sadd
MIPS_ssub = _idaapi.MIPS_ssub
MIPS_btst = _idaapi.MIPS_btst
MIPS_bclr = _idaapi.MIPS_bclr
MIPS_bset = _idaapi.MIPS_bset
MIPS_bins = _idaapi.MIPS_bins
MIPS_bext = _idaapi.MIPS_bext
MIPS_dive = _idaapi.MIPS_dive
MIPS_diveu = _idaapi.MIPS_diveu
MIPS_min = _idaapi.MIPS_min
MIPS_max = _idaapi.MIPS_max
MIPS_madd3 = _idaapi.MIPS_madd3
MIPS_maddu3 = _idaapi.MIPS_maddu3
MIPS_msub3 = _idaapi.MIPS_msub3
MIPS_msubu3 = _idaapi.MIPS_msubu3
MIPS_dvpe = _idaapi.MIPS_dvpe
MIPS_evpe = _idaapi.MIPS_evpe
MIPS_dmt = _idaapi.MIPS_dmt
MIPS_emt = _idaapi.MIPS_emt
MIPS_fork = _idaapi.MIPS_fork
MIPS_yield = _idaapi.MIPS_yield
MIPS_mftr = _idaapi.MIPS_mftr
MIPS_mftc0 = _idaapi.MIPS_mftc0
MIPS_mftlo = _idaapi.MIPS_mftlo
MIPS_mfthi = _idaapi.MIPS_mfthi
MIPS_mftacx = _idaapi.MIPS_mftacx
MIPS_mftdsp = _idaapi.MIPS_mftdsp
MIPS_mfthc1 = _idaapi.MIPS_mfthc1
MIPS_mftc1 = _idaapi.MIPS_mftc1
MIPS_cftc1 = _idaapi.MIPS_cftc1
MIPS_mfthc2 = _idaapi.MIPS_mfthc2
MIPS_mftc2 = _idaapi.MIPS_mftc2
MIPS_cftc2 = _idaapi.MIPS_cftc2
MIPS_mftgpr = _idaapi.MIPS_mftgpr
MIPS_mttr = _idaapi.MIPS_mttr
MIPS_mttc0 = _idaapi.MIPS_mttc0
MIPS_mttlo = _idaapi.MIPS_mttlo
MIPS_mtthi = _idaapi.MIPS_mtthi
MIPS_mttacx = _idaapi.MIPS_mttacx
MIPS_mttdsp = _idaapi.MIPS_mttdsp
MIPS_mtthc1 = _idaapi.MIPS_mtthc1
MIPS_mttc1 = _idaapi.MIPS_mttc1
MIPS_cttc1 = _idaapi.MIPS_cttc1
MIPS_mtthc2 = _idaapi.MIPS_mtthc2
MIPS_mttc2 = _idaapi.MIPS_mttc2
MIPS_cttc2 = _idaapi.MIPS_cttc2
MIPS_mttgpr = _idaapi.MIPS_mttgpr
MIPS_faddr = _idaapi.MIPS_faddr
MIPS_bc1any2f = _idaapi.MIPS_bc1any2f
MIPS_bc1any2t = _idaapi.MIPS_bc1any2t
MIPS_bc1any4f = _idaapi.MIPS_bc1any4f
MIPS_bc1any4t = _idaapi.MIPS_bc1any4t
MIPS_fcabs_f = _idaapi.MIPS_fcabs_f
MIPS_fcabs_un = _idaapi.MIPS_fcabs_un
MIPS_fcabs_eq = _idaapi.MIPS_fcabs_eq
MIPS_fcabs_ueq = _idaapi.MIPS_fcabs_ueq
MIPS_fcabs_olt = _idaapi.MIPS_fcabs_olt
MIPS_fcabs_ult = _idaapi.MIPS_fcabs_ult
MIPS_fcabs_ole = _idaapi.MIPS_fcabs_ole
MIPS_fcabs_ule = _idaapi.MIPS_fcabs_ule
MIPS_fcabs_sf = _idaapi.MIPS_fcabs_sf
MIPS_fcabs_ngle = _idaapi.MIPS_fcabs_ngle
MIPS_fcabs_seq = _idaapi.MIPS_fcabs_seq
MIPS_fcabs_ngl = _idaapi.MIPS_fcabs_ngl
MIPS_fcabs_lt = _idaapi.MIPS_fcabs_lt
MIPS_fcabs_nge = _idaapi.MIPS_fcabs_nge
MIPS_fcabs_le = _idaapi.MIPS_fcabs_le
MIPS_fcabs_ngt = _idaapi.MIPS_fcabs_ngt
MIPS_fcvt_pw_ps = _idaapi.MIPS_fcvt_pw_ps
MIPS_fcvt_ps_pw = _idaapi.MIPS_fcvt_ps_pw
MIPS_fmulr = _idaapi.MIPS_fmulr
MIPS_frecip1 = _idaapi.MIPS_frecip1
MIPS_frecip2 = _idaapi.MIPS_frecip2
MIPS_frsqrt1 = _idaapi.MIPS_frsqrt1
MIPS_frsqrt2 = _idaapi.MIPS_frsqrt2
MIPS_lwxs = _idaapi.MIPS_lwxs
MIPS_maddp = _idaapi.MIPS_maddp
MIPS_mflhxu = _idaapi.MIPS_mflhxu
MIPS_mtlhx = _idaapi.MIPS_mtlhx
MIPS_multp = _idaapi.MIPS_multp
MIPS_pperm = _idaapi.MIPS_pperm
MIPS_jals = _idaapi.MIPS_jals
MIPS_lwp = _idaapi.MIPS_lwp
MIPS_ldp = _idaapi.MIPS_ldp
MIPS_lwm = _idaapi.MIPS_lwm
MIPS_ldm = _idaapi.MIPS_ldm
MIPS_swp = _idaapi.MIPS_swp
MIPS_sdp = _idaapi.MIPS_sdp
MIPS_swm = _idaapi.MIPS_swm
MIPS_sdm = _idaapi.MIPS_sdm
MIPS_bnezc = _idaapi.MIPS_bnezc
MIPS_bltzals = _idaapi.MIPS_bltzals
MIPS_beqzc = _idaapi.MIPS_beqzc
MIPS_bgezals = _idaapi.MIPS_bgezals
MIPS_jraddiusp = _idaapi.MIPS_jraddiusp
MIPS_jalrs = _idaapi.MIPS_jalrs
MIPS_jalrs_hb = _idaapi.MIPS_jalrs_hb
MIPS_movep = _idaapi.MIPS_movep
MIPS_dli = _idaapi.MIPS_dli
MIPS_insv = _idaapi.MIPS_insv
MIPS_dinsv = _idaapi.MIPS_dinsv
MIPS_bposge32 = _idaapi.MIPS_bposge32
MIPS_bposge64 = _idaapi.MIPS_bposge64
MIPS_addu_qb = _idaapi.MIPS_addu_qb
MIPS_addu_ph = _idaapi.MIPS_addu_ph
MIPS_addsc = _idaapi.MIPS_addsc
MIPS_subu_qb = _idaapi.MIPS_subu_qb
MIPS_subu_ph = _idaapi.MIPS_subu_ph
MIPS_addwc = _idaapi.MIPS_addwc
MIPS_addq_ph = _idaapi.MIPS_addq_ph
MIPS_modsub = _idaapi.MIPS_modsub
MIPS_subq_ph = _idaapi.MIPS_subq_ph
MIPS_addu_s_qb = _idaapi.MIPS_addu_s_qb
MIPS_addu_s_ph = _idaapi.MIPS_addu_s_ph
MIPS_raddu_w_qb = _idaapi.MIPS_raddu_w_qb
MIPS_muleq_s_w_phl = _idaapi.MIPS_muleq_s_w_phl
MIPS_subu_s_qb = _idaapi.MIPS_subu_s_qb
MIPS_subu_s_ph = _idaapi.MIPS_subu_s_ph
MIPS_muleq_s_w_phr = _idaapi.MIPS_muleq_s_w_phr
MIPS_muleu_s_ph_qbl = _idaapi.MIPS_muleu_s_ph_qbl
MIPS_addq_s_ph = _idaapi.MIPS_addq_s_ph
MIPS_addq_s_w = _idaapi.MIPS_addq_s_w
MIPS_mulq_s_ph = _idaapi.MIPS_mulq_s_ph
MIPS_muleu_s_ph_qbr = _idaapi.MIPS_muleu_s_ph_qbr
MIPS_subq_s_ph = _idaapi.MIPS_subq_s_ph
MIPS_subq_s_w = _idaapi.MIPS_subq_s_w
MIPS_mulq_rs_ph = _idaapi.MIPS_mulq_rs_ph
MIPS_addu_ob = _idaapi.MIPS_addu_ob
MIPS_subu_ob = _idaapi.MIPS_subu_ob
MIPS_addq_qh = _idaapi.MIPS_addq_qh
MIPS_addq_pw = _idaapi.MIPS_addq_pw
MIPS_subq_qh = _idaapi.MIPS_subq_qh
MIPS_subq_pw = _idaapi.MIPS_subq_pw
MIPS_addu_s_ob = _idaapi.MIPS_addu_s_ob
MIPS_raddu_l_ob = _idaapi.MIPS_raddu_l_ob
MIPS_muleq_s_pw_qhl = _idaapi.MIPS_muleq_s_pw_qhl
MIPS_subu_s_ob = _idaapi.MIPS_subu_s_ob
MIPS_muleq_s_pw_qhr = _idaapi.MIPS_muleq_s_pw_qhr
MIPS_muleu_s_qh_obl = _idaapi.MIPS_muleu_s_qh_obl
MIPS_addq_s_qh = _idaapi.MIPS_addq_s_qh
MIPS_addq_s_pw = _idaapi.MIPS_addq_s_pw
MIPS_muleu_s_qh_obr = _idaapi.MIPS_muleu_s_qh_obr
MIPS_subq_s_qh = _idaapi.MIPS_subq_s_qh
MIPS_subq_s_pw = _idaapi.MIPS_subq_s_pw
MIPS_mulq_rs_qh = _idaapi.MIPS_mulq_rs_qh
MIPS_cmpu_eq_qb = _idaapi.MIPS_cmpu_eq_qb
MIPS_cmp_eq_ph = _idaapi.MIPS_cmp_eq_ph
MIPS_cmpgdu_eq_qb = _idaapi.MIPS_cmpgdu_eq_qb
MIPS_cmpu_lt_qb = _idaapi.MIPS_cmpu_lt_qb
MIPS_cmp_lt_ph = _idaapi.MIPS_cmp_lt_ph
MIPS_cmpgdu_lt_qb = _idaapi.MIPS_cmpgdu_lt_qb
MIPS_cmpu_le_qb = _idaapi.MIPS_cmpu_le_qb
MIPS_cmp_le_ph = _idaapi.MIPS_cmp_le_ph
MIPS_cmpgdu_le_qb = _idaapi.MIPS_cmpgdu_le_qb
MIPS_pick_qb = _idaapi.MIPS_pick_qb
MIPS_pick_ph = _idaapi.MIPS_pick_ph
MIPS_cmpgu_eq_qb = _idaapi.MIPS_cmpgu_eq_qb
MIPS_precrq_qb_ph = _idaapi.MIPS_precrq_qb_ph
MIPS_precrq_ph_w = _idaapi.MIPS_precrq_ph_w
MIPS_cmpgu_lt_qb = _idaapi.MIPS_cmpgu_lt_qb
MIPS_precr_qb_ph = _idaapi.MIPS_precr_qb_ph
MIPS_precrq_rs_ph_w = _idaapi.MIPS_precrq_rs_ph_w
MIPS_cmpgu_le_qb = _idaapi.MIPS_cmpgu_le_qb
MIPS_packrl_ph = _idaapi.MIPS_packrl_ph
MIPS_precr_sra_ph_w = _idaapi.MIPS_precr_sra_ph_w
MIPS_precrqu_s_qb_ph = _idaapi.MIPS_precrqu_s_qb_ph
MIPS_precr_sra_r_ph_w = _idaapi.MIPS_precr_sra_r_ph_w
MIPS_cmpu_eq_ob = _idaapi.MIPS_cmpu_eq_ob
MIPS_cmp_eq_qh = _idaapi.MIPS_cmp_eq_qh
MIPS_cmp_eq_pw = _idaapi.MIPS_cmp_eq_pw
MIPS_cmpu_lt_ob = _idaapi.MIPS_cmpu_lt_ob
MIPS_cmp_lt_qh = _idaapi.MIPS_cmp_lt_qh
MIPS_cmp_lt_pw = _idaapi.MIPS_cmp_lt_pw
MIPS_cmpu_le_ob = _idaapi.MIPS_cmpu_le_ob
MIPS_cmp_le_qh = _idaapi.MIPS_cmp_le_qh
MIPS_cmp_le_pw = _idaapi.MIPS_cmp_le_pw
MIPS_pick_ob = _idaapi.MIPS_pick_ob
MIPS_pick_qh = _idaapi.MIPS_pick_qh
MIPS_pick_pw = _idaapi.MIPS_pick_pw
MIPS_cmpgu_eq_ob = _idaapi.MIPS_cmpgu_eq_ob
MIPS_precrq_ob_qh = _idaapi.MIPS_precrq_ob_qh
MIPS_precrq_qh_pw = _idaapi.MIPS_precrq_qh_pw
MIPS_precrq_pw_l = _idaapi.MIPS_precrq_pw_l
MIPS_cmpgu_lt_ob = _idaapi.MIPS_cmpgu_lt_ob
MIPS_precrq_rs_qh_pw = _idaapi.MIPS_precrq_rs_qh_pw
MIPS_cmpgu_le_ob = _idaapi.MIPS_cmpgu_le_ob
MIPS_packrl_pw = _idaapi.MIPS_packrl_pw
MIPS_precrqu_s_ob_qh = _idaapi.MIPS_precrqu_s_ob_qh
MIPS_absq_s_qb = _idaapi.MIPS_absq_s_qb
MIPS_absq_s_ph = _idaapi.MIPS_absq_s_ph
MIPS_absq_s_w = _idaapi.MIPS_absq_s_w
MIPS_repl_qb = _idaapi.MIPS_repl_qb
MIPS_repl_ph = _idaapi.MIPS_repl_ph
MIPS_replv_qb = _idaapi.MIPS_replv_qb
MIPS_replv_ph = _idaapi.MIPS_replv_ph
MIPS_bitrev = _idaapi.MIPS_bitrev
MIPS_precequ_ph_qbl = _idaapi.MIPS_precequ_ph_qbl
MIPS_preceq_w_phl = _idaapi.MIPS_preceq_w_phl
MIPS_preceu_ph_qbl = _idaapi.MIPS_preceu_ph_qbl
MIPS_precequ_ph_qbr = _idaapi.MIPS_precequ_ph_qbr
MIPS_preceq_w_phr = _idaapi.MIPS_preceq_w_phr
MIPS_preceu_ph_qbr = _idaapi.MIPS_preceu_ph_qbr
MIPS_precequ_ph_qbla = _idaapi.MIPS_precequ_ph_qbla
MIPS_preceu_ph_qbla = _idaapi.MIPS_preceu_ph_qbla
MIPS_precequ_ph_qbra = _idaapi.MIPS_precequ_ph_qbra
MIPS_preceu_ph_qbra = _idaapi.MIPS_preceu_ph_qbra
MIPS_absq_s_qh = _idaapi.MIPS_absq_s_qh
MIPS_absq_s_pw = _idaapi.MIPS_absq_s_pw
MIPS_repl_ob = _idaapi.MIPS_repl_ob
MIPS_repl_qh = _idaapi.MIPS_repl_qh
MIPS_repl_pw = _idaapi.MIPS_repl_pw
MIPS_replv_ob = _idaapi.MIPS_replv_ob
MIPS_replv_qh = _idaapi.MIPS_replv_qh
MIPS_replv_pw = _idaapi.MIPS_replv_pw
MIPS_precequ_pw_qhl = _idaapi.MIPS_precequ_pw_qhl
MIPS_preceq_pw_qhl = _idaapi.MIPS_preceq_pw_qhl
MIPS_preceq_s_l_pwl = _idaapi.MIPS_preceq_s_l_pwl
MIPS_preceu_qh_obl = _idaapi.MIPS_preceu_qh_obl
MIPS_precequ_pw_qhr = _idaapi.MIPS_precequ_pw_qhr
MIPS_preceq_pw_qhr = _idaapi.MIPS_preceq_pw_qhr
MIPS_preceq_s_l_pwr = _idaapi.MIPS_preceq_s_l_pwr
MIPS_preceu_qh_obr = _idaapi.MIPS_preceu_qh_obr
MIPS_precequ_pw_qhla = _idaapi.MIPS_precequ_pw_qhla
MIPS_preceq_pw_qhla = _idaapi.MIPS_preceq_pw_qhla
MIPS_preceu_qh_obla = _idaapi.MIPS_preceu_qh_obla
MIPS_precequ_pw_qhra = _idaapi.MIPS_precequ_pw_qhra
MIPS_preceq_pw_qhra = _idaapi.MIPS_preceq_pw_qhra
MIPS_preceu_qh_obra = _idaapi.MIPS_preceu_qh_obra
MIPS_shll_qb = _idaapi.MIPS_shll_qb
MIPS_shll_ph = _idaapi.MIPS_shll_ph
MIPS_shrl_qb = _idaapi.MIPS_shrl_qb
MIPS_shra_ph = _idaapi.MIPS_shra_ph
MIPS_shrl_ph = _idaapi.MIPS_shrl_ph
MIPS_shllv_qb = _idaapi.MIPS_shllv_qb
MIPS_shllv_ph = _idaapi.MIPS_shllv_ph
MIPS_shrlv_qb = _idaapi.MIPS_shrlv_qb
MIPS_shrav_ph = _idaapi.MIPS_shrav_ph
MIPS_shrlv_ph = _idaapi.MIPS_shrlv_ph
MIPS_shra_qb = _idaapi.MIPS_shra_qb
MIPS_shll_s_ph = _idaapi.MIPS_shll_s_ph
MIPS_shll_s_w = _idaapi.MIPS_shll_s_w
MIPS_shra_r_qb = _idaapi.MIPS_shra_r_qb
MIPS_shra_r_ph = _idaapi.MIPS_shra_r_ph
MIPS_shra_r_w = _idaapi.MIPS_shra_r_w
MIPS_shrav_qb = _idaapi.MIPS_shrav_qb
MIPS_shllv_s_ph = _idaapi.MIPS_shllv_s_ph
MIPS_shllv_s_w = _idaapi.MIPS_shllv_s_w
MIPS_shrav_r_qb = _idaapi.MIPS_shrav_r_qb
MIPS_shrav_r_ph = _idaapi.MIPS_shrav_r_ph
MIPS_shrav_r_w = _idaapi.MIPS_shrav_r_w
MIPS_shll_ob = _idaapi.MIPS_shll_ob
MIPS_shll_qh = _idaapi.MIPS_shll_qh
MIPS_shll_pw = _idaapi.MIPS_shll_pw
MIPS_shrl_ob = _idaapi.MIPS_shrl_ob
MIPS_shra_qh = _idaapi.MIPS_shra_qh
MIPS_shra_pw = _idaapi.MIPS_shra_pw
MIPS_shllv_ob = _idaapi.MIPS_shllv_ob
MIPS_shllv_qh = _idaapi.MIPS_shllv_qh
MIPS_shllv_pw = _idaapi.MIPS_shllv_pw
MIPS_shrlv_ob = _idaapi.MIPS_shrlv_ob
MIPS_shrav_qh = _idaapi.MIPS_shrav_qh
MIPS_shrav_pw = _idaapi.MIPS_shrav_pw
MIPS_shll_s_qh = _idaapi.MIPS_shll_s_qh
MIPS_shll_s_pw = _idaapi.MIPS_shll_s_pw
MIPS_shra_r_qh = _idaapi.MIPS_shra_r_qh
MIPS_shra_r_pw = _idaapi.MIPS_shra_r_pw
MIPS_shllv_s_qh = _idaapi.MIPS_shllv_s_qh
MIPS_shllv_s_pw = _idaapi.MIPS_shllv_s_pw
MIPS_shrav_r_qh = _idaapi.MIPS_shrav_r_qh
MIPS_shrav_r_pw = _idaapi.MIPS_shrav_r_pw
MIPS_lwx = _idaapi.MIPS_lwx
MIPS_ldx = _idaapi.MIPS_ldx
MIPS_lhx = _idaapi.MIPS_lhx
MIPS_lbux = _idaapi.MIPS_lbux
MIPS_dpa_w_ph = _idaapi.MIPS_dpa_w_ph
MIPS_dpax_w_ph = _idaapi.MIPS_dpax_w_ph
MIPS_maq_sa_w_phl = _idaapi.MIPS_maq_sa_w_phl
MIPS_dpaqx_s_w_ph = _idaapi.MIPS_dpaqx_s_w_ph
MIPS_dps_w_ph = _idaapi.MIPS_dps_w_ph
MIPS_dpsx_w_ph = _idaapi.MIPS_dpsx_w_ph
MIPS_dpsqx_s_w_ph = _idaapi.MIPS_dpsqx_s_w_ph
MIPS_mulsa_w_ph = _idaapi.MIPS_mulsa_w_ph
MIPS_maq_sa_w_phr = _idaapi.MIPS_maq_sa_w_phr
MIPS_dpaqx_sa_w_ph = _idaapi.MIPS_dpaqx_sa_w_ph
MIPS_dpau_h_qbl = _idaapi.MIPS_dpau_h_qbl
MIPS_dpsu_h_qbl = _idaapi.MIPS_dpsu_h_qbl
MIPS_dpsqx_sa_w_ph = _idaapi.MIPS_dpsqx_sa_w_ph
MIPS_dpaq_s_w_ph = _idaapi.MIPS_dpaq_s_w_ph
MIPS_dpaq_sa_l_w = _idaapi.MIPS_dpaq_sa_l_w
MIPS_maq_s_w_phl = _idaapi.MIPS_maq_s_w_phl
MIPS_dpsq_s_w_ph = _idaapi.MIPS_dpsq_s_w_ph
MIPS_dpsq_sa_l_w = _idaapi.MIPS_dpsq_sa_l_w
MIPS_mulsaq_s_w_ph = _idaapi.MIPS_mulsaq_s_w_ph
MIPS_maq_s_w_phr = _idaapi.MIPS_maq_s_w_phr
MIPS_dpau_h_qbr = _idaapi.MIPS_dpau_h_qbr
MIPS_dpsu_h_qbr = _idaapi.MIPS_dpsu_h_qbr
MIPS_maq_sa_w_qhll = _idaapi.MIPS_maq_sa_w_qhll
MIPS_maq_sa_w_qhlr = _idaapi.MIPS_maq_sa_w_qhlr
MIPS_dmadd = _idaapi.MIPS_dmadd
MIPS_dmsub = _idaapi.MIPS_dmsub
MIPS_maq_sa_w_qhrl = _idaapi.MIPS_maq_sa_w_qhrl
MIPS_dpau_h_obl = _idaapi.MIPS_dpau_h_obl
MIPS_dpsu_h_obl = _idaapi.MIPS_dpsu_h_obl
MIPS_maq_sa_w_qhrr = _idaapi.MIPS_maq_sa_w_qhrr
MIPS_dpaq_s_w_qh = _idaapi.MIPS_dpaq_s_w_qh
MIPS_dpaq_sa_l_pw = _idaapi.MIPS_dpaq_sa_l_pw
MIPS_maq_s_w_qhll = _idaapi.MIPS_maq_s_w_qhll
MIPS_maq_s_l_pwl = _idaapi.MIPS_maq_s_l_pwl
MIPS_dpsq_s_w_qh = _idaapi.MIPS_dpsq_s_w_qh
MIPS_dpsq_sa_l_pw = _idaapi.MIPS_dpsq_sa_l_pw
MIPS_maq_s_w_qhlr = _idaapi.MIPS_maq_s_w_qhlr
MIPS_dmaddu = _idaapi.MIPS_dmaddu
MIPS_mulsaq_s_w_qh = _idaapi.MIPS_mulsaq_s_w_qh
MIPS_mulsaq_s_l_pw = _idaapi.MIPS_mulsaq_s_l_pw
MIPS_maq_s_w_qhrl = _idaapi.MIPS_maq_s_w_qhrl
MIPS_maq_s_l_pwr = _idaapi.MIPS_maq_s_l_pwr
MIPS_dpau_h_obr = _idaapi.MIPS_dpau_h_obr
MIPS_dpsu_h_obr = _idaapi.MIPS_dpsu_h_obr
MIPS_maq_s_w_qhrr = _idaapi.MIPS_maq_s_w_qhrr
MIPS_dmsubu = _idaapi.MIPS_dmsubu
MIPS_extr_w = _idaapi.MIPS_extr_w
MIPS_extrv_w = _idaapi.MIPS_extrv_w
MIPS_extp = _idaapi.MIPS_extp
MIPS_extpdp = _idaapi.MIPS_extpdp
MIPS_rddsp = _idaapi.MIPS_rddsp
MIPS_shilo = _idaapi.MIPS_shilo
MIPS_extpv = _idaapi.MIPS_extpv
MIPS_extpdpv = _idaapi.MIPS_extpdpv
MIPS_wrdsp = _idaapi.MIPS_wrdsp
MIPS_shilov = _idaapi.MIPS_shilov
MIPS_extr_r_w = _idaapi.MIPS_extr_r_w
MIPS_extrv_r_w = _idaapi.MIPS_extrv_r_w
MIPS_extr_rs_w = _idaapi.MIPS_extr_rs_w
MIPS_extr_s_h = _idaapi.MIPS_extr_s_h
MIPS_extrv_rs_w = _idaapi.MIPS_extrv_rs_w
MIPS_extrv_s_h = _idaapi.MIPS_extrv_s_h
MIPS_mthlip = _idaapi.MIPS_mthlip
MIPS_dextr_w = _idaapi.MIPS_dextr_w
MIPS_dextr_l = _idaapi.MIPS_dextr_l
MIPS_dextrv_w = _idaapi.MIPS_dextrv_w
MIPS_dextrv_l = _idaapi.MIPS_dextrv_l
MIPS_dextp = _idaapi.MIPS_dextp
MIPS_dextpdp = _idaapi.MIPS_dextpdp
MIPS_dshilo = _idaapi.MIPS_dshilo
MIPS_dextpv = _idaapi.MIPS_dextpv
MIPS_dextpdpv = _idaapi.MIPS_dextpdpv
MIPS_dshilov = _idaapi.MIPS_dshilov
MIPS_dextr_r_w = _idaapi.MIPS_dextr_r_w
MIPS_dextr_r_l = _idaapi.MIPS_dextr_r_l
MIPS_dextrv_r_w = _idaapi.MIPS_dextrv_r_w
MIPS_dextrv_r_l = _idaapi.MIPS_dextrv_r_l
MIPS_dextr_rs_w = _idaapi.MIPS_dextr_rs_w
MIPS_dextr_s_h = _idaapi.MIPS_dextr_s_h
MIPS_dextr_rs_l = _idaapi.MIPS_dextr_rs_l
MIPS_dextrv_rs_w = _idaapi.MIPS_dextrv_rs_w
MIPS_dextrv_s_h = _idaapi.MIPS_dextrv_s_h
MIPS_dextrv_rs_l = _idaapi.MIPS_dextrv_rs_l
MIPS_dmthlip = _idaapi.MIPS_dmthlip
MIPS_adduh_qb = _idaapi.MIPS_adduh_qb
MIPS_addqh_ph = _idaapi.MIPS_addqh_ph
MIPS_addqh_w = _idaapi.MIPS_addqh_w
MIPS_subuh_qb = _idaapi.MIPS_subuh_qb
MIPS_subqh_ph = _idaapi.MIPS_subqh_ph
MIPS_subqh_w = _idaapi.MIPS_subqh_w
MIPS_adduh_r_qb = _idaapi.MIPS_adduh_r_qb
MIPS_addqh_r_ph = _idaapi.MIPS_addqh_r_ph
MIPS_addqh_r_w = _idaapi.MIPS_addqh_r_w
MIPS_subuh_r_qb = _idaapi.MIPS_subuh_r_qb
MIPS_subqh_r_ph = _idaapi.MIPS_subqh_r_ph
MIPS_subqh_r_w = _idaapi.MIPS_subqh_r_w
MIPS_mul_ph = _idaapi.MIPS_mul_ph
MIPS_mul_s_ph = _idaapi.MIPS_mul_s_ph
MIPS_mulq_s_w = _idaapi.MIPS_mulq_s_w
MIPS_mulq_rs_w = _idaapi.MIPS_mulq_rs_w
MIPS_append = _idaapi.MIPS_append
MIPS_balign = _idaapi.MIPS_balign
MIPS_prepend = _idaapi.MIPS_prepend
MIPS_laa = _idaapi.MIPS_laa
MIPS_laad = _idaapi.MIPS_laad
MIPS_lac = _idaapi.MIPS_lac
MIPS_lacd = _idaapi.MIPS_lacd
MIPS_lad = _idaapi.MIPS_lad
MIPS_ladd = _idaapi.MIPS_ladd
MIPS_lai = _idaapi.MIPS_lai
MIPS_laid = _idaapi.MIPS_laid
MIPS_las = _idaapi.MIPS_las
MIPS_lasd = _idaapi.MIPS_lasd
MIPS_law = _idaapi.MIPS_law
MIPS_lawd = _idaapi.MIPS_lawd
MIPS_lbx = _idaapi.MIPS_lbx
MIPS_lhux = _idaapi.MIPS_lhux
MIPS_lwux = _idaapi.MIPS_lwux
MIPS_qmac_00 = _idaapi.MIPS_qmac_00
MIPS_qmac_01 = _idaapi.MIPS_qmac_01
MIPS_qmac_02 = _idaapi.MIPS_qmac_02
MIPS_qmac_03 = _idaapi.MIPS_qmac_03
MIPS_qmacs_00 = _idaapi.MIPS_qmacs_00
MIPS_qmacs_01 = _idaapi.MIPS_qmacs_01
MIPS_qmacs_02 = _idaapi.MIPS_qmacs_02
MIPS_qmacs_03 = _idaapi.MIPS_qmacs_03
MIPS_zcb = _idaapi.MIPS_zcb
MIPS_zcbt = _idaapi.MIPS_zcbt
MIPS_msa_sll_b = _idaapi.MIPS_msa_sll_b
MIPS_msa_sll_h = _idaapi.MIPS_msa_sll_h
MIPS_msa_sll_w = _idaapi.MIPS_msa_sll_w
MIPS_msa_sll_d = _idaapi.MIPS_msa_sll_d
MIPS_msa_slli_b = _idaapi.MIPS_msa_slli_b
MIPS_msa_slli_h = _idaapi.MIPS_msa_slli_h
MIPS_msa_slli_w = _idaapi.MIPS_msa_slli_w
MIPS_msa_slli_d = _idaapi.MIPS_msa_slli_d
MIPS_msa_sra_b = _idaapi.MIPS_msa_sra_b
MIPS_msa_sra_h = _idaapi.MIPS_msa_sra_h
MIPS_msa_sra_w = _idaapi.MIPS_msa_sra_w
MIPS_msa_sra_d = _idaapi.MIPS_msa_sra_d
MIPS_msa_srai_b = _idaapi.MIPS_msa_srai_b
MIPS_msa_srai_h = _idaapi.MIPS_msa_srai_h
MIPS_msa_srai_w = _idaapi.MIPS_msa_srai_w
MIPS_msa_srai_d = _idaapi.MIPS_msa_srai_d
MIPS_msa_srl_b = _idaapi.MIPS_msa_srl_b
MIPS_msa_srl_h = _idaapi.MIPS_msa_srl_h
MIPS_msa_srl_w = _idaapi.MIPS_msa_srl_w
MIPS_msa_srl_d = _idaapi.MIPS_msa_srl_d
MIPS_msa_srli_b = _idaapi.MIPS_msa_srli_b
MIPS_msa_srli_h = _idaapi.MIPS_msa_srli_h
MIPS_msa_srli_w = _idaapi.MIPS_msa_srli_w
MIPS_msa_srli_d = _idaapi.MIPS_msa_srli_d
MIPS_msa_bclr_b = _idaapi.MIPS_msa_bclr_b
MIPS_msa_bclr_h = _idaapi.MIPS_msa_bclr_h
MIPS_msa_bclr_w = _idaapi.MIPS_msa_bclr_w
MIPS_msa_bclr_d = _idaapi.MIPS_msa_bclr_d
MIPS_msa_bclri_b = _idaapi.MIPS_msa_bclri_b
MIPS_msa_bclri_h = _idaapi.MIPS_msa_bclri_h
MIPS_msa_bclri_w = _idaapi.MIPS_msa_bclri_w
MIPS_msa_bclri_d = _idaapi.MIPS_msa_bclri_d
MIPS_msa_bset_b = _idaapi.MIPS_msa_bset_b
MIPS_msa_bset_h = _idaapi.MIPS_msa_bset_h
MIPS_msa_bset_w = _idaapi.MIPS_msa_bset_w
MIPS_msa_bset_d = _idaapi.MIPS_msa_bset_d
MIPS_msa_bseti_b = _idaapi.MIPS_msa_bseti_b
MIPS_msa_bseti_h = _idaapi.MIPS_msa_bseti_h
MIPS_msa_bseti_w = _idaapi.MIPS_msa_bseti_w
MIPS_msa_bseti_d = _idaapi.MIPS_msa_bseti_d
MIPS_msa_bneg_b = _idaapi.MIPS_msa_bneg_b
MIPS_msa_bneg_h = _idaapi.MIPS_msa_bneg_h
MIPS_msa_bneg_w = _idaapi.MIPS_msa_bneg_w
MIPS_msa_bneg_d = _idaapi.MIPS_msa_bneg_d
MIPS_msa_bnegi_b = _idaapi.MIPS_msa_bnegi_b
MIPS_msa_bnegi_h = _idaapi.MIPS_msa_bnegi_h
MIPS_msa_bnegi_w = _idaapi.MIPS_msa_bnegi_w
MIPS_msa_bnegi_d = _idaapi.MIPS_msa_bnegi_d
MIPS_msa_binsl_b = _idaapi.MIPS_msa_binsl_b
MIPS_msa_binsl_h = _idaapi.MIPS_msa_binsl_h
MIPS_msa_binsl_w = _idaapi.MIPS_msa_binsl_w
MIPS_msa_binsl_d = _idaapi.MIPS_msa_binsl_d
MIPS_msa_binsli_b = _idaapi.MIPS_msa_binsli_b
MIPS_msa_binsli_h = _idaapi.MIPS_msa_binsli_h
MIPS_msa_binsli_w = _idaapi.MIPS_msa_binsli_w
MIPS_msa_binsli_d = _idaapi.MIPS_msa_binsli_d
MIPS_msa_binsr_b = _idaapi.MIPS_msa_binsr_b
MIPS_msa_binsr_h = _idaapi.MIPS_msa_binsr_h
MIPS_msa_binsr_w = _idaapi.MIPS_msa_binsr_w
MIPS_msa_binsr_d = _idaapi.MIPS_msa_binsr_d
MIPS_msa_binsri_b = _idaapi.MIPS_msa_binsri_b
MIPS_msa_binsri_h = _idaapi.MIPS_msa_binsri_h
MIPS_msa_binsri_w = _idaapi.MIPS_msa_binsri_w
MIPS_msa_binsri_d = _idaapi.MIPS_msa_binsri_d
MIPS_msa_addv_b = _idaapi.MIPS_msa_addv_b
MIPS_msa_addv_h = _idaapi.MIPS_msa_addv_h
MIPS_msa_addv_w = _idaapi.MIPS_msa_addv_w
MIPS_msa_addv_d = _idaapi.MIPS_msa_addv_d
MIPS_msa_addvi_b = _idaapi.MIPS_msa_addvi_b
MIPS_msa_addvi_h = _idaapi.MIPS_msa_addvi_h
MIPS_msa_addvi_w = _idaapi.MIPS_msa_addvi_w
MIPS_msa_addvi_d = _idaapi.MIPS_msa_addvi_d
MIPS_msa_subv_b = _idaapi.MIPS_msa_subv_b
MIPS_msa_subv_h = _idaapi.MIPS_msa_subv_h
MIPS_msa_subv_w = _idaapi.MIPS_msa_subv_w
MIPS_msa_subv_d = _idaapi.MIPS_msa_subv_d
MIPS_msa_subvi_b = _idaapi.MIPS_msa_subvi_b
MIPS_msa_subvi_h = _idaapi.MIPS_msa_subvi_h
MIPS_msa_subvi_w = _idaapi.MIPS_msa_subvi_w
MIPS_msa_subvi_d = _idaapi.MIPS_msa_subvi_d
MIPS_msa_max_s_b = _idaapi.MIPS_msa_max_s_b
MIPS_msa_max_s_h = _idaapi.MIPS_msa_max_s_h
MIPS_msa_max_s_w = _idaapi.MIPS_msa_max_s_w
MIPS_msa_max_s_d = _idaapi.MIPS_msa_max_s_d
MIPS_msa_maxi_s_b = _idaapi.MIPS_msa_maxi_s_b
MIPS_msa_maxi_s_h = _idaapi.MIPS_msa_maxi_s_h
MIPS_msa_maxi_s_w = _idaapi.MIPS_msa_maxi_s_w
MIPS_msa_maxi_s_d = _idaapi.MIPS_msa_maxi_s_d
MIPS_msa_max_u_b = _idaapi.MIPS_msa_max_u_b
MIPS_msa_max_u_h = _idaapi.MIPS_msa_max_u_h
MIPS_msa_max_u_w = _idaapi.MIPS_msa_max_u_w
MIPS_msa_max_u_d = _idaapi.MIPS_msa_max_u_d
MIPS_msa_maxi_u_b = _idaapi.MIPS_msa_maxi_u_b
MIPS_msa_maxi_u_h = _idaapi.MIPS_msa_maxi_u_h
MIPS_msa_maxi_u_w = _idaapi.MIPS_msa_maxi_u_w
MIPS_msa_maxi_u_d = _idaapi.MIPS_msa_maxi_u_d
MIPS_msa_min_s_b = _idaapi.MIPS_msa_min_s_b
MIPS_msa_min_s_h = _idaapi.MIPS_msa_min_s_h
MIPS_msa_min_s_w = _idaapi.MIPS_msa_min_s_w
MIPS_msa_min_s_d = _idaapi.MIPS_msa_min_s_d
MIPS_msa_mini_s_b = _idaapi.MIPS_msa_mini_s_b
MIPS_msa_mini_s_h = _idaapi.MIPS_msa_mini_s_h
MIPS_msa_mini_s_w = _idaapi.MIPS_msa_mini_s_w
MIPS_msa_mini_s_d = _idaapi.MIPS_msa_mini_s_d
MIPS_msa_min_u_b = _idaapi.MIPS_msa_min_u_b
MIPS_msa_min_u_h = _idaapi.MIPS_msa_min_u_h
MIPS_msa_min_u_w = _idaapi.MIPS_msa_min_u_w
MIPS_msa_min_u_d = _idaapi.MIPS_msa_min_u_d
MIPS_msa_mini_u_b = _idaapi.MIPS_msa_mini_u_b
MIPS_msa_mini_u_h = _idaapi.MIPS_msa_mini_u_h
MIPS_msa_mini_u_w = _idaapi.MIPS_msa_mini_u_w
MIPS_msa_mini_u_d = _idaapi.MIPS_msa_mini_u_d
MIPS_msa_max_a_b = _idaapi.MIPS_msa_max_a_b
MIPS_msa_max_a_h = _idaapi.MIPS_msa_max_a_h
MIPS_msa_max_a_w = _idaapi.MIPS_msa_max_a_w
MIPS_msa_max_a_d = _idaapi.MIPS_msa_max_a_d
MIPS_msa_min_a_b = _idaapi.MIPS_msa_min_a_b
MIPS_msa_min_a_h = _idaapi.MIPS_msa_min_a_h
MIPS_msa_min_a_w = _idaapi.MIPS_msa_min_a_w
MIPS_msa_min_a_d = _idaapi.MIPS_msa_min_a_d
MIPS_msa_ceq_b = _idaapi.MIPS_msa_ceq_b
MIPS_msa_ceq_h = _idaapi.MIPS_msa_ceq_h
MIPS_msa_ceq_w = _idaapi.MIPS_msa_ceq_w
MIPS_msa_ceq_d = _idaapi.MIPS_msa_ceq_d
MIPS_msa_ceqi_b = _idaapi.MIPS_msa_ceqi_b
MIPS_msa_ceqi_h = _idaapi.MIPS_msa_ceqi_h
MIPS_msa_ceqi_w = _idaapi.MIPS_msa_ceqi_w
MIPS_msa_ceqi_d = _idaapi.MIPS_msa_ceqi_d
MIPS_msa_clt_s_b = _idaapi.MIPS_msa_clt_s_b
MIPS_msa_clt_s_h = _idaapi.MIPS_msa_clt_s_h
MIPS_msa_clt_s_w = _idaapi.MIPS_msa_clt_s_w
MIPS_msa_clt_s_d = _idaapi.MIPS_msa_clt_s_d
MIPS_msa_clti_s_b = _idaapi.MIPS_msa_clti_s_b
MIPS_msa_clti_s_h = _idaapi.MIPS_msa_clti_s_h
MIPS_msa_clti_s_w = _idaapi.MIPS_msa_clti_s_w
MIPS_msa_clti_s_d = _idaapi.MIPS_msa_clti_s_d
MIPS_msa_clt_u_b = _idaapi.MIPS_msa_clt_u_b
MIPS_msa_clt_u_h = _idaapi.MIPS_msa_clt_u_h
MIPS_msa_clt_u_w = _idaapi.MIPS_msa_clt_u_w
MIPS_msa_clt_u_d = _idaapi.MIPS_msa_clt_u_d
MIPS_msa_clti_u_b = _idaapi.MIPS_msa_clti_u_b
MIPS_msa_clti_u_h = _idaapi.MIPS_msa_clti_u_h
MIPS_msa_clti_u_w = _idaapi.MIPS_msa_clti_u_w
MIPS_msa_clti_u_d = _idaapi.MIPS_msa_clti_u_d
MIPS_msa_cle_s_b = _idaapi.MIPS_msa_cle_s_b
MIPS_msa_cle_s_h = _idaapi.MIPS_msa_cle_s_h
MIPS_msa_cle_s_w = _idaapi.MIPS_msa_cle_s_w
MIPS_msa_cle_s_d = _idaapi.MIPS_msa_cle_s_d
MIPS_msa_clei_s_b = _idaapi.MIPS_msa_clei_s_b
MIPS_msa_clei_s_h = _idaapi.MIPS_msa_clei_s_h
MIPS_msa_clei_s_w = _idaapi.MIPS_msa_clei_s_w
MIPS_msa_clei_s_d = _idaapi.MIPS_msa_clei_s_d
MIPS_msa_cle_u_b = _idaapi.MIPS_msa_cle_u_b
MIPS_msa_cle_u_h = _idaapi.MIPS_msa_cle_u_h
MIPS_msa_cle_u_w = _idaapi.MIPS_msa_cle_u_w
MIPS_msa_cle_u_d = _idaapi.MIPS_msa_cle_u_d
MIPS_msa_clei_u_b = _idaapi.MIPS_msa_clei_u_b
MIPS_msa_clei_u_h = _idaapi.MIPS_msa_clei_u_h
MIPS_msa_clei_u_w = _idaapi.MIPS_msa_clei_u_w
MIPS_msa_clei_u_d = _idaapi.MIPS_msa_clei_u_d
MIPS_msa_ld_b = _idaapi.MIPS_msa_ld_b
MIPS_msa_ld_h = _idaapi.MIPS_msa_ld_h
MIPS_msa_ld_w = _idaapi.MIPS_msa_ld_w
MIPS_msa_ld_d = _idaapi.MIPS_msa_ld_d
MIPS_msa_st_b = _idaapi.MIPS_msa_st_b
MIPS_msa_st_h = _idaapi.MIPS_msa_st_h
MIPS_msa_st_w = _idaapi.MIPS_msa_st_w
MIPS_msa_st_d = _idaapi.MIPS_msa_st_d
MIPS_msa_sat_s_b = _idaapi.MIPS_msa_sat_s_b
MIPS_msa_sat_s_h = _idaapi.MIPS_msa_sat_s_h
MIPS_msa_sat_s_w = _idaapi.MIPS_msa_sat_s_w
MIPS_msa_sat_s_d = _idaapi.MIPS_msa_sat_s_d
MIPS_msa_sat_u_b = _idaapi.MIPS_msa_sat_u_b
MIPS_msa_sat_u_h = _idaapi.MIPS_msa_sat_u_h
MIPS_msa_sat_u_w = _idaapi.MIPS_msa_sat_u_w
MIPS_msa_sat_u_d = _idaapi.MIPS_msa_sat_u_d
MIPS_msa_add_a_b = _idaapi.MIPS_msa_add_a_b
MIPS_msa_add_a_h = _idaapi.MIPS_msa_add_a_h
MIPS_msa_add_a_w = _idaapi.MIPS_msa_add_a_w
MIPS_msa_add_a_d = _idaapi.MIPS_msa_add_a_d
MIPS_msa_adds_a_b = _idaapi.MIPS_msa_adds_a_b
MIPS_msa_adds_a_h = _idaapi.MIPS_msa_adds_a_h
MIPS_msa_adds_a_w = _idaapi.MIPS_msa_adds_a_w
MIPS_msa_adds_a_d = _idaapi.MIPS_msa_adds_a_d
MIPS_msa_adds_s_b = _idaapi.MIPS_msa_adds_s_b
MIPS_msa_adds_s_h = _idaapi.MIPS_msa_adds_s_h
MIPS_msa_adds_s_w = _idaapi.MIPS_msa_adds_s_w
MIPS_msa_adds_s_d = _idaapi.MIPS_msa_adds_s_d
MIPS_msa_adds_u_b = _idaapi.MIPS_msa_adds_u_b
MIPS_msa_adds_u_h = _idaapi.MIPS_msa_adds_u_h
MIPS_msa_adds_u_w = _idaapi.MIPS_msa_adds_u_w
MIPS_msa_adds_u_d = _idaapi.MIPS_msa_adds_u_d
MIPS_msa_ave_s_b = _idaapi.MIPS_msa_ave_s_b
MIPS_msa_ave_s_h = _idaapi.MIPS_msa_ave_s_h
MIPS_msa_ave_s_w = _idaapi.MIPS_msa_ave_s_w
MIPS_msa_ave_s_d = _idaapi.MIPS_msa_ave_s_d
MIPS_msa_ave_u_b = _idaapi.MIPS_msa_ave_u_b
MIPS_msa_ave_u_h = _idaapi.MIPS_msa_ave_u_h
MIPS_msa_ave_u_w = _idaapi.MIPS_msa_ave_u_w
MIPS_msa_ave_u_d = _idaapi.MIPS_msa_ave_u_d
MIPS_msa_aver_s_b = _idaapi.MIPS_msa_aver_s_b
MIPS_msa_aver_s_h = _idaapi.MIPS_msa_aver_s_h
MIPS_msa_aver_s_w = _idaapi.MIPS_msa_aver_s_w
MIPS_msa_aver_s_d = _idaapi.MIPS_msa_aver_s_d
MIPS_msa_aver_u_b = _idaapi.MIPS_msa_aver_u_b
MIPS_msa_aver_u_h = _idaapi.MIPS_msa_aver_u_h
MIPS_msa_aver_u_w = _idaapi.MIPS_msa_aver_u_w
MIPS_msa_aver_u_d = _idaapi.MIPS_msa_aver_u_d
MIPS_msa_subs_s_b = _idaapi.MIPS_msa_subs_s_b
MIPS_msa_subs_s_h = _idaapi.MIPS_msa_subs_s_h
MIPS_msa_subs_s_w = _idaapi.MIPS_msa_subs_s_w
MIPS_msa_subs_s_d = _idaapi.MIPS_msa_subs_s_d
MIPS_msa_subs_u_b = _idaapi.MIPS_msa_subs_u_b
MIPS_msa_subs_u_h = _idaapi.MIPS_msa_subs_u_h
MIPS_msa_subs_u_w = _idaapi.MIPS_msa_subs_u_w
MIPS_msa_subs_u_d = _idaapi.MIPS_msa_subs_u_d
MIPS_msa_subsus_u_b = _idaapi.MIPS_msa_subsus_u_b
MIPS_msa_subsus_u_h = _idaapi.MIPS_msa_subsus_u_h
MIPS_msa_subsus_u_w = _idaapi.MIPS_msa_subsus_u_w
MIPS_msa_subsus_u_d = _idaapi.MIPS_msa_subsus_u_d
MIPS_msa_subsuu_s_b = _idaapi.MIPS_msa_subsuu_s_b
MIPS_msa_subsuu_s_h = _idaapi.MIPS_msa_subsuu_s_h
MIPS_msa_subsuu_s_w = _idaapi.MIPS_msa_subsuu_s_w
MIPS_msa_subsuu_s_d = _idaapi.MIPS_msa_subsuu_s_d
MIPS_msa_asub_s_b = _idaapi.MIPS_msa_asub_s_b
MIPS_msa_asub_s_h = _idaapi.MIPS_msa_asub_s_h
MIPS_msa_asub_s_w = _idaapi.MIPS_msa_asub_s_w
MIPS_msa_asub_s_d = _idaapi.MIPS_msa_asub_s_d
MIPS_msa_asub_u_b = _idaapi.MIPS_msa_asub_u_b
MIPS_msa_asub_u_h = _idaapi.MIPS_msa_asub_u_h
MIPS_msa_asub_u_w = _idaapi.MIPS_msa_asub_u_w
MIPS_msa_asub_u_d = _idaapi.MIPS_msa_asub_u_d
MIPS_msa_mulv_b = _idaapi.MIPS_msa_mulv_b
MIPS_msa_mulv_h = _idaapi.MIPS_msa_mulv_h
MIPS_msa_mulv_w = _idaapi.MIPS_msa_mulv_w
MIPS_msa_mulv_d = _idaapi.MIPS_msa_mulv_d
MIPS_msa_maddv_b = _idaapi.MIPS_msa_maddv_b
MIPS_msa_maddv_h = _idaapi.MIPS_msa_maddv_h
MIPS_msa_maddv_w = _idaapi.MIPS_msa_maddv_w
MIPS_msa_maddv_d = _idaapi.MIPS_msa_maddv_d
MIPS_msa_msubv_b = _idaapi.MIPS_msa_msubv_b
MIPS_msa_msubv_h = _idaapi.MIPS_msa_msubv_h
MIPS_msa_msubv_w = _idaapi.MIPS_msa_msubv_w
MIPS_msa_msubv_d = _idaapi.MIPS_msa_msubv_d
MIPS_msa_div_s_b = _idaapi.MIPS_msa_div_s_b
MIPS_msa_div_s_h = _idaapi.MIPS_msa_div_s_h
MIPS_msa_div_s_w = _idaapi.MIPS_msa_div_s_w
MIPS_msa_div_s_d = _idaapi.MIPS_msa_div_s_d
MIPS_msa_div_u_b = _idaapi.MIPS_msa_div_u_b
MIPS_msa_div_u_h = _idaapi.MIPS_msa_div_u_h
MIPS_msa_div_u_w = _idaapi.MIPS_msa_div_u_w
MIPS_msa_div_u_d = _idaapi.MIPS_msa_div_u_d
MIPS_msa_mod_s_b = _idaapi.MIPS_msa_mod_s_b
MIPS_msa_mod_s_h = _idaapi.MIPS_msa_mod_s_h
MIPS_msa_mod_s_w = _idaapi.MIPS_msa_mod_s_w
MIPS_msa_mod_s_d = _idaapi.MIPS_msa_mod_s_d
MIPS_msa_mod_u_b = _idaapi.MIPS_msa_mod_u_b
MIPS_msa_mod_u_h = _idaapi.MIPS_msa_mod_u_h
MIPS_msa_mod_u_w = _idaapi.MIPS_msa_mod_u_w
MIPS_msa_mod_u_d = _idaapi.MIPS_msa_mod_u_d
MIPS_msa_dotp_s_h = _idaapi.MIPS_msa_dotp_s_h
MIPS_msa_dotp_s_w = _idaapi.MIPS_msa_dotp_s_w
MIPS_msa_dotp_s_d = _idaapi.MIPS_msa_dotp_s_d
MIPS_msa_dotp_u_h = _idaapi.MIPS_msa_dotp_u_h
MIPS_msa_dotp_u_w = _idaapi.MIPS_msa_dotp_u_w
MIPS_msa_dotp_u_d = _idaapi.MIPS_msa_dotp_u_d
MIPS_msa_dpadd_s_h = _idaapi.MIPS_msa_dpadd_s_h
MIPS_msa_dpadd_s_w = _idaapi.MIPS_msa_dpadd_s_w
MIPS_msa_dpadd_s_d = _idaapi.MIPS_msa_dpadd_s_d
MIPS_msa_dpadd_u_h = _idaapi.MIPS_msa_dpadd_u_h
MIPS_msa_dpadd_u_w = _idaapi.MIPS_msa_dpadd_u_w
MIPS_msa_dpadd_u_d = _idaapi.MIPS_msa_dpadd_u_d
MIPS_msa_dpsub_s_h = _idaapi.MIPS_msa_dpsub_s_h
MIPS_msa_dpsub_s_w = _idaapi.MIPS_msa_dpsub_s_w
MIPS_msa_dpsub_s_d = _idaapi.MIPS_msa_dpsub_s_d
MIPS_msa_dpsub_u_h = _idaapi.MIPS_msa_dpsub_u_h
MIPS_msa_dpsub_u_w = _idaapi.MIPS_msa_dpsub_u_w
MIPS_msa_dpsub_u_d = _idaapi.MIPS_msa_dpsub_u_d
MIPS_msa_sld_b = _idaapi.MIPS_msa_sld_b
MIPS_msa_sld_h = _idaapi.MIPS_msa_sld_h
MIPS_msa_sld_w = _idaapi.MIPS_msa_sld_w
MIPS_msa_sld_d = _idaapi.MIPS_msa_sld_d
MIPS_msa_sldi_b = _idaapi.MIPS_msa_sldi_b
MIPS_msa_sldi_h = _idaapi.MIPS_msa_sldi_h
MIPS_msa_sldi_w = _idaapi.MIPS_msa_sldi_w
MIPS_msa_sldi_d = _idaapi.MIPS_msa_sldi_d
MIPS_msa_splat_b = _idaapi.MIPS_msa_splat_b
MIPS_msa_splat_h = _idaapi.MIPS_msa_splat_h
MIPS_msa_splat_w = _idaapi.MIPS_msa_splat_w
MIPS_msa_splat_d = _idaapi.MIPS_msa_splat_d
MIPS_msa_splati_b = _idaapi.MIPS_msa_splati_b
MIPS_msa_splati_h = _idaapi.MIPS_msa_splati_h
MIPS_msa_splati_w = _idaapi.MIPS_msa_splati_w
MIPS_msa_splati_d = _idaapi.MIPS_msa_splati_d
MIPS_msa_pckev_b = _idaapi.MIPS_msa_pckev_b
MIPS_msa_pckev_h = _idaapi.MIPS_msa_pckev_h
MIPS_msa_pckev_w = _idaapi.MIPS_msa_pckev_w
MIPS_msa_pckev_d = _idaapi.MIPS_msa_pckev_d
MIPS_msa_pckod_b = _idaapi.MIPS_msa_pckod_b
MIPS_msa_pckod_h = _idaapi.MIPS_msa_pckod_h
MIPS_msa_pckod_w = _idaapi.MIPS_msa_pckod_w
MIPS_msa_pckod_d = _idaapi.MIPS_msa_pckod_d
MIPS_msa_ilvl_b = _idaapi.MIPS_msa_ilvl_b
MIPS_msa_ilvl_h = _idaapi.MIPS_msa_ilvl_h
MIPS_msa_ilvl_w = _idaapi.MIPS_msa_ilvl_w
MIPS_msa_ilvl_d = _idaapi.MIPS_msa_ilvl_d
MIPS_msa_ilvr_b = _idaapi.MIPS_msa_ilvr_b
MIPS_msa_ilvr_h = _idaapi.MIPS_msa_ilvr_h
MIPS_msa_ilvr_w = _idaapi.MIPS_msa_ilvr_w
MIPS_msa_ilvr_d = _idaapi.MIPS_msa_ilvr_d
MIPS_msa_ilvev_b = _idaapi.MIPS_msa_ilvev_b
MIPS_msa_ilvev_h = _idaapi.MIPS_msa_ilvev_h
MIPS_msa_ilvev_w = _idaapi.MIPS_msa_ilvev_w
MIPS_msa_ilvev_d = _idaapi.MIPS_msa_ilvev_d
MIPS_msa_ilvod_b = _idaapi.MIPS_msa_ilvod_b
MIPS_msa_ilvod_h = _idaapi.MIPS_msa_ilvod_h
MIPS_msa_ilvod_w = _idaapi.MIPS_msa_ilvod_w
MIPS_msa_ilvod_d = _idaapi.MIPS_msa_ilvod_d
MIPS_msa_vshf_b = _idaapi.MIPS_msa_vshf_b
MIPS_msa_vshf_h = _idaapi.MIPS_msa_vshf_h
MIPS_msa_vshf_w = _idaapi.MIPS_msa_vshf_w
MIPS_msa_vshf_d = _idaapi.MIPS_msa_vshf_d
MIPS_msa_srar_b = _idaapi.MIPS_msa_srar_b
MIPS_msa_srar_h = _idaapi.MIPS_msa_srar_h
MIPS_msa_srar_w = _idaapi.MIPS_msa_srar_w
MIPS_msa_srar_d = _idaapi.MIPS_msa_srar_d
MIPS_msa_srari_b = _idaapi.MIPS_msa_srari_b
MIPS_msa_srari_h = _idaapi.MIPS_msa_srari_h
MIPS_msa_srari_w = _idaapi.MIPS_msa_srari_w
MIPS_msa_srari_d = _idaapi.MIPS_msa_srari_d
MIPS_msa_srlr_b = _idaapi.MIPS_msa_srlr_b
MIPS_msa_srlr_h = _idaapi.MIPS_msa_srlr_h
MIPS_msa_srlr_w = _idaapi.MIPS_msa_srlr_w
MIPS_msa_srlr_d = _idaapi.MIPS_msa_srlr_d
MIPS_msa_srlri_b = _idaapi.MIPS_msa_srlri_b
MIPS_msa_srlri_h = _idaapi.MIPS_msa_srlri_h
MIPS_msa_srlri_w = _idaapi.MIPS_msa_srlri_w
MIPS_msa_srlri_d = _idaapi.MIPS_msa_srlri_d
MIPS_msa_hadd_s_h = _idaapi.MIPS_msa_hadd_s_h
MIPS_msa_hadd_s_w = _idaapi.MIPS_msa_hadd_s_w
MIPS_msa_hadd_s_d = _idaapi.MIPS_msa_hadd_s_d
MIPS_msa_hadd_u_h = _idaapi.MIPS_msa_hadd_u_h
MIPS_msa_hadd_u_w = _idaapi.MIPS_msa_hadd_u_w
MIPS_msa_hadd_u_d = _idaapi.MIPS_msa_hadd_u_d
MIPS_msa_hsub_s_h = _idaapi.MIPS_msa_hsub_s_h
MIPS_msa_hsub_s_w = _idaapi.MIPS_msa_hsub_s_w
MIPS_msa_hsub_s_d = _idaapi.MIPS_msa_hsub_s_d
MIPS_msa_hsub_u_h = _idaapi.MIPS_msa_hsub_u_h
MIPS_msa_hsub_u_w = _idaapi.MIPS_msa_hsub_u_w
MIPS_msa_hsub_u_d = _idaapi.MIPS_msa_hsub_u_d
MIPS_msa_and_v = _idaapi.MIPS_msa_and_v
MIPS_msa_andi_b = _idaapi.MIPS_msa_andi_b
MIPS_msa_or_v = _idaapi.MIPS_msa_or_v
MIPS_msa_ori_b = _idaapi.MIPS_msa_ori_b
MIPS_msa_nor_v = _idaapi.MIPS_msa_nor_v
MIPS_msa_nori_b = _idaapi.MIPS_msa_nori_b
MIPS_msa_xor_v = _idaapi.MIPS_msa_xor_v
MIPS_msa_xori_b = _idaapi.MIPS_msa_xori_b
MIPS_msa_bmnz_v = _idaapi.MIPS_msa_bmnz_v
MIPS_msa_bmnzi_b = _idaapi.MIPS_msa_bmnzi_b
MIPS_msa_bmz_v = _idaapi.MIPS_msa_bmz_v
MIPS_msa_bmzi_b = _idaapi.MIPS_msa_bmzi_b
MIPS_msa_bsel_v = _idaapi.MIPS_msa_bsel_v
MIPS_msa_bseli_b = _idaapi.MIPS_msa_bseli_b
MIPS_msa_shf_b = _idaapi.MIPS_msa_shf_b
MIPS_msa_shf_h = _idaapi.MIPS_msa_shf_h
MIPS_msa_shf_w = _idaapi.MIPS_msa_shf_w
MIPS_msa_bnz_v = _idaapi.MIPS_msa_bnz_v
MIPS_msa_bz_v = _idaapi.MIPS_msa_bz_v
MIPS_msa_fill_b = _idaapi.MIPS_msa_fill_b
MIPS_msa_fill_h = _idaapi.MIPS_msa_fill_h
MIPS_msa_fill_w = _idaapi.MIPS_msa_fill_w
MIPS_msa_fill_d = _idaapi.MIPS_msa_fill_d
MIPS_msa_pcnt_b = _idaapi.MIPS_msa_pcnt_b
MIPS_msa_pcnt_h = _idaapi.MIPS_msa_pcnt_h
MIPS_msa_pcnt_w = _idaapi.MIPS_msa_pcnt_w
MIPS_msa_pcnt_d = _idaapi.MIPS_msa_pcnt_d
MIPS_msa_nloc_b = _idaapi.MIPS_msa_nloc_b
MIPS_msa_nloc_h = _idaapi.MIPS_msa_nloc_h
MIPS_msa_nloc_w = _idaapi.MIPS_msa_nloc_w
MIPS_msa_nloc_d = _idaapi.MIPS_msa_nloc_d
MIPS_msa_nlzc_b = _idaapi.MIPS_msa_nlzc_b
MIPS_msa_nlzc_h = _idaapi.MIPS_msa_nlzc_h
MIPS_msa_nlzc_w = _idaapi.MIPS_msa_nlzc_w
MIPS_msa_nlzc_d = _idaapi.MIPS_msa_nlzc_d
MIPS_msa_copy_s_b = _idaapi.MIPS_msa_copy_s_b
MIPS_msa_copy_s_h = _idaapi.MIPS_msa_copy_s_h
MIPS_msa_copy_s_w = _idaapi.MIPS_msa_copy_s_w
MIPS_msa_copy_s_d = _idaapi.MIPS_msa_copy_s_d
MIPS_msa_copy_u_b = _idaapi.MIPS_msa_copy_u_b
MIPS_msa_copy_u_h = _idaapi.MIPS_msa_copy_u_h
MIPS_msa_copy_u_w = _idaapi.MIPS_msa_copy_u_w
MIPS_msa_copy_u_d = _idaapi.MIPS_msa_copy_u_d
MIPS_msa_insert_b = _idaapi.MIPS_msa_insert_b
MIPS_msa_insert_h = _idaapi.MIPS_msa_insert_h
MIPS_msa_insert_w = _idaapi.MIPS_msa_insert_w
MIPS_msa_insert_d = _idaapi.MIPS_msa_insert_d
MIPS_msa_insve_b = _idaapi.MIPS_msa_insve_b
MIPS_msa_insve_h = _idaapi.MIPS_msa_insve_h
MIPS_msa_insve_w = _idaapi.MIPS_msa_insve_w
MIPS_msa_insve_d = _idaapi.MIPS_msa_insve_d
MIPS_msa_bnz_b = _idaapi.MIPS_msa_bnz_b
MIPS_msa_bnz_h = _idaapi.MIPS_msa_bnz_h
MIPS_msa_bnz_w = _idaapi.MIPS_msa_bnz_w
MIPS_msa_bnz_d = _idaapi.MIPS_msa_bnz_d
MIPS_msa_bz_b = _idaapi.MIPS_msa_bz_b
MIPS_msa_bz_h = _idaapi.MIPS_msa_bz_h
MIPS_msa_bz_w = _idaapi.MIPS_msa_bz_w
MIPS_msa_bz_d = _idaapi.MIPS_msa_bz_d
MIPS_msa_ldi_b = _idaapi.MIPS_msa_ldi_b
MIPS_msa_ldi_h = _idaapi.MIPS_msa_ldi_h
MIPS_msa_ldi_w = _idaapi.MIPS_msa_ldi_w
MIPS_msa_ldi_d = _idaapi.MIPS_msa_ldi_d
MIPS_msa_fcaf_w = _idaapi.MIPS_msa_fcaf_w
MIPS_msa_fcaf_d = _idaapi.MIPS_msa_fcaf_d
MIPS_msa_fcun_w = _idaapi.MIPS_msa_fcun_w
MIPS_msa_fcun_d = _idaapi.MIPS_msa_fcun_d
MIPS_msa_fceq_w = _idaapi.MIPS_msa_fceq_w
MIPS_msa_fceq_d = _idaapi.MIPS_msa_fceq_d
MIPS_msa_fcueq_w = _idaapi.MIPS_msa_fcueq_w
MIPS_msa_fcueq_d = _idaapi.MIPS_msa_fcueq_d
MIPS_msa_fclt_w = _idaapi.MIPS_msa_fclt_w
MIPS_msa_fclt_d = _idaapi.MIPS_msa_fclt_d
MIPS_msa_fcult_w = _idaapi.MIPS_msa_fcult_w
MIPS_msa_fcult_d = _idaapi.MIPS_msa_fcult_d
MIPS_msa_fcle_w = _idaapi.MIPS_msa_fcle_w
MIPS_msa_fcle_d = _idaapi.MIPS_msa_fcle_d
MIPS_msa_fcule_w = _idaapi.MIPS_msa_fcule_w
MIPS_msa_fcule_d = _idaapi.MIPS_msa_fcule_d
MIPS_msa_fsaf_w = _idaapi.MIPS_msa_fsaf_w
MIPS_msa_fsaf_d = _idaapi.MIPS_msa_fsaf_d
MIPS_msa_fsun_w = _idaapi.MIPS_msa_fsun_w
MIPS_msa_fsun_d = _idaapi.MIPS_msa_fsun_d
MIPS_msa_fseq_w = _idaapi.MIPS_msa_fseq_w
MIPS_msa_fseq_d = _idaapi.MIPS_msa_fseq_d
MIPS_msa_fsueq_w = _idaapi.MIPS_msa_fsueq_w
MIPS_msa_fsueq_d = _idaapi.MIPS_msa_fsueq_d
MIPS_msa_fslt_w = _idaapi.MIPS_msa_fslt_w
MIPS_msa_fslt_d = _idaapi.MIPS_msa_fslt_d
MIPS_msa_fsult_w = _idaapi.MIPS_msa_fsult_w
MIPS_msa_fsult_d = _idaapi.MIPS_msa_fsult_d
MIPS_msa_fsle_w = _idaapi.MIPS_msa_fsle_w
MIPS_msa_fsle_d = _idaapi.MIPS_msa_fsle_d
MIPS_msa_fsule_w = _idaapi.MIPS_msa_fsule_w
MIPS_msa_fsule_d = _idaapi.MIPS_msa_fsule_d
MIPS_msa_fadd_w = _idaapi.MIPS_msa_fadd_w
MIPS_msa_fadd_d = _idaapi.MIPS_msa_fadd_d
MIPS_msa_fsub_w = _idaapi.MIPS_msa_fsub_w
MIPS_msa_fsub_d = _idaapi.MIPS_msa_fsub_d
MIPS_msa_fmul_w = _idaapi.MIPS_msa_fmul_w
MIPS_msa_fmul_d = _idaapi.MIPS_msa_fmul_d
MIPS_msa_fdiv_w = _idaapi.MIPS_msa_fdiv_w
MIPS_msa_fdiv_d = _idaapi.MIPS_msa_fdiv_d
MIPS_msa_fmadd_w = _idaapi.MIPS_msa_fmadd_w
MIPS_msa_fmadd_d = _idaapi.MIPS_msa_fmadd_d
MIPS_msa_fmsub_w = _idaapi.MIPS_msa_fmsub_w
MIPS_msa_fmsub_d = _idaapi.MIPS_msa_fmsub_d
MIPS_msa_fexp2_w = _idaapi.MIPS_msa_fexp2_w
MIPS_msa_fexp2_d = _idaapi.MIPS_msa_fexp2_d
MIPS_msa_fexdo_h = _idaapi.MIPS_msa_fexdo_h
MIPS_msa_fexdo_w = _idaapi.MIPS_msa_fexdo_w
MIPS_msa_ftq_h = _idaapi.MIPS_msa_ftq_h
MIPS_msa_ftq_w = _idaapi.MIPS_msa_ftq_w
MIPS_msa_fmin_w = _idaapi.MIPS_msa_fmin_w
MIPS_msa_fmin_d = _idaapi.MIPS_msa_fmin_d
MIPS_msa_fmin_a_w = _idaapi.MIPS_msa_fmin_a_w
MIPS_msa_fmin_a_d = _idaapi.MIPS_msa_fmin_a_d
MIPS_msa_fmax_w = _idaapi.MIPS_msa_fmax_w
MIPS_msa_fmax_d = _idaapi.MIPS_msa_fmax_d
MIPS_msa_fmax_a_w = _idaapi.MIPS_msa_fmax_a_w
MIPS_msa_fmax_a_d = _idaapi.MIPS_msa_fmax_a_d
MIPS_msa_fcor_w = _idaapi.MIPS_msa_fcor_w
MIPS_msa_fcor_d = _idaapi.MIPS_msa_fcor_d
MIPS_msa_fcune_w = _idaapi.MIPS_msa_fcune_w
MIPS_msa_fcune_d = _idaapi.MIPS_msa_fcune_d
MIPS_msa_fcne_w = _idaapi.MIPS_msa_fcne_w
MIPS_msa_fcne_d = _idaapi.MIPS_msa_fcne_d
MIPS_msa_mul_q_h = _idaapi.MIPS_msa_mul_q_h
MIPS_msa_mul_q_w = _idaapi.MIPS_msa_mul_q_w
MIPS_msa_madd_q_h = _idaapi.MIPS_msa_madd_q_h
MIPS_msa_madd_q_w = _idaapi.MIPS_msa_madd_q_w
MIPS_msa_msub_q_h = _idaapi.MIPS_msa_msub_q_h
MIPS_msa_msub_q_w = _idaapi.MIPS_msa_msub_q_w
MIPS_msa_fsor_w = _idaapi.MIPS_msa_fsor_w
MIPS_msa_fsor_d = _idaapi.MIPS_msa_fsor_d
MIPS_msa_fsune_w = _idaapi.MIPS_msa_fsune_w
MIPS_msa_fsune_d = _idaapi.MIPS_msa_fsune_d
MIPS_msa_fsne_w = _idaapi.MIPS_msa_fsne_w
MIPS_msa_fsne_d = _idaapi.MIPS_msa_fsne_d
MIPS_msa_mulr_q_h = _idaapi.MIPS_msa_mulr_q_h
MIPS_msa_mulr_q_w = _idaapi.MIPS_msa_mulr_q_w
MIPS_msa_maddr_q_h = _idaapi.MIPS_msa_maddr_q_h
MIPS_msa_maddr_q_w = _idaapi.MIPS_msa_maddr_q_w
MIPS_msa_msubr_q_h = _idaapi.MIPS_msa_msubr_q_h
MIPS_msa_msubr_q_w = _idaapi.MIPS_msa_msubr_q_w
MIPS_msa_fclass_w = _idaapi.MIPS_msa_fclass_w
MIPS_msa_fclass_d = _idaapi.MIPS_msa_fclass_d
MIPS_msa_ftrunc_s_w = _idaapi.MIPS_msa_ftrunc_s_w
MIPS_msa_ftrunc_s_d = _idaapi.MIPS_msa_ftrunc_s_d
MIPS_msa_ftrunc_u_w = _idaapi.MIPS_msa_ftrunc_u_w
MIPS_msa_ftrunc_u_d = _idaapi.MIPS_msa_ftrunc_u_d
MIPS_msa_fsqrt_w = _idaapi.MIPS_msa_fsqrt_w
MIPS_msa_fsqrt_d = _idaapi.MIPS_msa_fsqrt_d
MIPS_msa_frsqrt_w = _idaapi.MIPS_msa_frsqrt_w
MIPS_msa_frsqrt_d = _idaapi.MIPS_msa_frsqrt_d
MIPS_msa_frcp_w = _idaapi.MIPS_msa_frcp_w
MIPS_msa_frcp_d = _idaapi.MIPS_msa_frcp_d
MIPS_msa_frint_w = _idaapi.MIPS_msa_frint_w
MIPS_msa_frint_d = _idaapi.MIPS_msa_frint_d
MIPS_msa_flog2_w = _idaapi.MIPS_msa_flog2_w
MIPS_msa_flog2_d = _idaapi.MIPS_msa_flog2_d
MIPS_msa_fexupl_w = _idaapi.MIPS_msa_fexupl_w
MIPS_msa_fexupl_d = _idaapi.MIPS_msa_fexupl_d
MIPS_msa_fexupr_w = _idaapi.MIPS_msa_fexupr_w
MIPS_msa_fexupr_d = _idaapi.MIPS_msa_fexupr_d
MIPS_msa_ffql_w = _idaapi.MIPS_msa_ffql_w
MIPS_msa_ffql_d = _idaapi.MIPS_msa_ffql_d
MIPS_msa_ffqr_w = _idaapi.MIPS_msa_ffqr_w
MIPS_msa_ffqr_d = _idaapi.MIPS_msa_ffqr_d
MIPS_msa_ftint_s_w = _idaapi.MIPS_msa_ftint_s_w
MIPS_msa_ftint_s_d = _idaapi.MIPS_msa_ftint_s_d
MIPS_msa_ftint_u_w = _idaapi.MIPS_msa_ftint_u_w
MIPS_msa_ftint_u_d = _idaapi.MIPS_msa_ftint_u_d
MIPS_msa_ffint_s_w = _idaapi.MIPS_msa_ffint_s_w
MIPS_msa_ffint_s_d = _idaapi.MIPS_msa_ffint_s_d
MIPS_msa_ffint_u_w = _idaapi.MIPS_msa_ffint_u_w
MIPS_msa_ffint_u_d = _idaapi.MIPS_msa_ffint_u_d
MIPS_msa_ctcmsa = _idaapi.MIPS_msa_ctcmsa
MIPS_msa_cfcmsa = _idaapi.MIPS_msa_cfcmsa
MIPS_msa_move_v = _idaapi.MIPS_msa_move_v
MIPS_lsa = _idaapi.MIPS_lsa
MIPS_dlsa = _idaapi.MIPS_dlsa
MIPS_last = _idaapi.MIPS_last
H8_null = _idaapi.H8_null
H8_add = _idaapi.H8_add
H8_adds = _idaapi.H8_adds
H8_addx = _idaapi.H8_addx
H8_and = _idaapi.H8_and
H8_andc = _idaapi.H8_andc
H8_band = _idaapi.H8_band
H8_bra = _idaapi.H8_bra
H8_brn = _idaapi.H8_brn
H8_bhi = _idaapi.H8_bhi
H8_bls = _idaapi.H8_bls
H8_bcc = _idaapi.H8_bcc
H8_bcs = _idaapi.H8_bcs
H8_bne = _idaapi.H8_bne
H8_beq = _idaapi.H8_beq
H8_bvc = _idaapi.H8_bvc
H8_bvs = _idaapi.H8_bvs
H8_bpl = _idaapi.H8_bpl
H8_bmi = _idaapi.H8_bmi
H8_bge = _idaapi.H8_bge
H8_blt = _idaapi.H8_blt
H8_bgt = _idaapi.H8_bgt
H8_ble = _idaapi.H8_ble
H8_bclr = _idaapi.H8_bclr
H8_biand = _idaapi.H8_biand
H8_bild = _idaapi.H8_bild
H8_bior = _idaapi.H8_bior
H8_bist = _idaapi.H8_bist
H8_bixor = _idaapi.H8_bixor
H8_bld = _idaapi.H8_bld
H8_bnot = _idaapi.H8_bnot
H8_bor = _idaapi.H8_bor
H8_bset = _idaapi.H8_bset
H8_bsr = _idaapi.H8_bsr
H8_bst = _idaapi.H8_bst
H8_btst = _idaapi.H8_btst
H8_bxor = _idaapi.H8_bxor
H8_clrmac = _idaapi.H8_clrmac
H8_cmp = _idaapi.H8_cmp
H8_daa = _idaapi.H8_daa
H8_das = _idaapi.H8_das
H8_dec = _idaapi.H8_dec
H8_divxs = _idaapi.H8_divxs
H8_divxu = _idaapi.H8_divxu
H8_eepmov = _idaapi.H8_eepmov
H8_exts = _idaapi.H8_exts
H8_extu = _idaapi.H8_extu
H8_inc = _idaapi.H8_inc
H8_jmp = _idaapi.H8_jmp
H8_jsr = _idaapi.H8_jsr
H8_ldc = _idaapi.H8_ldc
H8_ldm = _idaapi.H8_ldm
H8_ldmac = _idaapi.H8_ldmac
H8_mac = _idaapi.H8_mac
H8_mov = _idaapi.H8_mov
H8_movfpe = _idaapi.H8_movfpe
H8_movtpe = _idaapi.H8_movtpe
H8_mulxs = _idaapi.H8_mulxs
H8_mulxu = _idaapi.H8_mulxu
H8_neg = _idaapi.H8_neg
H8_nop = _idaapi.H8_nop
H8_not = _idaapi.H8_not
H8_or = _idaapi.H8_or
H8_orc = _idaapi.H8_orc
H8_pop = _idaapi.H8_pop
H8_push = _idaapi.H8_push
H8_rotl = _idaapi.H8_rotl
H8_rotr = _idaapi.H8_rotr
H8_rotxl = _idaapi.H8_rotxl
H8_rotxr = _idaapi.H8_rotxr
H8_rte = _idaapi.H8_rte
H8_rts = _idaapi.H8_rts
H8_shal = _idaapi.H8_shal
H8_shar = _idaapi.H8_shar
H8_shll = _idaapi.H8_shll
H8_shlr = _idaapi.H8_shlr
H8_sleep = _idaapi.H8_sleep
H8_stc = _idaapi.H8_stc
H8_stm = _idaapi.H8_stm
H8_stmac = _idaapi.H8_stmac
H8_sub = _idaapi.H8_sub
H8_subs = _idaapi.H8_subs
H8_subx = _idaapi.H8_subx
H8_tas = _idaapi.H8_tas
H8_trapa = _idaapi.H8_trapa
H8_xor = _idaapi.H8_xor
H8_xorc = _idaapi.H8_xorc
H8_rtel = _idaapi.H8_rtel
H8_rtsl = _idaapi.H8_rtsl
H8_movmd = _idaapi.H8_movmd
H8_movsd = _idaapi.H8_movsd
H8_bras = _idaapi.H8_bras
H8_movab = _idaapi.H8_movab
H8_movaw = _idaapi.H8_movaw
H8_moval = _idaapi.H8_moval
H8_bsetne = _idaapi.H8_bsetne
H8_bseteq = _idaapi.H8_bseteq
H8_bclrne = _idaapi.H8_bclrne
H8_bclreq = _idaapi.H8_bclreq
H8_bstz = _idaapi.H8_bstz
H8_bistz = _idaapi.H8_bistz
H8_bfld = _idaapi.H8_bfld
H8_bfst = _idaapi.H8_bfst
H8_muls = _idaapi.H8_muls
H8_divs = _idaapi.H8_divs
H8_mulu = _idaapi.H8_mulu
H8_divu = _idaapi.H8_divu
H8_mulsu = _idaapi.H8_mulsu
H8_muluu = _idaapi.H8_muluu
H8_brabc = _idaapi.H8_brabc
H8_brabs = _idaapi.H8_brabs
H8_bsrbc = _idaapi.H8_bsrbc
H8_bsrbs = _idaapi.H8_bsrbs
H8_last = _idaapi.H8_last
PIC_null = _idaapi.PIC_null
PIC_addwf = _idaapi.PIC_addwf
PIC_andwf = _idaapi.PIC_andwf
PIC_clrf = _idaapi.PIC_clrf
PIC_clrw = _idaapi.PIC_clrw
PIC_comf = _idaapi.PIC_comf
PIC_decf = _idaapi.PIC_decf
PIC_decfsz = _idaapi.PIC_decfsz
PIC_incf = _idaapi.PIC_incf
PIC_incfsz = _idaapi.PIC_incfsz
PIC_iorwf = _idaapi.PIC_iorwf
PIC_movf = _idaapi.PIC_movf
PIC_movwf = _idaapi.PIC_movwf
PIC_nop = _idaapi.PIC_nop
PIC_rlf = _idaapi.PIC_rlf
PIC_rrf = _idaapi.PIC_rrf
PIC_subwf = _idaapi.PIC_subwf
PIC_swapf = _idaapi.PIC_swapf
PIC_xorwf = _idaapi.PIC_xorwf
PIC_bcf = _idaapi.PIC_bcf
PIC_bsf = _idaapi.PIC_bsf
PIC_btfsc = _idaapi.PIC_btfsc
PIC_btfss = _idaapi.PIC_btfss
PIC_addlw = _idaapi.PIC_addlw
PIC_andlw = _idaapi.PIC_andlw
PIC_call = _idaapi.PIC_call
PIC_clrwdt = _idaapi.PIC_clrwdt
PIC_goto = _idaapi.PIC_goto
PIC_iorlw = _idaapi.PIC_iorlw
PIC_movlw = _idaapi.PIC_movlw
PIC_retfie = _idaapi.PIC_retfie
PIC_retlw = _idaapi.PIC_retlw
PIC_return = _idaapi.PIC_return
PIC_sleep = _idaapi.PIC_sleep
PIC_sublw = _idaapi.PIC_sublw
PIC_xorlw = _idaapi.PIC_xorlw
PIC_option = _idaapi.PIC_option
PIC_tris = _idaapi.PIC_tris
PIC_movfw = _idaapi.PIC_movfw
PIC_tstf = _idaapi.PIC_tstf
PIC_negf = _idaapi.PIC_negf
PIC_b = _idaapi.PIC_b
PIC_clrc = _idaapi.PIC_clrc
PIC_clrdc = _idaapi.PIC_clrdc
PIC_clrz = _idaapi.PIC_clrz
PIC_setc = _idaapi.PIC_setc
PIC_setdc = _idaapi.PIC_setdc
PIC_setz = _idaapi.PIC_setz
PIC_skpc = _idaapi.PIC_skpc
PIC_skpdc = _idaapi.PIC_skpdc
PIC_skpnc = _idaapi.PIC_skpnc
PIC_skpndc = _idaapi.PIC_skpndc
PIC_skpnz = _idaapi.PIC_skpnz
PIC_skpz = _idaapi.PIC_skpz
PIC_bc = _idaapi.PIC_bc
PIC_bdc = _idaapi.PIC_bdc
PIC_bnc = _idaapi.PIC_bnc
PIC_bndc = _idaapi.PIC_bndc
PIC_bnz = _idaapi.PIC_bnz
PIC_bz = _idaapi.PIC_bz
PIC_addcf = _idaapi.PIC_addcf
PIC_adddcf = _idaapi.PIC_adddcf
PIC_subcf = _idaapi.PIC_subcf
PIC_addwf3 = _idaapi.PIC_addwf3
PIC_addwfc3 = _idaapi.PIC_addwfc3
PIC_andwf3 = _idaapi.PIC_andwf3
PIC_clrf2 = _idaapi.PIC_clrf2
PIC_comf3 = _idaapi.PIC_comf3
PIC_cpfseq2 = _idaapi.PIC_cpfseq2
PIC_cpfsgt2 = _idaapi.PIC_cpfsgt2
PIC_cpfslt2 = _idaapi.PIC_cpfslt2
PIC_decf3 = _idaapi.PIC_decf3
PIC_decfsz3 = _idaapi.PIC_decfsz3
PIC_dcfsnz3 = _idaapi.PIC_dcfsnz3
PIC_incf3 = _idaapi.PIC_incf3
PIC_incfsz3 = _idaapi.PIC_incfsz3
PIC_infsnz3 = _idaapi.PIC_infsnz3
PIC_iorwf3 = _idaapi.PIC_iorwf3
PIC_movf3 = _idaapi.PIC_movf3
PIC_movff2 = _idaapi.PIC_movff2
PIC_movwf2 = _idaapi.PIC_movwf2
PIC_mulwf2 = _idaapi.PIC_mulwf2
PIC_negf2 = _idaapi.PIC_negf2
PIC_rlcf3 = _idaapi.PIC_rlcf3
PIC_rlncf3 = _idaapi.PIC_rlncf3
PIC_rrcf3 = _idaapi.PIC_rrcf3
PIC_rrncf3 = _idaapi.PIC_rrncf3
PIC_setf2 = _idaapi.PIC_setf2
PIC_subfwb3 = _idaapi.PIC_subfwb3
PIC_subwf3 = _idaapi.PIC_subwf3
PIC_subwfb3 = _idaapi.PIC_subwfb3
PIC_swapf3 = _idaapi.PIC_swapf3
PIC_tstfsz2 = _idaapi.PIC_tstfsz2
PIC_xorwf3 = _idaapi.PIC_xorwf3
PIC_bcf3 = _idaapi.PIC_bcf3
PIC_bsf3 = _idaapi.PIC_bsf3
PIC_btfsc3 = _idaapi.PIC_btfsc3
PIC_btfss3 = _idaapi.PIC_btfss3
PIC_btg3 = _idaapi.PIC_btg3
PIC_bc1 = _idaapi.PIC_bc1
PIC_bn1 = _idaapi.PIC_bn1
PIC_bnc1 = _idaapi.PIC_bnc1
PIC_bnn1 = _idaapi.PIC_bnn1
PIC_bnov1 = _idaapi.PIC_bnov1
PIC_bnz1 = _idaapi.PIC_bnz1
PIC_bov1 = _idaapi.PIC_bov1
PIC_bra1 = _idaapi.PIC_bra1
PIC_bz1 = _idaapi.PIC_bz1
PIC_call2 = _idaapi.PIC_call2
PIC_daw0 = _idaapi.PIC_daw0
PIC_pop0 = _idaapi.PIC_pop0
PIC_push0 = _idaapi.PIC_push0
PIC_rcall1 = _idaapi.PIC_rcall1
PIC_reset0 = _idaapi.PIC_reset0
PIC_retfie1 = _idaapi.PIC_retfie1
PIC_return1 = _idaapi.PIC_return1
PIC_lfsr2 = _idaapi.PIC_lfsr2
PIC_movlb1 = _idaapi.PIC_movlb1
PIC_mullw1 = _idaapi.PIC_mullw1
PIC_tblrd0 = _idaapi.PIC_tblrd0
PIC_tblrd0p = _idaapi.PIC_tblrd0p
PIC_tblrd0m = _idaapi.PIC_tblrd0m
PIC_tblrdp0 = _idaapi.PIC_tblrdp0
PIC_tblwt0 = _idaapi.PIC_tblwt0
PIC_tblwt0p = _idaapi.PIC_tblwt0p
PIC_tblwt0m = _idaapi.PIC_tblwt0m
PIC_tblwtp0 = _idaapi.PIC_tblwtp0
PIC_last = _idaapi.PIC_last
SPARC_null = _idaapi.SPARC_null
SPARC_add = _idaapi.SPARC_add
SPARC_addcc = _idaapi.SPARC_addcc
SPARC_addc = _idaapi.SPARC_addc
SPARC_addccc = _idaapi.SPARC_addccc
SPARC_and = _idaapi.SPARC_and
SPARC_andcc = _idaapi.SPARC_andcc
SPARC_andn = _idaapi.SPARC_andn
SPARC_andncc = _idaapi.SPARC_andncc
SPARC_b = _idaapi.SPARC_b
SPARC_bp = _idaapi.SPARC_bp
SPARC_bpr = _idaapi.SPARC_bpr
SPARC_call = _idaapi.SPARC_call
SPARC_casa = _idaapi.SPARC_casa
SPARC_casxa = _idaapi.SPARC_casxa
SPARC_done = _idaapi.SPARC_done
SPARC_fabs = _idaapi.SPARC_fabs
SPARC_fadd = _idaapi.SPARC_fadd
SPARC_fbp = _idaapi.SPARC_fbp
SPARC_fb = _idaapi.SPARC_fb
SPARC_fcmp = _idaapi.SPARC_fcmp
SPARC_fcmpe = _idaapi.SPARC_fcmpe
SPARC_fdiv = _idaapi.SPARC_fdiv
SPARC_fdmulq = _idaapi.SPARC_fdmulq
SPARC_flush = _idaapi.SPARC_flush
SPARC_flushw = _idaapi.SPARC_flushw
SPARC_fmov = _idaapi.SPARC_fmov
SPARC_fmovcc = _idaapi.SPARC_fmovcc
SPARC_fmovr = _idaapi.SPARC_fmovr
SPARC_fmul = _idaapi.SPARC_fmul
SPARC_fneg = _idaapi.SPARC_fneg
SPARC_fsmuld = _idaapi.SPARC_fsmuld
SPARC_fsqrt = _idaapi.SPARC_fsqrt
SPARC_fsub = _idaapi.SPARC_fsub
SPARC_fstox = _idaapi.SPARC_fstox
SPARC_fdtox = _idaapi.SPARC_fdtox
SPARC_fqtox = _idaapi.SPARC_fqtox
SPARC_fxtos = _idaapi.SPARC_fxtos
SPARC_fxtod = _idaapi.SPARC_fxtod
SPARC_fxtoq = _idaapi.SPARC_fxtoq
SPARC_fitos = _idaapi.SPARC_fitos
SPARC_fdtos = _idaapi.SPARC_fdtos
SPARC_fqtos = _idaapi.SPARC_fqtos
SPARC_fitod = _idaapi.SPARC_fitod
SPARC_fstod = _idaapi.SPARC_fstod
SPARC_fqtod = _idaapi.SPARC_fqtod
SPARC_fitoq = _idaapi.SPARC_fitoq
SPARC_fstoq = _idaapi.SPARC_fstoq
SPARC_fdtoq = _idaapi.SPARC_fdtoq
SPARC_fstoi = _idaapi.SPARC_fstoi
SPARC_fdtoi = _idaapi.SPARC_fdtoi
SPARC_fqtoi = _idaapi.SPARC_fqtoi
SPARC_illtrap = _idaapi.SPARC_illtrap
SPARC_impdep1 = _idaapi.SPARC_impdep1
SPARC_impdep2 = _idaapi.SPARC_impdep2
SPARC_jmpl = _idaapi.SPARC_jmpl
SPARC_ldd = _idaapi.SPARC_ldd
SPARC_ldda = _idaapi.SPARC_ldda
SPARC_lddf = _idaapi.SPARC_lddf
SPARC_lddfa = _idaapi.SPARC_lddfa
SPARC_ldf = _idaapi.SPARC_ldf
SPARC_ldfa = _idaapi.SPARC_ldfa
SPARC_ldfsr = _idaapi.SPARC_ldfsr
SPARC_ldqf = _idaapi.SPARC_ldqf
SPARC_ldqfa = _idaapi.SPARC_ldqfa
SPARC_ldsb = _idaapi.SPARC_ldsb
SPARC_ldsba = _idaapi.SPARC_ldsba
SPARC_ldsh = _idaapi.SPARC_ldsh
SPARC_ldsha = _idaapi.SPARC_ldsha
SPARC_ldstub = _idaapi.SPARC_ldstub
SPARC_ldstuba = _idaapi.SPARC_ldstuba
SPARC_ldsw = _idaapi.SPARC_ldsw
SPARC_ldswa = _idaapi.SPARC_ldswa
SPARC_ldub = _idaapi.SPARC_ldub
SPARC_lduba = _idaapi.SPARC_lduba
SPARC_lduh = _idaapi.SPARC_lduh
SPARC_lduha = _idaapi.SPARC_lduha
SPARC_lduw = _idaapi.SPARC_lduw
SPARC_lduwa = _idaapi.SPARC_lduwa
SPARC_ldx = _idaapi.SPARC_ldx
SPARC_ldxa = _idaapi.SPARC_ldxa
SPARC_ldxfsr = _idaapi.SPARC_ldxfsr
SPARC_membar = _idaapi.SPARC_membar
SPARC_mov = _idaapi.SPARC_mov
SPARC_movr = _idaapi.SPARC_movr
SPARC_mulscc = _idaapi.SPARC_mulscc
SPARC_mulx = _idaapi.SPARC_mulx
SPARC_nop = _idaapi.SPARC_nop
SPARC_or = _idaapi.SPARC_or
SPARC_orcc = _idaapi.SPARC_orcc
SPARC_orn = _idaapi.SPARC_orn
SPARC_orncc = _idaapi.SPARC_orncc
SPARC_popc = _idaapi.SPARC_popc
SPARC_prefetch = _idaapi.SPARC_prefetch
SPARC_prefetcha = _idaapi.SPARC_prefetcha
SPARC_rd = _idaapi.SPARC_rd
SPARC_rdpr = _idaapi.SPARC_rdpr
SPARC_restore = _idaapi.SPARC_restore
SPARC_restored = _idaapi.SPARC_restored
SPARC_retry = _idaapi.SPARC_retry
SPARC_return = _idaapi.SPARC_return
SPARC_save = _idaapi.SPARC_save
SPARC_saved = _idaapi.SPARC_saved
SPARC_sdiv = _idaapi.SPARC_sdiv
SPARC_sdivcc = _idaapi.SPARC_sdivcc
SPARC_sdivx = _idaapi.SPARC_sdivx
SPARC_sethi = _idaapi.SPARC_sethi
SPARC_sir = _idaapi.SPARC_sir
SPARC_sll = _idaapi.SPARC_sll
SPARC_sllx = _idaapi.SPARC_sllx
SPARC_smul = _idaapi.SPARC_smul
SPARC_smulcc = _idaapi.SPARC_smulcc
SPARC_sra = _idaapi.SPARC_sra
SPARC_srax = _idaapi.SPARC_srax
SPARC_srl = _idaapi.SPARC_srl
SPARC_srlx = _idaapi.SPARC_srlx
SPARC_stb = _idaapi.SPARC_stb
SPARC_stba = _idaapi.SPARC_stba
SPARC_stbar = _idaapi.SPARC_stbar
SPARC_std = _idaapi.SPARC_std
SPARC_stda = _idaapi.SPARC_stda
SPARC_stdf = _idaapi.SPARC_stdf
SPARC_stdfa = _idaapi.SPARC_stdfa
SPARC_stf = _idaapi.SPARC_stf
SPARC_stfa = _idaapi.SPARC_stfa
SPARC_stfsr = _idaapi.SPARC_stfsr
SPARC_sth = _idaapi.SPARC_sth
SPARC_stha = _idaapi.SPARC_stha
SPARC_stqf = _idaapi.SPARC_stqf
SPARC_stqfa = _idaapi.SPARC_stqfa
SPARC_stw = _idaapi.SPARC_stw
SPARC_stwa = _idaapi.SPARC_stwa
SPARC_stx = _idaapi.SPARC_stx
SPARC_stxa = _idaapi.SPARC_stxa
SPARC_stxfsr = _idaapi.SPARC_stxfsr
SPARC_sub = _idaapi.SPARC_sub
SPARC_subcc = _idaapi.SPARC_subcc
SPARC_subc = _idaapi.SPARC_subc
SPARC_subccc = _idaapi.SPARC_subccc
SPARC_swap = _idaapi.SPARC_swap
SPARC_swapa = _idaapi.SPARC_swapa
SPARC_taddcc = _idaapi.SPARC_taddcc
SPARC_taddcctv = _idaapi.SPARC_taddcctv
SPARC_tsubcc = _idaapi.SPARC_tsubcc
SPARC_tsubcctv = _idaapi.SPARC_tsubcctv
SPARC_t = _idaapi.SPARC_t
SPARC_udiv = _idaapi.SPARC_udiv
SPARC_udivcc = _idaapi.SPARC_udivcc
SPARC_udivx = _idaapi.SPARC_udivx
SPARC_umul = _idaapi.SPARC_umul
SPARC_umulcc = _idaapi.SPARC_umulcc
SPARC_wr = _idaapi.SPARC_wr
SPARC_wrpr = _idaapi.SPARC_wrpr
SPARC_xnor = _idaapi.SPARC_xnor
SPARC_xnorcc = _idaapi.SPARC_xnorcc
SPARC_xor = _idaapi.SPARC_xor
SPARC_xorcc = _idaapi.SPARC_xorcc
SPARC_cmp = _idaapi.SPARC_cmp
SPARC_jmp = _idaapi.SPARC_jmp
SPARC_iprefetch = _idaapi.SPARC_iprefetch
SPARC_tst = _idaapi.SPARC_tst
SPARC_ret = _idaapi.SPARC_ret
SPARC_retl = _idaapi.SPARC_retl
SPARC_setuw = _idaapi.SPARC_setuw
SPARC_setsw = _idaapi.SPARC_setsw
SPARC_setx = _idaapi.SPARC_setx
SPARC_signx = _idaapi.SPARC_signx
SPARC_not = _idaapi.SPARC_not
SPARC_neg = _idaapi.SPARC_neg
SPARC_cas = _idaapi.SPARC_cas
SPARC_casl = _idaapi.SPARC_casl
SPARC_casx = _idaapi.SPARC_casx
SPARC_casxl = _idaapi.SPARC_casxl
SPARC_inc = _idaapi.SPARC_inc
SPARC_inccc = _idaapi.SPARC_inccc
SPARC_dec = _idaapi.SPARC_dec
SPARC_deccc = _idaapi.SPARC_deccc
SPARC_btst = _idaapi.SPARC_btst
SPARC_bset = _idaapi.SPARC_bset
SPARC_bclr = _idaapi.SPARC_bclr
SPARC_btog = _idaapi.SPARC_btog
SPARC_clr = _idaapi.SPARC_clr
SPARC_clrb = _idaapi.SPARC_clrb
SPARC_clrh = _idaapi.SPARC_clrh
SPARC_clrx = _idaapi.SPARC_clrx
SPARC_clruw = _idaapi.SPARC_clruw
SPARC_pseudo_mov = _idaapi.SPARC_pseudo_mov
SPARC_alignaddress = _idaapi.SPARC_alignaddress
SPARC_array = _idaapi.SPARC_array
SPARC_edge = _idaapi.SPARC_edge
SPARC_faligndata = _idaapi.SPARC_faligndata
SPARC_fandnot1 = _idaapi.SPARC_fandnot1
SPARC_fandnot2 = _idaapi.SPARC_fandnot2
SPARC_fand = _idaapi.SPARC_fand
SPARC_fcmpeq = _idaapi.SPARC_fcmpeq
SPARC_fcmpgt = _idaapi.SPARC_fcmpgt
SPARC_fcmple = _idaapi.SPARC_fcmple
SPARC_fcmpne = _idaapi.SPARC_fcmpne
SPARC_fexpand = _idaapi.SPARC_fexpand
SPARC_fmul8sux16 = _idaapi.SPARC_fmul8sux16
SPARC_fmul8ulx16 = _idaapi.SPARC_fmul8ulx16
SPARC_fmul8x16 = _idaapi.SPARC_fmul8x16
SPARC_fmul8x16al = _idaapi.SPARC_fmul8x16al
SPARC_fmul8x16au = _idaapi.SPARC_fmul8x16au
SPARC_fmuld8sux16 = _idaapi.SPARC_fmuld8sux16
SPARC_fmuld8ulx16 = _idaapi.SPARC_fmuld8ulx16
SPARC_fnand = _idaapi.SPARC_fnand
SPARC_fnor = _idaapi.SPARC_fnor
SPARC_fnot1 = _idaapi.SPARC_fnot1
SPARC_fnot2 = _idaapi.SPARC_fnot2
SPARC_fone = _idaapi.SPARC_fone
SPARC_fornot1 = _idaapi.SPARC_fornot1
SPARC_fornot2 = _idaapi.SPARC_fornot2
SPARC_for = _idaapi.SPARC_for
SPARC_fpackfix = _idaapi.SPARC_fpackfix
SPARC_fpack = _idaapi.SPARC_fpack
SPARC_fpadd = _idaapi.SPARC_fpadd
SPARC_fpmerge = _idaapi.SPARC_fpmerge
SPARC_fpsub = _idaapi.SPARC_fpsub
SPARC_fsrc1 = _idaapi.SPARC_fsrc1
SPARC_fsrc2 = _idaapi.SPARC_fsrc2
SPARC_fxnor = _idaapi.SPARC_fxnor
SPARC_fxor = _idaapi.SPARC_fxor
SPARC_fzero = _idaapi.SPARC_fzero
SPARC_pdist = _idaapi.SPARC_pdist
SPARC_shutdown = _idaapi.SPARC_shutdown
SPARC_rett = _idaapi.SPARC_rett
SPARC_last = _idaapi.SPARC_last
HPPA_null = _idaapi.HPPA_null
HPPA_add = _idaapi.HPPA_add
HPPA_addb = _idaapi.HPPA_addb
HPPA_addi = _idaapi.HPPA_addi
HPPA_addib = _idaapi.HPPA_addib
HPPA_addil = _idaapi.HPPA_addil
HPPA_and = _idaapi.HPPA_and
HPPA_andcm = _idaapi.HPPA_andcm
HPPA_b = _idaapi.HPPA_b
HPPA_bb = _idaapi.HPPA_bb
HPPA_be = _idaapi.HPPA_be
HPPA_blr = _idaapi.HPPA_blr
HPPA_break = _idaapi.HPPA_break
HPPA_bv = _idaapi.HPPA_bv
HPPA_bve = _idaapi.HPPA_bve
HPPA_cldd = _idaapi.HPPA_cldd
HPPA_cldw = _idaapi.HPPA_cldw
HPPA_clrbts = _idaapi.HPPA_clrbts
HPPA_cmpb = _idaapi.HPPA_cmpb
HPPA_cmpclr = _idaapi.HPPA_cmpclr
HPPA_cmpib = _idaapi.HPPA_cmpib
HPPA_cmpiclr = _idaapi.HPPA_cmpiclr
HPPA_copr = _idaapi.HPPA_copr
HPPA_cstd = _idaapi.HPPA_cstd
HPPA_cstw = _idaapi.HPPA_cstw
HPPA_dcor = _idaapi.HPPA_dcor
HPPA_depd = _idaapi.HPPA_depd
HPPA_depdi = _idaapi.HPPA_depdi
HPPA_depw = _idaapi.HPPA_depw
HPPA_depwi = _idaapi.HPPA_depwi
HPPA_diag = _idaapi.HPPA_diag
HPPA_ds = _idaapi.HPPA_ds
HPPA_extrd = _idaapi.HPPA_extrd
HPPA_extrw = _idaapi.HPPA_extrw
HPPA_fdc = _idaapi.HPPA_fdc
HPPA_fdce = _idaapi.HPPA_fdce
HPPA_fic = _idaapi.HPPA_fic
HPPA_fice = _idaapi.HPPA_fice
HPPA_hadd = _idaapi.HPPA_hadd
HPPA_havg = _idaapi.HPPA_havg
HPPA_hshl = _idaapi.HPPA_hshl
HPPA_hshladd = _idaapi.HPPA_hshladd
HPPA_hshr = _idaapi.HPPA_hshr
HPPA_hshradd = _idaapi.HPPA_hshradd
HPPA_hsub = _idaapi.HPPA_hsub
HPPA_idtlbt = _idaapi.HPPA_idtlbt
HPPA_iitlbt = _idaapi.HPPA_iitlbt
HPPA_lci = _idaapi.HPPA_lci
HPPA_ldb = _idaapi.HPPA_ldb
HPPA_ldcd = _idaapi.HPPA_ldcd
HPPA_ldcw = _idaapi.HPPA_ldcw
HPPA_ldd = _idaapi.HPPA_ldd
HPPA_ldda = _idaapi.HPPA_ldda
HPPA_ldh = _idaapi.HPPA_ldh
HPPA_ldil = _idaapi.HPPA_ldil
HPPA_ldo = _idaapi.HPPA_ldo
HPPA_ldsid = _idaapi.HPPA_ldsid
HPPA_ldw = _idaapi.HPPA_ldw
HPPA_ldwa = _idaapi.HPPA_ldwa
HPPA_lpa = _idaapi.HPPA_lpa
HPPA_mfctl = _idaapi.HPPA_mfctl
HPPA_mfia = _idaapi.HPPA_mfia
HPPA_mfsp = _idaapi.HPPA_mfsp
HPPA_mixh = _idaapi.HPPA_mixh
HPPA_mixw = _idaapi.HPPA_mixw
HPPA_movb = _idaapi.HPPA_movb
HPPA_movib = _idaapi.HPPA_movib
HPPA_mtctl = _idaapi.HPPA_mtctl
HPPA_mtsarcm = _idaapi.HPPA_mtsarcm
HPPA_mtsm = _idaapi.HPPA_mtsm
HPPA_mtsp = _idaapi.HPPA_mtsp
HPPA_or = _idaapi.HPPA_or
HPPA_pdc = _idaapi.HPPA_pdc
HPPA_pdtlb = _idaapi.HPPA_pdtlb
HPPA_pdtlbe = _idaapi.HPPA_pdtlbe
HPPA_permh = _idaapi.HPPA_permh
HPPA_pitlb = _idaapi.HPPA_pitlb
HPPA_pitlbe = _idaapi.HPPA_pitlbe
HPPA_popbts = _idaapi.HPPA_popbts
HPPA_probe = _idaapi.HPPA_probe
HPPA_probei = _idaapi.HPPA_probei
HPPA_pushbts = _idaapi.HPPA_pushbts
HPPA_pushnom = _idaapi.HPPA_pushnom
HPPA_rfi = _idaapi.HPPA_rfi
HPPA_rsm = _idaapi.HPPA_rsm
HPPA_shladd = _idaapi.HPPA_shladd
HPPA_shrpd = _idaapi.HPPA_shrpd
HPPA_shrpw = _idaapi.HPPA_shrpw
HPPA_spop0 = _idaapi.HPPA_spop0
HPPA_spop1 = _idaapi.HPPA_spop1
HPPA_spop2 = _idaapi.HPPA_spop2
HPPA_spop3 = _idaapi.HPPA_spop3
HPPA_ssm = _idaapi.HPPA_ssm
HPPA_stb = _idaapi.HPPA_stb
HPPA_stby = _idaapi.HPPA_stby
HPPA_std = _idaapi.HPPA_std
HPPA_stda = _idaapi.HPPA_stda
HPPA_stdby = _idaapi.HPPA_stdby
HPPA_sth = _idaapi.HPPA_sth
HPPA_stw = _idaapi.HPPA_stw
HPPA_stwa = _idaapi.HPPA_stwa
HPPA_sub = _idaapi.HPPA_sub
HPPA_subi = _idaapi.HPPA_subi
HPPA_sync = _idaapi.HPPA_sync
HPPA_syncdma = _idaapi.HPPA_syncdma
HPPA_uaddcm = _idaapi.HPPA_uaddcm
HPPA_uxor = _idaapi.HPPA_uxor
HPPA_xor = _idaapi.HPPA_xor
HPPA_fabs = _idaapi.HPPA_fabs
HPPA_fadd = _idaapi.HPPA_fadd
HPPA_fcmp = _idaapi.HPPA_fcmp
HPPA_fcnv = _idaapi.HPPA_fcnv
HPPA_fcpy = _idaapi.HPPA_fcpy
HPPA_fdiv = _idaapi.HPPA_fdiv
HPPA_fid = _idaapi.HPPA_fid
HPPA_fldd = _idaapi.HPPA_fldd
HPPA_fldw = _idaapi.HPPA_fldw
HPPA_fmpy = _idaapi.HPPA_fmpy
HPPA_fmpyadd = _idaapi.HPPA_fmpyadd
HPPA_fmpyfadd = _idaapi.HPPA_fmpyfadd
HPPA_fmpynfadd = _idaapi.HPPA_fmpynfadd
HPPA_fmpysub = _idaapi.HPPA_fmpysub
HPPA_fneg = _idaapi.HPPA_fneg
HPPA_fnegabs = _idaapi.HPPA_fnegabs
HPPA_frem = _idaapi.HPPA_frem
HPPA_frnd = _idaapi.HPPA_frnd
HPPA_fsqrt = _idaapi.HPPA_fsqrt
HPPA_fstd = _idaapi.HPPA_fstd
HPPA_fstw = _idaapi.HPPA_fstw
HPPA_fsub = _idaapi.HPPA_fsub
HPPA_ftest = _idaapi.HPPA_ftest
HPPA_xmpyu = _idaapi.HPPA_xmpyu
HPPA_pmdis = _idaapi.HPPA_pmdis
HPPA_pmenb = _idaapi.HPPA_pmenb
HPPA_call = _idaapi.HPPA_call
HPPA_ret = _idaapi.HPPA_ret
HPPA_shld = _idaapi.HPPA_shld
HPPA_shlw = _idaapi.HPPA_shlw
HPPA_shrd = _idaapi.HPPA_shrd
HPPA_shrw = _idaapi.HPPA_shrw
HPPA_ldi = _idaapi.HPPA_ldi
HPPA_copy = _idaapi.HPPA_copy
HPPA_mtsar = _idaapi.HPPA_mtsar
HPPA_nop = _idaapi.HPPA_nop
HPPA_last = _idaapi.HPPA_last
H8500_null = _idaapi.H8500_null
H8500_mov_g = _idaapi.H8500_mov_g
H8500_mov_e = _idaapi.H8500_mov_e
H8500_mov_i = _idaapi.H8500_mov_i
H8500_mov_f = _idaapi.H8500_mov_f
H8500_mov_l = _idaapi.H8500_mov_l
H8500_mov_s = _idaapi.H8500_mov_s
H8500_ldm = _idaapi.H8500_ldm
H8500_stm = _idaapi.H8500_stm
H8500_xch = _idaapi.H8500_xch
H8500_swap = _idaapi.H8500_swap
H8500_movtpe = _idaapi.H8500_movtpe
H8500_movfpe = _idaapi.H8500_movfpe
H8500_add_g = _idaapi.H8500_add_g
H8500_add_q = _idaapi.H8500_add_q
H8500_sub = _idaapi.H8500_sub
H8500_adds = _idaapi.H8500_adds
H8500_subs = _idaapi.H8500_subs
H8500_addx = _idaapi.H8500_addx
H8500_subx = _idaapi.H8500_subx
H8500_dadd = _idaapi.H8500_dadd
H8500_dsub = _idaapi.H8500_dsub
H8500_mulxu = _idaapi.H8500_mulxu
H8500_divxu = _idaapi.H8500_divxu
H8500_cmp_g = _idaapi.H8500_cmp_g
H8500_cmp_e = _idaapi.H8500_cmp_e
H8500_cmp_i = _idaapi.H8500_cmp_i
H8500_exts = _idaapi.H8500_exts
H8500_extu = _idaapi.H8500_extu
H8500_tst = _idaapi.H8500_tst
H8500_neg = _idaapi.H8500_neg
H8500_clr = _idaapi.H8500_clr
H8500_tas = _idaapi.H8500_tas
H8500_and = _idaapi.H8500_and
H8500_or = _idaapi.H8500_or
H8500_xor = _idaapi.H8500_xor
H8500_not = _idaapi.H8500_not
H8500_shal = _idaapi.H8500_shal
H8500_shar = _idaapi.H8500_shar
H8500_shll = _idaapi.H8500_shll
H8500_shlr = _idaapi.H8500_shlr
H8500_rotl = _idaapi.H8500_rotl
H8500_rotr = _idaapi.H8500_rotr
H8500_rotxl = _idaapi.H8500_rotxl
H8500_rotxr = _idaapi.H8500_rotxr
H8500_bset = _idaapi.H8500_bset
H8500_bclr = _idaapi.H8500_bclr
H8500_bnot = _idaapi.H8500_bnot
H8500_btst = _idaapi.H8500_btst
H8500_bra = _idaapi.H8500_bra
H8500_brn = _idaapi.H8500_brn
H8500_bhi = _idaapi.H8500_bhi
H8500_bls = _idaapi.H8500_bls
H8500_bcc = _idaapi.H8500_bcc
H8500_bcs = _idaapi.H8500_bcs
H8500_bne = _idaapi.H8500_bne
H8500_beq = _idaapi.H8500_beq
H8500_bvc = _idaapi.H8500_bvc
H8500_bvs = _idaapi.H8500_bvs
H8500_bpl = _idaapi.H8500_bpl
H8500_bmi = _idaapi.H8500_bmi
H8500_bge = _idaapi.H8500_bge
H8500_blt = _idaapi.H8500_blt
H8500_bgt = _idaapi.H8500_bgt
H8500_ble = _idaapi.H8500_ble
H8500_jmp = _idaapi.H8500_jmp
H8500_pjmp = _idaapi.H8500_pjmp
H8500_bsr = _idaapi.H8500_bsr
H8500_jsr = _idaapi.H8500_jsr
H8500_pjsr = _idaapi.H8500_pjsr
H8500_rts = _idaapi.H8500_rts
H8500_prts = _idaapi.H8500_prts
H8500_rtd = _idaapi.H8500_rtd
H8500_prtd = _idaapi.H8500_prtd
H8500_scb = _idaapi.H8500_scb
H8500_trapa = _idaapi.H8500_trapa
H8500_trap_vs = _idaapi.H8500_trap_vs
H8500_rte = _idaapi.H8500_rte
H8500_link = _idaapi.H8500_link
H8500_unlk = _idaapi.H8500_unlk
H8500_sleep = _idaapi.H8500_sleep
H8500_ldc = _idaapi.H8500_ldc
H8500_stc = _idaapi.H8500_stc
H8500_andc = _idaapi.H8500_andc
H8500_orc = _idaapi.H8500_orc
H8500_xorc = _idaapi.H8500_xorc
H8500_nop = _idaapi.H8500_nop
H8500_bpt = _idaapi.H8500_bpt
H8500_last = _idaapi.H8500_last
DSP56_null = _idaapi.DSP56_null
DSP56_abs = _idaapi.DSP56_abs
DSP56_adc = _idaapi.DSP56_adc
DSP56_add = _idaapi.DSP56_add
DSP56_addl = _idaapi.DSP56_addl
DSP56_addr = _idaapi.DSP56_addr
DSP56_and = _idaapi.DSP56_and
DSP56_andi = _idaapi.DSP56_andi
DSP56_asl = _idaapi.DSP56_asl
DSP56_asl4 = _idaapi.DSP56_asl4
DSP56_asr = _idaapi.DSP56_asr
DSP56_asr4 = _idaapi.DSP56_asr4
DSP56_asr16 = _idaapi.DSP56_asr16
DSP56_bfchg = _idaapi.DSP56_bfchg
DSP56_bfclr = _idaapi.DSP56_bfclr
DSP56_bfset = _idaapi.DSP56_bfset
DSP56_bftsth = _idaapi.DSP56_bftsth
DSP56_bftstl = _idaapi.DSP56_bftstl
DSP56_bcc = _idaapi.DSP56_bcc
DSP56_bchg = _idaapi.DSP56_bchg
DSP56_bclr = _idaapi.DSP56_bclr
DSP56_bra = _idaapi.DSP56_bra
DSP56_brclr = _idaapi.DSP56_brclr
DSP56_brkcc = _idaapi.DSP56_brkcc
DSP56_brset = _idaapi.DSP56_brset
DSP56_bscc = _idaapi.DSP56_bscc
DSP56_bsclr = _idaapi.DSP56_bsclr
DSP56_bset = _idaapi.DSP56_bset
DSP56_bsr = _idaapi.DSP56_bsr
DSP56_bsset = _idaapi.DSP56_bsset
DSP56_btst = _idaapi.DSP56_btst
DSP56_chkaau = _idaapi.DSP56_chkaau
DSP56_clb = _idaapi.DSP56_clb
DSP56_clr = _idaapi.DSP56_clr
DSP56_clr24 = _idaapi.DSP56_clr24
DSP56_cmp = _idaapi.DSP56_cmp
DSP56_cmpm = _idaapi.DSP56_cmpm
DSP56_cmpu = _idaapi.DSP56_cmpu
DSP56_debug = _idaapi.DSP56_debug
DSP56_debugcc = _idaapi.DSP56_debugcc
DSP56_dec = _idaapi.DSP56_dec
DSP56_dec24 = _idaapi.DSP56_dec24
DSP56_div = _idaapi.DSP56_div
DSP56_dmac = _idaapi.DSP56_dmac
DSP56_do = _idaapi.DSP56_do
DSP56_do_f = _idaapi.DSP56_do_f
DSP56_dor = _idaapi.DSP56_dor
DSP56_dor_f = _idaapi.DSP56_dor_f
DSP56_enddo = _idaapi.DSP56_enddo
DSP56_eor = _idaapi.DSP56_eor
DSP56_extract = _idaapi.DSP56_extract
DSP56_extractu = _idaapi.DSP56_extractu
DSP56_ext = _idaapi.DSP56_ext
DSP56_ill = _idaapi.DSP56_ill
DSP56_imac = _idaapi.DSP56_imac
DSP56_impy = _idaapi.DSP56_impy
DSP56_inc = _idaapi.DSP56_inc
DSP56_inc24 = _idaapi.DSP56_inc24
DSP56_insert = _idaapi.DSP56_insert
DSP56_jcc = _idaapi.DSP56_jcc
DSP56_jclr = _idaapi.DSP56_jclr
DSP56_jmp = _idaapi.DSP56_jmp
DSP56_jscc = _idaapi.DSP56_jscc
DSP56_jsclr = _idaapi.DSP56_jsclr
DSP56_jset = _idaapi.DSP56_jset
DSP56_jsr = _idaapi.DSP56_jsr
DSP56_jsset = _idaapi.DSP56_jsset
DSP56_lra = _idaapi.DSP56_lra
DSP56_lsl = _idaapi.DSP56_lsl
DSP56_lsr = _idaapi.DSP56_lsr
DSP56_lua = _idaapi.DSP56_lua
DSP56_lea = _idaapi.DSP56_lea
DSP56_mac = _idaapi.DSP56_mac
DSP56_maci = _idaapi.DSP56_maci
DSP56_mac_s_u = _idaapi.DSP56_mac_s_u
DSP56_macr = _idaapi.DSP56_macr
DSP56_macri = _idaapi.DSP56_macri
DSP56_max = _idaapi.DSP56_max
DSP56_maxm = _idaapi.DSP56_maxm
DSP56_merge = _idaapi.DSP56_merge
DSP56_move = _idaapi.DSP56_move
DSP56_movec = _idaapi.DSP56_movec
DSP56_movei = _idaapi.DSP56_movei
DSP56_movem = _idaapi.DSP56_movem
DSP56_movep = _idaapi.DSP56_movep
DSP56_moves = _idaapi.DSP56_moves
DSP56_mpy = _idaapi.DSP56_mpy
DSP56_mpyi = _idaapi.DSP56_mpyi
DSP56_mpy_s_u = _idaapi.DSP56_mpy_s_u
DSP56_mpyr = _idaapi.DSP56_mpyr
DSP56_mpyri = _idaapi.DSP56_mpyri
DSP56_neg = _idaapi.DSP56_neg
DSP56_negc = _idaapi.DSP56_negc
DSP56_nop = _idaapi.DSP56_nop
DSP56_norm = _idaapi.DSP56_norm
DSP56_normf = _idaapi.DSP56_normf
DSP56_not = _idaapi.DSP56_not
DSP56_or = _idaapi.DSP56_or
DSP56_ori = _idaapi.DSP56_ori
DSP56_pflush = _idaapi.DSP56_pflush
DSP56_pflushun = _idaapi.DSP56_pflushun
DSP56_pfree = _idaapi.DSP56_pfree
DSP56_plock = _idaapi.DSP56_plock
DSP56_plockr = _idaapi.DSP56_plockr
DSP56_punlock = _idaapi.DSP56_punlock
DSP56_punlockr = _idaapi.DSP56_punlockr
DSP56_rep = _idaapi.DSP56_rep
DSP56_repcc = _idaapi.DSP56_repcc
DSP56_reset = _idaapi.DSP56_reset
DSP56_rnd = _idaapi.DSP56_rnd
DSP56_rol = _idaapi.DSP56_rol
DSP56_ror = _idaapi.DSP56_ror
DSP56_rti = _idaapi.DSP56_rti
DSP56_rts = _idaapi.DSP56_rts
DSP56_sbc = _idaapi.DSP56_sbc
DSP56_stop = _idaapi.DSP56_stop
DSP56_sub = _idaapi.DSP56_sub
DSP56_subl = _idaapi.DSP56_subl
DSP56_subr = _idaapi.DSP56_subr
DSP56_swap = _idaapi.DSP56_swap
DSP56_tcc = _idaapi.DSP56_tcc
DSP56_tfr = _idaapi.DSP56_tfr
DSP56_tfr2 = _idaapi.DSP56_tfr2
DSP56_tfr3 = _idaapi.DSP56_tfr3
DSP56_trap = _idaapi.DSP56_trap
DSP56_trapcc = _idaapi.DSP56_trapcc
DSP56_tst = _idaapi.DSP56_tst
DSP56_tst2 = _idaapi.DSP56_tst2
DSP56_vsl = _idaapi.DSP56_vsl
DSP56_wait = _idaapi.DSP56_wait
DSP56_zero = _idaapi.DSP56_zero
DSP56_swi = _idaapi.DSP56_swi
DSP56_pmov = _idaapi.DSP56_pmov
DSP56_last = _idaapi.DSP56_last
DSP96_null = _idaapi.DSP96_null
DSP96_abs = _idaapi.DSP96_abs
DSP96_add = _idaapi.DSP96_add
DSP96_addc = _idaapi.DSP96_addc
DSP96_and = _idaapi.DSP96_and
DSP96_andc = _idaapi.DSP96_andc
DSP96_andi = _idaapi.DSP96_andi
DSP96_asl = _idaapi.DSP96_asl
DSP96_asr = _idaapi.DSP96_asr
DSP96_bcc = _idaapi.DSP96_bcc
DSP96_bccd = _idaapi.DSP96_bccd
DSP96_bchg = _idaapi.DSP96_bchg
DSP96_bclr = _idaapi.DSP96_bclr
DSP96_bfind = _idaapi.DSP96_bfind
DSP96_bra = _idaapi.DSP96_bra
DSP96_brclr = _idaapi.DSP96_brclr
DSP96_brset = _idaapi.DSP96_brset
DSP96_bscc = _idaapi.DSP96_bscc
DSP96_bsccd = _idaapi.DSP96_bsccd
DSP96_bsclr = _idaapi.DSP96_bsclr
DSP96_bset = _idaapi.DSP96_bset
DSP96_bsr = _idaapi.DSP96_bsr
DSP96_bsrd = _idaapi.DSP96_bsrd
DSP96_bsset = _idaapi.DSP96_bsset
DSP96_btst = _idaapi.DSP96_btst
DSP96_clr = _idaapi.DSP96_clr
DSP96_cmp = _idaapi.DSP96_cmp
DSP96_cmpg = _idaapi.DSP96_cmpg
DSP96_debugcc = _idaapi.DSP96_debugcc
DSP96_dec = _idaapi.DSP96_dec
DSP96_do = _idaapi.DSP96_do
DSP96_dor = _idaapi.DSP96_dor
DSP96_enddo = _idaapi.DSP96_enddo
DSP96_eor = _idaapi.DSP96_eor
DSP96_ext = _idaapi.DSP96_ext
DSP96_extb = _idaapi.DSP96_extb
DSP96_fabs = _idaapi.DSP96_fabs
DSP96_fadd = _idaapi.DSP96_fadd
DSP96_faddsub = _idaapi.DSP96_faddsub
DSP96_fbcc = _idaapi.DSP96_fbcc
DSP96_fbccd = _idaapi.DSP96_fbccd
DSP96_fbscc = _idaapi.DSP96_fbscc
DSP96_fbsccd = _idaapi.DSP96_fbsccd
DSP96_fclr = _idaapi.DSP96_fclr
DSP96_fcmp = _idaapi.DSP96_fcmp
DSP96_fcmpg = _idaapi.DSP96_fcmpg
DSP96_fcmpm = _idaapi.DSP96_fcmpm
DSP96_fcopys = _idaapi.DSP96_fcopys
DSP96_fdebugcc = _idaapi.DSP96_fdebugcc
DSP96_fgetman = _idaapi.DSP96_fgetman
DSP96_fint = _idaapi.DSP96_fint
DSP96_fjcc = _idaapi.DSP96_fjcc
DSP96_fjccd = _idaapi.DSP96_fjccd
DSP96_fjscc = _idaapi.DSP96_fjscc
DSP96_fjsccd = _idaapi.DSP96_fjsccd
DSP96_float = _idaapi.DSP96_float
DSP96_floatu = _idaapi.DSP96_floatu
DSP96_floor = _idaapi.DSP96_floor
DSP96_fmove = _idaapi.DSP96_fmove
DSP96_fmpyfadd = _idaapi.DSP96_fmpyfadd
DSP96_fmpyfaddsub = _idaapi.DSP96_fmpyfaddsub
DSP96_fmpyfsub = _idaapi.DSP96_fmpyfsub
DSP96_fmpy = _idaapi.DSP96_fmpy
DSP96_fneg = _idaapi.DSP96_fneg
DSP96_fscale = _idaapi.DSP96_fscale
DSP96_fseedd = _idaapi.DSP96_fseedd
DSP96_fseedr = _idaapi.DSP96_fseedr
DSP96_fsub = _idaapi.DSP96_fsub
DSP96_ftfr = _idaapi.DSP96_ftfr
DSP96_ftrapcc = _idaapi.DSP96_ftrapcc
DSP96_ftst = _idaapi.DSP96_ftst
DSP96_getexp = _idaapi.DSP96_getexp
DSP96_illegal = _idaapi.DSP96_illegal
DSP96_inc = _idaapi.DSP96_inc
DSP96_int = _idaapi.DSP96_int
DSP96_intrz = _idaapi.DSP96_intrz
DSP96_intu = _idaapi.DSP96_intu
DSP96_inturz = _idaapi.DSP96_inturz
DSP96_jcc = _idaapi.DSP96_jcc
DSP96_jccd = _idaapi.DSP96_jccd
DSP96_jclr = _idaapi.DSP96_jclr
DSP96_join = _idaapi.DSP96_join
DSP96_joinb = _idaapi.DSP96_joinb
DSP96_jscc = _idaapi.DSP96_jscc
DSP96_jsccd = _idaapi.DSP96_jsccd
DSP96_jsclr = _idaapi.DSP96_jsclr
DSP96_jset = _idaapi.DSP96_jset
DSP96_jsset = _idaapi.DSP96_jsset
DSP96_lea = _idaapi.DSP96_lea
DSP96_lra = _idaapi.DSP96_lra
DSP96_lsl = _idaapi.DSP96_lsl
DSP96_lsr = _idaapi.DSP96_lsr
DSP96_move = _idaapi.DSP96_move
DSP96_movec = _idaapi.DSP96_movec
DSP96_movei = _idaapi.DSP96_movei
DSP96_movem = _idaapi.DSP96_movem
DSP96_movep = _idaapi.DSP96_movep
DSP96_moves = _idaapi.DSP96_moves
DSP96_moveta = _idaapi.DSP96_moveta
DSP96_mpys = _idaapi.DSP96_mpys
DSP96_mpyu = _idaapi.DSP96_mpyu
DSP96_neg = _idaapi.DSP96_neg
DSP96_negc = _idaapi.DSP96_negc
DSP96_nop = _idaapi.DSP96_nop
DSP96_not = _idaapi.DSP96_not
DSP96_or = _idaapi.DSP96_or
DSP96_orc = _idaapi.DSP96_orc
DSP96_ori = _idaapi.DSP96_ori
DSP96_rep = _idaapi.DSP96_rep
DSP96_reset = _idaapi.DSP96_reset
DSP96_rol = _idaapi.DSP96_rol
DSP96_ror = _idaapi.DSP96_ror
DSP96_rti = _idaapi.DSP96_rti
DSP96_rtr = _idaapi.DSP96_rtr
DSP96_rts = _idaapi.DSP96_rts
DSP96_setw = _idaapi.DSP96_setw
DSP96_split = _idaapi.DSP96_split
DSP96_splitb = _idaapi.DSP96_splitb
DSP96_stop = _idaapi.DSP96_stop
DSP96_sub = _idaapi.DSP96_sub
DSP96_subc = _idaapi.DSP96_subc
DSP96_tfr = _idaapi.DSP96_tfr
DSP96_trapcc = _idaapi.DSP96_trapcc
DSP96_tst = _idaapi.DSP96_tst
DSP96_wait = _idaapi.DSP96_wait
DSP96_last = _idaapi.DSP96_last
PM96_NoMove = _idaapi.PM96_NoMove
PM96_R2R = _idaapi.PM96_R2R
PM96_Update = _idaapi.PM96_Update
PM96_XYMem = _idaapi.PM96_XYMem
PM96_XYmemR = _idaapi.PM96_XYmemR
PM96_Long = _idaapi.PM96_Long
PM96_XY = _idaapi.PM96_XY
PM96_IFcc = _idaapi.PM96_IFcc
C166_null = _idaapi.C166_null
C166_add = _idaapi.C166_add
C166_addb = _idaapi.C166_addb
C166_addc = _idaapi.C166_addc
C166_addcb = _idaapi.C166_addcb
C166_and = _idaapi.C166_and
C166_andb = _idaapi.C166_andb
C166_ashr = _idaapi.C166_ashr
C166_atomic = _idaapi.C166_atomic
C166_band = _idaapi.C166_band
C166_bclr = _idaapi.C166_bclr
C166_bcmp = _idaapi.C166_bcmp
C166_bfldh = _idaapi.C166_bfldh
C166_bfldl = _idaapi.C166_bfldl
C166_bmov = _idaapi.C166_bmov
C166_bmovn = _idaapi.C166_bmovn
C166_bor = _idaapi.C166_bor
C166_bset = _idaapi.C166_bset
C166_bxor = _idaapi.C166_bxor
C166_calla = _idaapi.C166_calla
C166_calli = _idaapi.C166_calli
C166_callr = _idaapi.C166_callr
C166_calls = _idaapi.C166_calls
C166_cmp = _idaapi.C166_cmp
C166_cmpb = _idaapi.C166_cmpb
C166_cmpd1 = _idaapi.C166_cmpd1
C166_cmpd2 = _idaapi.C166_cmpd2
C166_cmpi1 = _idaapi.C166_cmpi1
C166_cmpi2 = _idaapi.C166_cmpi2
C166_cpl = _idaapi.C166_cpl
C166_cplb = _idaapi.C166_cplb
C166_diswdt = _idaapi.C166_diswdt
C166_div = _idaapi.C166_div
C166_divl = _idaapi.C166_divl
C166_divlu = _idaapi.C166_divlu
C166_divu = _idaapi.C166_divu
C166_einit = _idaapi.C166_einit
C166_extr = _idaapi.C166_extr
C166_extp = _idaapi.C166_extp
C166_extpr = _idaapi.C166_extpr
C166_exts = _idaapi.C166_exts
C166_extsr = _idaapi.C166_extsr
C166_idle = _idaapi.C166_idle
C166_jb = _idaapi.C166_jb
C166_jbc = _idaapi.C166_jbc
C166_jmpa = _idaapi.C166_jmpa
C166_jmpi = _idaapi.C166_jmpi
C166_jmpr = _idaapi.C166_jmpr
C166_jmps = _idaapi.C166_jmps
C166_jnb = _idaapi.C166_jnb
C166_jnbs = _idaapi.C166_jnbs
C166_mov = _idaapi.C166_mov
C166_movb = _idaapi.C166_movb
C166_movbs = _idaapi.C166_movbs
C166_movbz = _idaapi.C166_movbz
C166_mul = _idaapi.C166_mul
C166_mulu = _idaapi.C166_mulu
C166_neg = _idaapi.C166_neg
C166_negb = _idaapi.C166_negb
C166_nop = _idaapi.C166_nop
C166_or = _idaapi.C166_or
C166_orb = _idaapi.C166_orb
C166_pcall = _idaapi.C166_pcall
C166_pop = _idaapi.C166_pop
C166_prior = _idaapi.C166_prior
C166_push = _idaapi.C166_push
C166_pwrdn = _idaapi.C166_pwrdn
C166_ret = _idaapi.C166_ret
C166_reti = _idaapi.C166_reti
C166_retp = _idaapi.C166_retp
C166_rets = _idaapi.C166_rets
C166_rol = _idaapi.C166_rol
C166_ror = _idaapi.C166_ror
C166_scxt = _idaapi.C166_scxt
C166_shl = _idaapi.C166_shl
C166_shr = _idaapi.C166_shr
C166_srst = _idaapi.C166_srst
C166_srvwdt = _idaapi.C166_srvwdt
C166_sub = _idaapi.C166_sub
C166_subb = _idaapi.C166_subb
C166_subc = _idaapi.C166_subc
C166_subcb = _idaapi.C166_subcb
C166_trap = _idaapi.C166_trap
C166_xor = _idaapi.C166_xor
C166_xorb = _idaapi.C166_xorb
ST10_CoABS = _idaapi.ST10_CoABS
ST10_CoADD = _idaapi.ST10_CoADD
ST10_CoASHR = _idaapi.ST10_CoASHR
ST10_CoCMP = _idaapi.ST10_CoCMP
ST10_CoLOAD = _idaapi.ST10_CoLOAD
ST10_CoMAC = _idaapi.ST10_CoMAC
ST10_CoMACM = _idaapi.ST10_CoMACM
ST10_CoMAX = _idaapi.ST10_CoMAX
ST10_CoMIN = _idaapi.ST10_CoMIN
ST10_CoMOV = _idaapi.ST10_CoMOV
ST10_CoMUL = _idaapi.ST10_CoMUL
ST10_CoNEG = _idaapi.ST10_CoNEG
ST10_CoNOP = _idaapi.ST10_CoNOP
ST10_CoRND = _idaapi.ST10_CoRND
ST10_CoSHL = _idaapi.ST10_CoSHL
ST10_CoSHR = _idaapi.ST10_CoSHR
ST10_CoSTORE = _idaapi.ST10_CoSTORE
ST10_CoSUB = _idaapi.ST10_CoSUB
C166_enwdt = _idaapi.C166_enwdt
C166_sbrk = _idaapi.C166_sbrk
C166_last = _idaapi.C166_last
ST20_null = _idaapi.ST20_null
ST20_adc = _idaapi.ST20_adc
ST20_add = _idaapi.ST20_add
ST20_addc = _idaapi.ST20_addc
ST20_ajw = _idaapi.ST20_ajw
ST20_and = _idaapi.ST20_and
ST20_arot = _idaapi.ST20_arot
ST20_ashr = _idaapi.ST20_ashr
ST20_biquad = _idaapi.ST20_biquad
ST20_bitld = _idaapi.ST20_bitld
ST20_bitmask = _idaapi.ST20_bitmask
ST20_bitst = _idaapi.ST20_bitst
ST20_breakpoint = _idaapi.ST20_breakpoint
ST20_cj = _idaapi.ST20_cj
ST20_dequeue = _idaapi.ST20_dequeue
ST20_divstep = _idaapi.ST20_divstep
ST20_dup = _idaapi.ST20_dup
ST20_ecall = _idaapi.ST20_ecall
ST20_enqueue = _idaapi.ST20_enqueue
ST20_eqc = _idaapi.ST20_eqc
ST20_eret = _idaapi.ST20_eret
ST20_fcall = _idaapi.ST20_fcall
ST20_gajw = _idaapi.ST20_gajw
ST20_gt = _idaapi.ST20_gt
ST20_gtu = _idaapi.ST20_gtu
ST20_io = _idaapi.ST20_io
ST20_j = _idaapi.ST20_j
ST20_jab = _idaapi.ST20_jab
ST20_lbinc = _idaapi.ST20_lbinc
ST20_ldc = _idaapi.ST20_ldc
ST20_ldl = _idaapi.ST20_ldl
ST20_ldlp = _idaapi.ST20_ldlp
ST20_ldnl = _idaapi.ST20_ldnl
ST20_ldnlp = _idaapi.ST20_ldnlp
ST20_ldpi = _idaapi.ST20_ldpi
ST20_ldprodid = _idaapi.ST20_ldprodid
ST20_ldtdesc = _idaapi.ST20_ldtdesc
ST20_lsinc = _idaapi.ST20_lsinc
ST20_lsxinc = _idaapi.ST20_lsxinc
ST20_lwinc = _idaapi.ST20_lwinc
ST20_mac = _idaapi.ST20_mac
ST20_mul = _idaapi.ST20_mul
ST20_nfix = _idaapi.ST20_nfix
ST20_nop = _idaapi.ST20_nop
ST20_not = _idaapi.ST20_not
ST20_opr = _idaapi.ST20_opr
ST20_or = _idaapi.ST20_or
ST20_order = _idaapi.ST20_order
ST20_orderu = _idaapi.ST20_orderu
ST20_pfix = _idaapi.ST20_pfix
ST20_rev = _idaapi.ST20_rev
ST20_rmw = _idaapi.ST20_rmw
ST20_rot = _idaapi.ST20_rot
ST20_run = _idaapi.ST20_run
ST20_saturate = _idaapi.ST20_saturate
ST20_sbinc = _idaapi.ST20_sbinc
ST20_shl = _idaapi.ST20_shl
ST20_shr = _idaapi.ST20_shr
ST20_signal = _idaapi.ST20_signal
ST20_smacinit = _idaapi.ST20_smacinit
ST20_smacloop = _idaapi.ST20_smacloop
ST20_smul = _idaapi.ST20_smul
ST20_ssinc = _idaapi.ST20_ssinc
ST20_statusclr = _idaapi.ST20_statusclr
ST20_statusset = _idaapi.ST20_statusset
ST20_statustst = _idaapi.ST20_statustst
ST20_stl = _idaapi.ST20_stl
ST20_stnl = _idaapi.ST20_stnl
ST20_stop = _idaapi.ST20_stop
ST20_sub = _idaapi.ST20_sub
ST20_subc = _idaapi.ST20_subc
ST20_swap32 = _idaapi.ST20_swap32
ST20_swinc = _idaapi.ST20_swinc
ST20_timeslice = _idaapi.ST20_timeslice
ST20_umac = _idaapi.ST20_umac
ST20_unsign = _idaapi.ST20_unsign
ST20_wait = _idaapi.ST20_wait
ST20_wsub = _idaapi.ST20_wsub
ST20_xbword = _idaapi.ST20_xbword
ST20_xor = _idaapi.ST20_xor
ST20_xsword = _idaapi.ST20_xsword
ST20_alt = _idaapi.ST20_alt
ST20_altend = _idaapi.ST20_altend
ST20_altwt = _idaapi.ST20_altwt
ST20_bcnt = _idaapi.ST20_bcnt
ST20_bitcnt = _idaapi.ST20_bitcnt
ST20_bitrevnbits = _idaapi.ST20_bitrevnbits
ST20_bitrevword = _idaapi.ST20_bitrevword
ST20_bsub = _idaapi.ST20_bsub
ST20_call = _idaapi.ST20_call
ST20_causeerror = _idaapi.ST20_causeerror
ST20_cb = _idaapi.ST20_cb
ST20_cbu = _idaapi.ST20_cbu
ST20_ccnt1 = _idaapi.ST20_ccnt1
ST20_cflerr = _idaapi.ST20_cflerr
ST20_cir = _idaapi.ST20_cir
ST20_ciru = _idaapi.ST20_ciru
ST20_clockdis = _idaapi.ST20_clockdis
ST20_clockenb = _idaapi.ST20_clockenb
ST20_clrhalterr = _idaapi.ST20_clrhalterr
ST20_crcbyte = _idaapi.ST20_crcbyte
ST20_crcword = _idaapi.ST20_crcword
ST20_cs = _idaapi.ST20_cs
ST20_csngl = _idaapi.ST20_csngl
ST20_csu = _idaapi.ST20_csu
ST20_csub0 = _idaapi.ST20_csub0
ST20_cword = _idaapi.ST20_cword
ST20_devlb = _idaapi.ST20_devlb
ST20_devls = _idaapi.ST20_devls
ST20_devlw = _idaapi.ST20_devlw
ST20_devmove = _idaapi.ST20_devmove
ST20_devsb = _idaapi.ST20_devsb
ST20_devss = _idaapi.ST20_devss
ST20_devsw = _idaapi.ST20_devsw
ST20_diff = _idaapi.ST20_diff
ST20_disc = _idaapi.ST20_disc
ST20_diss = _idaapi.ST20_diss
ST20_dist = _idaapi.ST20_dist
ST20_div = _idaapi.ST20_div
ST20_enbc = _idaapi.ST20_enbc
ST20_enbs = _idaapi.ST20_enbs
ST20_enbt = _idaapi.ST20_enbt
ST20_endp = _idaapi.ST20_endp
ST20_fmul = _idaapi.ST20_fmul
ST20_fptesterr = _idaapi.ST20_fptesterr
ST20_gcall = _idaapi.ST20_gcall
ST20_gintdis = _idaapi.ST20_gintdis
ST20_gintenb = _idaapi.ST20_gintenb
ST20_in = _idaapi.ST20_in
ST20_insertqueue = _idaapi.ST20_insertqueue
ST20_intdis = _idaapi.ST20_intdis
ST20_intenb = _idaapi.ST20_intenb
ST20_iret = _idaapi.ST20_iret
ST20_ladd = _idaapi.ST20_ladd
ST20_lb = _idaapi.ST20_lb
ST20_lbx = _idaapi.ST20_lbx
ST20_ldclock = _idaapi.ST20_ldclock
ST20_lddevid = _idaapi.ST20_lddevid
ST20_ldiff = _idaapi.ST20_ldiff
ST20_ldinf = _idaapi.ST20_ldinf
ST20_ldiv = _idaapi.ST20_ldiv
ST20_ldmemstartval = _idaapi.ST20_ldmemstartval
ST20_ldpri = _idaapi.ST20_ldpri
ST20_ldshadow = _idaapi.ST20_ldshadow
ST20_ldtimer = _idaapi.ST20_ldtimer
ST20_ldtraph = _idaapi.ST20_ldtraph
ST20_ldtrapped = _idaapi.ST20_ldtrapped
ST20_lend = _idaapi.ST20_lend
ST20_lmul = _idaapi.ST20_lmul
ST20_ls = _idaapi.ST20_ls
ST20_lshl = _idaapi.ST20_lshl
ST20_lshr = _idaapi.ST20_lshr
ST20_lsub = _idaapi.ST20_lsub
ST20_lsum = _idaapi.ST20_lsum
ST20_lsx = _idaapi.ST20_lsx
ST20_mint = _idaapi.ST20_mint
ST20_move = _idaapi.ST20_move
ST20_move2dall = _idaapi.ST20_move2dall
ST20_move2dinit = _idaapi.ST20_move2dinit
ST20_move2dnonzero = _idaapi.ST20_move2dnonzero
ST20_move2dzero = _idaapi.ST20_move2dzero
ST20_norm = _idaapi.ST20_norm
ST20_out = _idaapi.ST20_out
ST20_outbyte = _idaapi.ST20_outbyte
ST20_outword = _idaapi.ST20_outword
ST20_pop = _idaapi.ST20_pop
ST20_postnormsn = _idaapi.ST20_postnormsn
ST20_prod = _idaapi.ST20_prod
ST20_reboot = _idaapi.ST20_reboot
ST20_rem = _idaapi.ST20_rem
ST20_resetch = _idaapi.ST20_resetch
ST20_restart = _idaapi.ST20_restart
ST20_ret = _idaapi.ST20_ret
ST20_roundsn = _idaapi.ST20_roundsn
ST20_runp = _idaapi.ST20_runp
ST20_satadd = _idaapi.ST20_satadd
ST20_satmul = _idaapi.ST20_satmul
ST20_satsub = _idaapi.ST20_satsub
ST20_saveh = _idaapi.ST20_saveh
ST20_savel = _idaapi.ST20_savel
ST20_sb = _idaapi.ST20_sb
ST20_seterr = _idaapi.ST20_seterr
ST20_sethalterr = _idaapi.ST20_sethalterr
ST20_settimeslice = _idaapi.ST20_settimeslice
ST20_slmul = _idaapi.ST20_slmul
ST20_ss = _idaapi.ST20_ss
ST20_ssub = _idaapi.ST20_ssub
ST20_startp = _idaapi.ST20_startp
ST20_stclock = _idaapi.ST20_stclock
ST20_sthb = _idaapi.ST20_sthb
ST20_sthf = _idaapi.ST20_sthf
ST20_stlb = _idaapi.ST20_stlb
ST20_stlf = _idaapi.ST20_stlf
ST20_stoperr = _idaapi.ST20_stoperr
ST20_stopp = _idaapi.ST20_stopp
ST20_stshadow = _idaapi.ST20_stshadow
ST20_sttimer = _idaapi.ST20_sttimer
ST20_sttraph = _idaapi.ST20_sttraph
ST20_sttrapped = _idaapi.ST20_sttrapped
ST20_sulmul = _idaapi.ST20_sulmul
ST20_sum = _idaapi.ST20_sum
ST20_swapqueue = _idaapi.ST20_swapqueue
ST20_swaptimer = _idaapi.ST20_swaptimer
ST20_talt = _idaapi.ST20_talt
ST20_taltwt = _idaapi.ST20_taltwt
ST20_testerr = _idaapi.ST20_testerr
ST20_testhalterr = _idaapi.ST20_testhalterr
ST20_testpranal = _idaapi.ST20_testpranal
ST20_tin = _idaapi.ST20_tin
ST20_trapdis = _idaapi.ST20_trapdis
ST20_trapenb = _idaapi.ST20_trapenb
ST20_tret = _idaapi.ST20_tret
ST20_unpacksn = _idaapi.ST20_unpacksn
ST20_wcnt = _idaapi.ST20_wcnt
ST20_wsubdb = _idaapi.ST20_wsubdb
ST20_xdble = _idaapi.ST20_xdble
ST20_xword = _idaapi.ST20_xword
ST20_last = _idaapi.ST20_last
ST7_null = _idaapi.ST7_null
ST7_adc = _idaapi.ST7_adc
ST7_add = _idaapi.ST7_add
ST7_and = _idaapi.ST7_and
ST7_bcp = _idaapi.ST7_bcp
ST7_bres = _idaapi.ST7_bres
ST7_bset = _idaapi.ST7_bset
ST7_btjf = _idaapi.ST7_btjf
ST7_btjt = _idaapi.ST7_btjt
ST7_call = _idaapi.ST7_call
ST7_callr = _idaapi.ST7_callr
ST7_clr = _idaapi.ST7_clr
ST7_cp = _idaapi.ST7_cp
ST7_cpl = _idaapi.ST7_cpl
ST7_dec = _idaapi.ST7_dec
ST7_halt = _idaapi.ST7_halt
ST7_iret = _idaapi.ST7_iret
ST7_inc = _idaapi.ST7_inc
ST7_jp = _idaapi.ST7_jp
ST7_jra = _idaapi.ST7_jra
ST7_jrt = _idaapi.ST7_jrt
ST7_jrf = _idaapi.ST7_jrf
ST7_jrih = _idaapi.ST7_jrih
ST7_jril = _idaapi.ST7_jril
ST7_jrh = _idaapi.ST7_jrh
ST7_jrnh = _idaapi.ST7_jrnh
ST7_jrm = _idaapi.ST7_jrm
ST7_jrnm = _idaapi.ST7_jrnm
ST7_jrmi = _idaapi.ST7_jrmi
ST7_jrpl = _idaapi.ST7_jrpl
ST7_jreq = _idaapi.ST7_jreq
ST7_jrne = _idaapi.ST7_jrne
ST7_jrc = _idaapi.ST7_jrc
ST7_jrnc = _idaapi.ST7_jrnc
ST7_jrult = _idaapi.ST7_jrult
ST7_jruge = _idaapi.ST7_jruge
ST7_jrugt = _idaapi.ST7_jrugt
ST7_jrule = _idaapi.ST7_jrule
ST7_ld = _idaapi.ST7_ld
ST7_mul = _idaapi.ST7_mul
ST7_neg = _idaapi.ST7_neg
ST7_nop = _idaapi.ST7_nop
ST7_or = _idaapi.ST7_or
ST7_pop = _idaapi.ST7_pop
ST7_push = _idaapi.ST7_push
ST7_rcf = _idaapi.ST7_rcf
ST7_ret = _idaapi.ST7_ret
ST7_rim = _idaapi.ST7_rim
ST7_rlc = _idaapi.ST7_rlc
ST7_rrc = _idaapi.ST7_rrc
ST7_rsp = _idaapi.ST7_rsp
ST7_sbc = _idaapi.ST7_sbc
ST7_scf = _idaapi.ST7_scf
ST7_sim = _idaapi.ST7_sim
ST7_sla = _idaapi.ST7_sla
ST7_sll = _idaapi.ST7_sll
ST7_srl = _idaapi.ST7_srl
ST7_sra = _idaapi.ST7_sra
ST7_sub = _idaapi.ST7_sub
ST7_swap = _idaapi.ST7_swap
ST7_tnz = _idaapi.ST7_tnz
ST7_trap = _idaapi.ST7_trap
ST7_wfi = _idaapi.ST7_wfi
ST7_xor = _idaapi.ST7_xor
ST7_last = _idaapi.ST7_last
IA64_null = _idaapi.IA64_null
IA64_0 = _idaapi.IA64_0
IA64_1 = _idaapi.IA64_1
IA64_a = _idaapi.IA64_a
IA64_acq = _idaapi.IA64_acq
IA64_add = _idaapi.IA64_add
IA64_addl = _idaapi.IA64_addl
IA64_addp4 = _idaapi.IA64_addp4
IA64_adds = _idaapi.IA64_adds
IA64_alloc = _idaapi.IA64_alloc
IA64_and = _idaapi.IA64_and
IA64_andcm = _idaapi.IA64_andcm
IA64_b = _idaapi.IA64_b
IA64_bias = _idaapi.IA64_bias
IA64_br = _idaapi.IA64_br
IA64_break = _idaapi.IA64_break
IA64_brl = _idaapi.IA64_brl
IA64_brp = _idaapi.IA64_brp
IA64_bsw = _idaapi.IA64_bsw
IA64_c = _idaapi.IA64_c
IA64_call = _idaapi.IA64_call
IA64_cexit = _idaapi.IA64_cexit
IA64_chk = _idaapi.IA64_chk
IA64_cloop = _idaapi.IA64_cloop
IA64_clr = _idaapi.IA64_clr
IA64_clrrrb = _idaapi.IA64_clrrrb
IA64_cmp = _idaapi.IA64_cmp
IA64_cmp4 = _idaapi.IA64_cmp4
IA64_cmpxchg1 = _idaapi.IA64_cmpxchg1
IA64_cmpxchg2 = _idaapi.IA64_cmpxchg2
IA64_cmpxchg4 = _idaapi.IA64_cmpxchg4
IA64_cmpxchg8 = _idaapi.IA64_cmpxchg8
IA64_cond = _idaapi.IA64_cond
IA64_cover = _idaapi.IA64_cover
IA64_ctop = _idaapi.IA64_ctop
IA64_czx1 = _idaapi.IA64_czx1
IA64_czx2 = _idaapi.IA64_czx2
IA64_d = _idaapi.IA64_d
IA64_dep = _idaapi.IA64_dep
IA64_dpnt = _idaapi.IA64_dpnt
IA64_dptk = _idaapi.IA64_dptk
IA64_e = _idaapi.IA64_e
IA64_epc = _idaapi.IA64_epc
IA64_eq = _idaapi.IA64_eq
IA64_excl = _idaapi.IA64_excl
IA64_exit = _idaapi.IA64_exit
IA64_exp = _idaapi.IA64_exp
IA64_extr = _idaapi.IA64_extr
IA64_f = _idaapi.IA64_f
IA64_fabs = _idaapi.IA64_fabs
IA64_fadd = _idaapi.IA64_fadd
IA64_famax = _idaapi.IA64_famax
IA64_famin = _idaapi.IA64_famin
IA64_fand = _idaapi.IA64_fand
IA64_fandcm = _idaapi.IA64_fandcm
IA64_fault = _idaapi.IA64_fault
IA64_fc = _idaapi.IA64_fc
IA64_fchkf = _idaapi.IA64_fchkf
IA64_fclass = _idaapi.IA64_fclass
IA64_fclrf = _idaapi.IA64_fclrf
IA64_fcmp = _idaapi.IA64_fcmp
IA64_fcvt = _idaapi.IA64_fcvt
IA64_fetchadd4 = _idaapi.IA64_fetchadd4
IA64_fetchadd8 = _idaapi.IA64_fetchadd8
IA64_few = _idaapi.IA64_few
IA64_fill = _idaapi.IA64_fill
IA64_flushrs = _idaapi.IA64_flushrs
IA64_fma = _idaapi.IA64_fma
IA64_fmax = _idaapi.IA64_fmax
IA64_fmerge = _idaapi.IA64_fmerge
IA64_fmin = _idaapi.IA64_fmin
IA64_fmix = _idaapi.IA64_fmix
IA64_fmpy = _idaapi.IA64_fmpy
IA64_fms = _idaapi.IA64_fms
IA64_fneg = _idaapi.IA64_fneg
IA64_fnegabs = _idaapi.IA64_fnegabs
IA64_fnma = _idaapi.IA64_fnma
IA64_fnmpy = _idaapi.IA64_fnmpy
IA64_fnorm = _idaapi.IA64_fnorm
IA64_for = _idaapi.IA64_for
IA64_fpabs = _idaapi.IA64_fpabs
IA64_fpack = _idaapi.IA64_fpack
IA64_fpamax = _idaapi.IA64_fpamax
IA64_fpamin = _idaapi.IA64_fpamin
IA64_fpcmp = _idaapi.IA64_fpcmp
IA64_fpcvt = _idaapi.IA64_fpcvt
IA64_fpma = _idaapi.IA64_fpma
IA64_fpmax = _idaapi.IA64_fpmax
IA64_fpmerge = _idaapi.IA64_fpmerge
IA64_fpmin = _idaapi.IA64_fpmin
IA64_fpmpy = _idaapi.IA64_fpmpy
IA64_fpms = _idaapi.IA64_fpms
IA64_fpneg = _idaapi.IA64_fpneg
IA64_fpnegabs = _idaapi.IA64_fpnegabs
IA64_fpnma = _idaapi.IA64_fpnma
IA64_fpnmpy = _idaapi.IA64_fpnmpy
IA64_fprcpa = _idaapi.IA64_fprcpa
IA64_fprsqrta = _idaapi.IA64_fprsqrta
IA64_frcpa = _idaapi.IA64_frcpa
IA64_frsqrta = _idaapi.IA64_frsqrta
IA64_fselect = _idaapi.IA64_fselect
IA64_fsetc = _idaapi.IA64_fsetc
IA64_fsub = _idaapi.IA64_fsub
IA64_fswap = _idaapi.IA64_fswap
IA64_fsxt = _idaapi.IA64_fsxt
IA64_fwb = _idaapi.IA64_fwb
IA64_fx = _idaapi.IA64_fx
IA64_fxor = _idaapi.IA64_fxor
IA64_fxu = _idaapi.IA64_fxu
IA64_g = _idaapi.IA64_g
IA64_ga = _idaapi.IA64_ga
IA64_ge = _idaapi.IA64_ge
IA64_getf = _idaapi.IA64_getf
IA64_geu = _idaapi.IA64_geu
IA64_gt = _idaapi.IA64_gt
IA64_gtu = _idaapi.IA64_gtu
IA64_h = _idaapi.IA64_h
IA64_hu = _idaapi.IA64_hu
IA64_i = _idaapi.IA64_i
IA64_ia = _idaapi.IA64_ia
IA64_imp = _idaapi.IA64_imp
IA64_invala = _idaapi.IA64_invala
IA64_itc = _idaapi.IA64_itc
IA64_itr = _idaapi.IA64_itr
IA64_l = _idaapi.IA64_l
IA64_ld1 = _idaapi.IA64_ld1
IA64_ld2 = _idaapi.IA64_ld2
IA64_ld4 = _idaapi.IA64_ld4
IA64_ld8 = _idaapi.IA64_ld8
IA64_ldf = _idaapi.IA64_ldf
IA64_ldf8 = _idaapi.IA64_ldf8
IA64_ldfd = _idaapi.IA64_ldfd
IA64_ldfe = _idaapi.IA64_ldfe
IA64_ldfp8 = _idaapi.IA64_ldfp8
IA64_ldfpd = _idaapi.IA64_ldfpd
IA64_ldfps = _idaapi.IA64_ldfps
IA64_ldfs = _idaapi.IA64_ldfs
IA64_le = _idaapi.IA64_le
IA64_leu = _idaapi.IA64_leu
IA64_lfetch = _idaapi.IA64_lfetch
IA64_loadrs = _idaapi.IA64_loadrs
IA64_loop = _idaapi.IA64_loop
IA64_lr = _idaapi.IA64_lr
IA64_lt = _idaapi.IA64_lt
IA64_ltu = _idaapi.IA64_ltu
IA64_lu = _idaapi.IA64_lu
IA64_m = _idaapi.IA64_m
IA64_many = _idaapi.IA64_many
IA64_mf = _idaapi.IA64_mf
IA64_mix1 = _idaapi.IA64_mix1
IA64_mix2 = _idaapi.IA64_mix2
IA64_mix4 = _idaapi.IA64_mix4
IA64_mov = _idaapi.IA64_mov
IA64_movl = _idaapi.IA64_movl
IA64_mux1 = _idaapi.IA64_mux1
IA64_mux2 = _idaapi.IA64_mux2
IA64_nc = _idaapi.IA64_nc
IA64_ne = _idaapi.IA64_ne
IA64_neq = _idaapi.IA64_neq
IA64_nge = _idaapi.IA64_nge
IA64_ngt = _idaapi.IA64_ngt
IA64_nl = _idaapi.IA64_nl
IA64_nle = _idaapi.IA64_nle
IA64_nlt = _idaapi.IA64_nlt
IA64_nm = _idaapi.IA64_nm
IA64_nop = _idaapi.IA64_nop
IA64_nr = _idaapi.IA64_nr
IA64_ns = _idaapi.IA64_ns
IA64_nt1 = _idaapi.IA64_nt1
IA64_nt2 = _idaapi.IA64_nt2
IA64_nta = _idaapi.IA64_nta
IA64_nz = _idaapi.IA64_nz
IA64_or = _idaapi.IA64_or
IA64_orcm = _idaapi.IA64_orcm
IA64_ord = _idaapi.IA64_ord
IA64_pack2 = _idaapi.IA64_pack2
IA64_pack4 = _idaapi.IA64_pack4
IA64_padd1 = _idaapi.IA64_padd1
IA64_padd2 = _idaapi.IA64_padd2
IA64_padd4 = _idaapi.IA64_padd4
IA64_pavg1 = _idaapi.IA64_pavg1
IA64_pavg2 = _idaapi.IA64_pavg2
IA64_pavgsub1 = _idaapi.IA64_pavgsub1
IA64_pavgsub2 = _idaapi.IA64_pavgsub2
IA64_pcmp1 = _idaapi.IA64_pcmp1
IA64_pcmp2 = _idaapi.IA64_pcmp2
IA64_pcmp4 = _idaapi.IA64_pcmp4
IA64_pmax1 = _idaapi.IA64_pmax1
IA64_pmax2 = _idaapi.IA64_pmax2
IA64_pmin1 = _idaapi.IA64_pmin1
IA64_pmin2 = _idaapi.IA64_pmin2
IA64_pmpy2 = _idaapi.IA64_pmpy2
IA64_pmpyshr2 = _idaapi.IA64_pmpyshr2
IA64_popcnt = _idaapi.IA64_popcnt
IA64_pr = _idaapi.IA64_pr
IA64_probe = _idaapi.IA64_probe
IA64_psad1 = _idaapi.IA64_psad1
IA64_pshl2 = _idaapi.IA64_pshl2
IA64_pshl4 = _idaapi.IA64_pshl4
IA64_pshladd2 = _idaapi.IA64_pshladd2
IA64_pshr2 = _idaapi.IA64_pshr2
IA64_pshr4 = _idaapi.IA64_pshr4
IA64_pshradd2 = _idaapi.IA64_pshradd2
IA64_psub1 = _idaapi.IA64_psub1
IA64_psub2 = _idaapi.IA64_psub2
IA64_psub4 = _idaapi.IA64_psub4
IA64_ptc = _idaapi.IA64_ptc
IA64_ptr = _idaapi.IA64_ptr
IA64_r = _idaapi.IA64_r
IA64_raz = _idaapi.IA64_raz
IA64_rel = _idaapi.IA64_rel
IA64_ret = _idaapi.IA64_ret
IA64_rfi = _idaapi.IA64_rfi
IA64_rsm = _idaapi.IA64_rsm
IA64_rum = _idaapi.IA64_rum
IA64_rw = _idaapi.IA64_rw
IA64_s = _idaapi.IA64_s
IA64_s0 = _idaapi.IA64_s0
IA64_s1 = _idaapi.IA64_s1
IA64_s2 = _idaapi.IA64_s2
IA64_s3 = _idaapi.IA64_s3
IA64_sa = _idaapi.IA64_sa
IA64_se = _idaapi.IA64_se
IA64_setf = _idaapi.IA64_setf
IA64_shl = _idaapi.IA64_shl
IA64_shladd = _idaapi.IA64_shladd
IA64_shladdp4 = _idaapi.IA64_shladdp4
IA64_shr = _idaapi.IA64_shr
IA64_shrp = _idaapi.IA64_shrp
IA64_sig = _idaapi.IA64_sig
IA64_spill = _idaapi.IA64_spill
IA64_spnt = _idaapi.IA64_spnt
IA64_sptk = _idaapi.IA64_sptk
IA64_srlz = _idaapi.IA64_srlz
IA64_ssm = _idaapi.IA64_ssm
IA64_sss = _idaapi.IA64_sss
IA64_st1 = _idaapi.IA64_st1
IA64_st2 = _idaapi.IA64_st2
IA64_st4 = _idaapi.IA64_st4
IA64_st8 = _idaapi.IA64_st8
IA64_stf = _idaapi.IA64_stf
IA64_stf8 = _idaapi.IA64_stf8
IA64_stfd = _idaapi.IA64_stfd
IA64_stfe = _idaapi.IA64_stfe
IA64_stfs = _idaapi.IA64_stfs
IA64_sub = _idaapi.IA64_sub
IA64_sum = _idaapi.IA64_sum
IA64_sxt1 = _idaapi.IA64_sxt1
IA64_sxt2 = _idaapi.IA64_sxt2
IA64_sxt4 = _idaapi.IA64_sxt4
IA64_sync = _idaapi.IA64_sync
IA64_tak = _idaapi.IA64_tak
IA64_tbit = _idaapi.IA64_tbit
IA64_thash = _idaapi.IA64_thash
IA64_tnat = _idaapi.IA64_tnat
IA64_tpa = _idaapi.IA64_tpa
IA64_trunc = _idaapi.IA64_trunc
IA64_ttag = _idaapi.IA64_ttag
IA64_u = _idaapi.IA64_u
IA64_unc = _idaapi.IA64_unc
IA64_unord = _idaapi.IA64_unord
IA64_unpack1 = _idaapi.IA64_unpack1
IA64_unpack2 = _idaapi.IA64_unpack2
IA64_unpack4 = _idaapi.IA64_unpack4
IA64_uss = _idaapi.IA64_uss
IA64_uus = _idaapi.IA64_uus
IA64_uuu = _idaapi.IA64_uuu
IA64_w = _idaapi.IA64_w
IA64_wexit = _idaapi.IA64_wexit
IA64_wtop = _idaapi.IA64_wtop
IA64_x = _idaapi.IA64_x
IA64_xchg1 = _idaapi.IA64_xchg1
IA64_xchg2 = _idaapi.IA64_xchg2
IA64_xchg4 = _idaapi.IA64_xchg4
IA64_xchg8 = _idaapi.IA64_xchg8
IA64_xf = _idaapi.IA64_xf
IA64_xma = _idaapi.IA64_xma
IA64_xmpy = _idaapi.IA64_xmpy
IA64_xor = _idaapi.IA64_xor
IA64_xuf = _idaapi.IA64_xuf
IA64_z = _idaapi.IA64_z
IA64_zxt1 = _idaapi.IA64_zxt1
IA64_zxt2 = _idaapi.IA64_zxt2
IA64_zxt4 = _idaapi.IA64_zxt4
IA64_last = _idaapi.IA64_last
NET_null = _idaapi.NET_null
NET_add = _idaapi.NET_add
NET_add_ovf = _idaapi.NET_add_ovf
NET_add_ovf_un = _idaapi.NET_add_ovf_un
NET_and = _idaapi.NET_and
NET_ann_arg = _idaapi.NET_ann_arg
NET_ann_call = _idaapi.NET_ann_call
NET_ann_catch = _idaapi.NET_ann_catch
NET_ann_data = _idaapi.NET_ann_data
NET_ann_data_s = _idaapi.NET_ann_data_s
NET_ann_dead = _idaapi.NET_ann_dead
NET_ann_def = _idaapi.NET_ann_def
NET_ann_hoisted = _idaapi.NET_ann_hoisted
NET_ann_hoisted_call = _idaapi.NET_ann_hoisted_call
NET_ann_lab = _idaapi.NET_ann_lab
NET_ann_live = _idaapi.NET_ann_live
NET_ann_phi = _idaapi.NET_ann_phi
NET_ann_ref = _idaapi.NET_ann_ref
NET_ann_ref_s = _idaapi.NET_ann_ref_s
NET_arglist = _idaapi.NET_arglist
NET_beq = _idaapi.NET_beq
NET_beq_s = _idaapi.NET_beq_s
NET_bge = _idaapi.NET_bge
NET_bge_s = _idaapi.NET_bge_s
NET_bge_un = _idaapi.NET_bge_un
NET_bge_un_s = _idaapi.NET_bge_un_s
NET_bgt = _idaapi.NET_bgt
NET_bgt_s = _idaapi.NET_bgt_s
NET_bgt_un = _idaapi.NET_bgt_un
NET_bgt_un_s = _idaapi.NET_bgt_un_s
NET_ble = _idaapi.NET_ble
NET_ble_s = _idaapi.NET_ble_s
NET_ble_un = _idaapi.NET_ble_un
NET_ble_un_s = _idaapi.NET_ble_un_s
NET_blt = _idaapi.NET_blt
NET_blt_s = _idaapi.NET_blt_s
NET_blt_un = _idaapi.NET_blt_un
NET_blt_un_s = _idaapi.NET_blt_un_s
NET_bne_un = _idaapi.NET_bne_un
NET_bne_un_s = _idaapi.NET_bne_un_s
NET_box = _idaapi.NET_box
NET_br = _idaapi.NET_br
NET_br_s = _idaapi.NET_br_s
NET_break = _idaapi.NET_break
NET_brfalse = _idaapi.NET_brfalse
NET_brfalse_s = _idaapi.NET_brfalse_s
NET_brtrue = _idaapi.NET_brtrue
NET_brtrue_s = _idaapi.NET_brtrue_s
NET_call = _idaapi.NET_call
NET_calli = _idaapi.NET_calli
NET_callvirt = _idaapi.NET_callvirt
NET_castclass = _idaapi.NET_castclass
NET_ceq = _idaapi.NET_ceq
NET_cgt = _idaapi.NET_cgt
NET_cgt_un = _idaapi.NET_cgt_un
NET_ckfinite = _idaapi.NET_ckfinite
NET_clt = _idaapi.NET_clt
NET_clt_un = _idaapi.NET_clt_un
NET_conv_i = _idaapi.NET_conv_i
NET_conv_i1 = _idaapi.NET_conv_i1
NET_conv_i2 = _idaapi.NET_conv_i2
NET_conv_i4 = _idaapi.NET_conv_i4
NET_conv_i8 = _idaapi.NET_conv_i8
NET_conv_ovf_i = _idaapi.NET_conv_ovf_i
NET_conv_ovf_i1 = _idaapi.NET_conv_ovf_i1
NET_conv_ovf_i1_un = _idaapi.NET_conv_ovf_i1_un
NET_conv_ovf_i2 = _idaapi.NET_conv_ovf_i2
NET_conv_ovf_i2_un = _idaapi.NET_conv_ovf_i2_un
NET_conv_ovf_i4 = _idaapi.NET_conv_ovf_i4
NET_conv_ovf_i4_un = _idaapi.NET_conv_ovf_i4_un
NET_conv_ovf_i8 = _idaapi.NET_conv_ovf_i8
NET_conv_ovf_i8_un = _idaapi.NET_conv_ovf_i8_un
NET_conv_ovf_i_un = _idaapi.NET_conv_ovf_i_un
NET_conv_ovf_u = _idaapi.NET_conv_ovf_u
NET_conv_ovf_u1 = _idaapi.NET_conv_ovf_u1
NET_conv_ovf_u1_un = _idaapi.NET_conv_ovf_u1_un
NET_conv_ovf_u2 = _idaapi.NET_conv_ovf_u2
NET_conv_ovf_u2_un = _idaapi.NET_conv_ovf_u2_un
NET_conv_ovf_u4 = _idaapi.NET_conv_ovf_u4
NET_conv_ovf_u4_un = _idaapi.NET_conv_ovf_u4_un
NET_conv_ovf_u8 = _idaapi.NET_conv_ovf_u8
NET_conv_ovf_u8_un = _idaapi.NET_conv_ovf_u8_un
NET_conv_ovf_u_un = _idaapi.NET_conv_ovf_u_un
NET_conv_r4 = _idaapi.NET_conv_r4
NET_conv_r8 = _idaapi.NET_conv_r8
NET_conv_r_un = _idaapi.NET_conv_r_un
NET_conv_u = _idaapi.NET_conv_u
NET_conv_u1 = _idaapi.NET_conv_u1
NET_conv_u2 = _idaapi.NET_conv_u2
NET_conv_u4 = _idaapi.NET_conv_u4
NET_conv_u8 = _idaapi.NET_conv_u8
NET_cpblk = _idaapi.NET_cpblk
NET_cpobj = _idaapi.NET_cpobj
NET_div = _idaapi.NET_div
NET_div_un = _idaapi.NET_div_un
NET_dup = _idaapi.NET_dup
NET_endfilter = _idaapi.NET_endfilter
NET_endfinally = _idaapi.NET_endfinally
NET_initblk = _idaapi.NET_initblk
NET_initobj = _idaapi.NET_initobj
NET_isinst = _idaapi.NET_isinst
NET_jmp = _idaapi.NET_jmp
NET_ldarg = _idaapi.NET_ldarg
NET_ldarg_0 = _idaapi.NET_ldarg_0
NET_ldarg_1 = _idaapi.NET_ldarg_1
NET_ldarg_2 = _idaapi.NET_ldarg_2
NET_ldarg_3 = _idaapi.NET_ldarg_3
NET_ldarg_s = _idaapi.NET_ldarg_s
NET_ldarga = _idaapi.NET_ldarga
NET_ldarga_s = _idaapi.NET_ldarga_s
NET_ldc_i4 = _idaapi.NET_ldc_i4
NET_ldc_i4_0 = _idaapi.NET_ldc_i4_0
NET_ldc_i4_1 = _idaapi.NET_ldc_i4_1
NET_ldc_i4_2 = _idaapi.NET_ldc_i4_2
NET_ldc_i4_3 = _idaapi.NET_ldc_i4_3
NET_ldc_i4_4 = _idaapi.NET_ldc_i4_4
NET_ldc_i4_5 = _idaapi.NET_ldc_i4_5
NET_ldc_i4_6 = _idaapi.NET_ldc_i4_6
NET_ldc_i4_7 = _idaapi.NET_ldc_i4_7
NET_ldc_i4_8 = _idaapi.NET_ldc_i4_8
NET_ldc_i4_m1 = _idaapi.NET_ldc_i4_m1
NET_ldc_i4_s = _idaapi.NET_ldc_i4_s
NET_ldc_i8 = _idaapi.NET_ldc_i8
NET_ldc_r4 = _idaapi.NET_ldc_r4
NET_ldc_r8 = _idaapi.NET_ldc_r8
NET_ldelem_i = _idaapi.NET_ldelem_i
NET_ldelem_i1 = _idaapi.NET_ldelem_i1
NET_ldelem_i2 = _idaapi.NET_ldelem_i2
NET_ldelem_i4 = _idaapi.NET_ldelem_i4
NET_ldelem_i8 = _idaapi.NET_ldelem_i8
NET_ldelem_r4 = _idaapi.NET_ldelem_r4
NET_ldelem_r8 = _idaapi.NET_ldelem_r8
NET_ldelem_ref = _idaapi.NET_ldelem_ref
NET_ldelem_u1 = _idaapi.NET_ldelem_u1
NET_ldelem_u2 = _idaapi.NET_ldelem_u2
NET_ldelem_u4 = _idaapi.NET_ldelem_u4
NET_ldelema = _idaapi.NET_ldelema
NET_ldfld = _idaapi.NET_ldfld
NET_ldflda = _idaapi.NET_ldflda
NET_ldftn = _idaapi.NET_ldftn
NET_ldind_i = _idaapi.NET_ldind_i
NET_ldind_i1 = _idaapi.NET_ldind_i1
NET_ldind_i2 = _idaapi.NET_ldind_i2
NET_ldind_i4 = _idaapi.NET_ldind_i4
NET_ldind_i8 = _idaapi.NET_ldind_i8
NET_ldind_r4 = _idaapi.NET_ldind_r4
NET_ldind_r8 = _idaapi.NET_ldind_r8
NET_ldind_ref = _idaapi.NET_ldind_ref
NET_ldind_u1 = _idaapi.NET_ldind_u1
NET_ldind_u2 = _idaapi.NET_ldind_u2
NET_ldind_u4 = _idaapi.NET_ldind_u4
NET_ldlen = _idaapi.NET_ldlen
NET_ldloc = _idaapi.NET_ldloc
NET_ldloc_0 = _idaapi.NET_ldloc_0
NET_ldloc_1 = _idaapi.NET_ldloc_1
NET_ldloc_2 = _idaapi.NET_ldloc_2
NET_ldloc_3 = _idaapi.NET_ldloc_3
NET_ldloc_s = _idaapi.NET_ldloc_s
NET_ldloca = _idaapi.NET_ldloca
NET_ldloca_s = _idaapi.NET_ldloca_s
NET_ldnull = _idaapi.NET_ldnull
NET_ldobj = _idaapi.NET_ldobj
NET_ldsfld = _idaapi.NET_ldsfld
NET_ldsflda = _idaapi.NET_ldsflda
NET_ldstr = _idaapi.NET_ldstr
NET_ldtoken = _idaapi.NET_ldtoken
NET_ldvirtftn = _idaapi.NET_ldvirtftn
NET_leave = _idaapi.NET_leave
NET_leave_s = _idaapi.NET_leave_s
NET_localloc = _idaapi.NET_localloc
NET_mkrefany = _idaapi.NET_mkrefany
NET_mul = _idaapi.NET_mul
NET_mul_ovf = _idaapi.NET_mul_ovf
NET_mul_ovf_un = _idaapi.NET_mul_ovf_un
NET_neg = _idaapi.NET_neg
NET_newarr = _idaapi.NET_newarr
NET_newobj = _idaapi.NET_newobj
NET_nop = _idaapi.NET_nop
NET_not = _idaapi.NET_not
NET_or = _idaapi.NET_or
NET_pop = _idaapi.NET_pop
NET_refanytype = _idaapi.NET_refanytype
NET_refanyval = _idaapi.NET_refanyval
NET_rem = _idaapi.NET_rem
NET_rem_un = _idaapi.NET_rem_un
NET_ret = _idaapi.NET_ret
NET_rethrow = _idaapi.NET_rethrow
NET_shl = _idaapi.NET_shl
NET_shr = _idaapi.NET_shr
NET_shr_un = _idaapi.NET_shr_un
NET_sizeof = _idaapi.NET_sizeof
NET_starg = _idaapi.NET_starg
NET_starg_s = _idaapi.NET_starg_s
NET_stelem_i = _idaapi.NET_stelem_i
NET_stelem_i1 = _idaapi.NET_stelem_i1
NET_stelem_i2 = _idaapi.NET_stelem_i2
NET_stelem_i4 = _idaapi.NET_stelem_i4
NET_stelem_i8 = _idaapi.NET_stelem_i8
NET_stelem_r4 = _idaapi.NET_stelem_r4
NET_stelem_r8 = _idaapi.NET_stelem_r8
NET_stelem_ref = _idaapi.NET_stelem_ref
NET_stfld = _idaapi.NET_stfld
NET_stind_i = _idaapi.NET_stind_i
NET_stind_i1 = _idaapi.NET_stind_i1
NET_stind_i2 = _idaapi.NET_stind_i2
NET_stind_i4 = _idaapi.NET_stind_i4
NET_stind_i8 = _idaapi.NET_stind_i8
NET_stind_r4 = _idaapi.NET_stind_r4
NET_stind_r8 = _idaapi.NET_stind_r8
NET_stind_ref = _idaapi.NET_stind_ref
NET_stloc = _idaapi.NET_stloc
NET_stloc_0 = _idaapi.NET_stloc_0
NET_stloc_1 = _idaapi.NET_stloc_1
NET_stloc_2 = _idaapi.NET_stloc_2
NET_stloc_3 = _idaapi.NET_stloc_3
NET_stloc_s = _idaapi.NET_stloc_s
NET_stobj = _idaapi.NET_stobj
NET_stsfld = _idaapi.NET_stsfld
NET_sub = _idaapi.NET_sub
NET_sub_ovf = _idaapi.NET_sub_ovf
NET_sub_ovf_un = _idaapi.NET_sub_ovf_un
NET_switch = _idaapi.NET_switch
NET_tail_ = _idaapi.NET_tail_
NET_throw = _idaapi.NET_throw
NET_unaligned_ = _idaapi.NET_unaligned_
NET_unbox = _idaapi.NET_unbox
NET_volatile_ = _idaapi.NET_volatile_
NET_xor = _idaapi.NET_xor
NET_ldelem = _idaapi.NET_ldelem
NET_stelem = _idaapi.NET_stelem
NET_unbox_any = _idaapi.NET_unbox_any
NET_constrained_ = _idaapi.NET_constrained_
NET_no_ = _idaapi.NET_no_
NET_readonly_ = _idaapi.NET_readonly_
NET_last = _idaapi.NET_last
MC12_null = _idaapi.MC12_null
MC12_aba = _idaapi.MC12_aba
MC12_abx = _idaapi.MC12_abx
MC12_aby = _idaapi.MC12_aby
MC12_adca = _idaapi.MC12_adca
MC12_adcb = _idaapi.MC12_adcb
MC12_adda = _idaapi.MC12_adda
MC12_addb = _idaapi.MC12_addb
MC12_addd = _idaapi.MC12_addd
MC12_anda = _idaapi.MC12_anda
MC12_andb = _idaapi.MC12_andb
MC12_andcc = _idaapi.MC12_andcc
MC12_asl = _idaapi.MC12_asl
MC12_asla = _idaapi.MC12_asla
MC12_aslb = _idaapi.MC12_aslb
MC12_asld = _idaapi.MC12_asld
MC12_asr = _idaapi.MC12_asr
MC12_asra = _idaapi.MC12_asra
MC12_asrb = _idaapi.MC12_asrb
MC12_bcc = _idaapi.MC12_bcc
MC12_bclr = _idaapi.MC12_bclr
MC12_bcs = _idaapi.MC12_bcs
MC12_beq = _idaapi.MC12_beq
MC12_bge = _idaapi.MC12_bge
MC12_bgnd = _idaapi.MC12_bgnd
MC12_bgt = _idaapi.MC12_bgt
MC12_bhi = _idaapi.MC12_bhi
MC12_bhs = _idaapi.MC12_bhs
MC12_bita = _idaapi.MC12_bita
MC12_bitb = _idaapi.MC12_bitb
MC12_ble = _idaapi.MC12_ble
MC12_blo = _idaapi.MC12_blo
MC12_bls = _idaapi.MC12_bls
MC12_blt = _idaapi.MC12_blt
MC12_bmi = _idaapi.MC12_bmi
MC12_bne = _idaapi.MC12_bne
MC12_bpl = _idaapi.MC12_bpl
MC12_bra = _idaapi.MC12_bra
MC12_brclr = _idaapi.MC12_brclr
MC12_brn = _idaapi.MC12_brn
MC12_brset = _idaapi.MC12_brset
MC12_bset = _idaapi.MC12_bset
MC12_bsr = _idaapi.MC12_bsr
MC12_bvc = _idaapi.MC12_bvc
MC12_bvs = _idaapi.MC12_bvs
MC12_call = _idaapi.MC12_call
MC12_cba = _idaapi.MC12_cba
MC12_clc = _idaapi.MC12_clc
MC12_cli = _idaapi.MC12_cli
MC12_clr = _idaapi.MC12_clr
MC12_clra = _idaapi.MC12_clra
MC12_clrb = _idaapi.MC12_clrb
MC12_clv = _idaapi.MC12_clv
MC12_cmpa = _idaapi.MC12_cmpa
MC12_cmpb = _idaapi.MC12_cmpb
MC12_com = _idaapi.MC12_com
MC12_coma = _idaapi.MC12_coma
MC12_comb = _idaapi.MC12_comb
MC12_cpd = _idaapi.MC12_cpd
MC12_cps = _idaapi.MC12_cps
MC12_cpx = _idaapi.MC12_cpx
MC12_cpy = _idaapi.MC12_cpy
MC12_daa = _idaapi.MC12_daa
MC12_dbeq = _idaapi.MC12_dbeq
MC12_dbne = _idaapi.MC12_dbne
MC12_dec = _idaapi.MC12_dec
MC12_deca = _idaapi.MC12_deca
MC12_decb = _idaapi.MC12_decb
MC12_des = _idaapi.MC12_des
MC12_dex = _idaapi.MC12_dex
MC12_dey = _idaapi.MC12_dey
MC12_ediv = _idaapi.MC12_ediv
MC12_edivs = _idaapi.MC12_edivs
MC12_emacs = _idaapi.MC12_emacs
MC12_emaxd = _idaapi.MC12_emaxd
MC12_emaxm = _idaapi.MC12_emaxm
MC12_emind = _idaapi.MC12_emind
MC12_eminm = _idaapi.MC12_eminm
MC12_emul = _idaapi.MC12_emul
MC12_emuls = _idaapi.MC12_emuls
MC12_eora = _idaapi.MC12_eora
MC12_eorb = _idaapi.MC12_eorb
MC12_etbl = _idaapi.MC12_etbl
MC12_exg = _idaapi.MC12_exg
MC12_fdiv = _idaapi.MC12_fdiv
MC12_ibeq = _idaapi.MC12_ibeq
MC12_ibne = _idaapi.MC12_ibne
MC12_idiv = _idaapi.MC12_idiv
MC12_idivs = _idaapi.MC12_idivs
MC12_inc = _idaapi.MC12_inc
MC12_inca = _idaapi.MC12_inca
MC12_incb = _idaapi.MC12_incb
MC12_ins = _idaapi.MC12_ins
MC12_inx = _idaapi.MC12_inx
MC12_iny = _idaapi.MC12_iny
MC12_jmp = _idaapi.MC12_jmp
MC12_jsr = _idaapi.MC12_jsr
MC12_lbcc = _idaapi.MC12_lbcc
MC12_lbcs = _idaapi.MC12_lbcs
MC12_lbeq = _idaapi.MC12_lbeq
MC12_lbge = _idaapi.MC12_lbge
MC12_lbgt = _idaapi.MC12_lbgt
MC12_lbhi = _idaapi.MC12_lbhi
MC12_lbhs = _idaapi.MC12_lbhs
MC12_lble = _idaapi.MC12_lble
MC12_lblo = _idaapi.MC12_lblo
MC12_lbls = _idaapi.MC12_lbls
MC12_lblt = _idaapi.MC12_lblt
MC12_lbmi = _idaapi.MC12_lbmi
MC12_lbne = _idaapi.MC12_lbne
MC12_lbpl = _idaapi.MC12_lbpl
MC12_lbra = _idaapi.MC12_lbra
MC12_lbrn = _idaapi.MC12_lbrn
MC12_lbvc = _idaapi.MC12_lbvc
MC12_lbvs = _idaapi.MC12_lbvs
MC12_ldaa = _idaapi.MC12_ldaa
MC12_ldab = _idaapi.MC12_ldab
MC12_ldd = _idaapi.MC12_ldd
MC12_lds = _idaapi.MC12_lds
MC12_ldx = _idaapi.MC12_ldx
MC12_ldy = _idaapi.MC12_ldy
MC12_leas = _idaapi.MC12_leas
MC12_leax = _idaapi.MC12_leax
MC12_leay = _idaapi.MC12_leay
MC12_lsl = _idaapi.MC12_lsl
MC12_lsla = _idaapi.MC12_lsla
MC12_lslb = _idaapi.MC12_lslb
MC12_lsld = _idaapi.MC12_lsld
MC12_lsr = _idaapi.MC12_lsr
MC12_lsra = _idaapi.MC12_lsra
MC12_lsrb = _idaapi.MC12_lsrb
MC12_lsrd = _idaapi.MC12_lsrd
MC12_maxa = _idaapi.MC12_maxa
MC12_maxm = _idaapi.MC12_maxm
MC12_mem = _idaapi.MC12_mem
MC12_mina = _idaapi.MC12_mina
MC12_minm = _idaapi.MC12_minm
MC12_movb = _idaapi.MC12_movb
MC12_movw = _idaapi.MC12_movw
MC12_mul = _idaapi.MC12_mul
MC12_neg = _idaapi.MC12_neg
MC12_nega = _idaapi.MC12_nega
MC12_negb = _idaapi.MC12_negb
MC12_nop = _idaapi.MC12_nop
MC12_oraa = _idaapi.MC12_oraa
MC12_orab = _idaapi.MC12_orab
MC12_orcc = _idaapi.MC12_orcc
MC12_psha = _idaapi.MC12_psha
MC12_pshb = _idaapi.MC12_pshb
MC12_pshc = _idaapi.MC12_pshc
MC12_pshd = _idaapi.MC12_pshd
MC12_pshx = _idaapi.MC12_pshx
MC12_pshy = _idaapi.MC12_pshy
MC12_pula = _idaapi.MC12_pula
MC12_pulb = _idaapi.MC12_pulb
MC12_pulc = _idaapi.MC12_pulc
MC12_puld = _idaapi.MC12_puld
MC12_pulx = _idaapi.MC12_pulx
MC12_puly = _idaapi.MC12_puly
MC12_rev = _idaapi.MC12_rev
MC12_revw = _idaapi.MC12_revw
MC12_rol = _idaapi.MC12_rol
MC12_rola = _idaapi.MC12_rola
MC12_rolb = _idaapi.MC12_rolb
MC12_ror = _idaapi.MC12_ror
MC12_rora = _idaapi.MC12_rora
MC12_rorb = _idaapi.MC12_rorb
MC12_rtc = _idaapi.MC12_rtc
MC12_rti = _idaapi.MC12_rti
MC12_rts = _idaapi.MC12_rts
MC12_sba = _idaapi.MC12_sba
MC12_sbca = _idaapi.MC12_sbca
MC12_sbcb = _idaapi.MC12_sbcb
MC12_sec = _idaapi.MC12_sec
MC12_sei = _idaapi.MC12_sei
MC12_sev = _idaapi.MC12_sev
MC12_sex = _idaapi.MC12_sex
MC12_staa = _idaapi.MC12_staa
MC12_stab = _idaapi.MC12_stab
MC12_std = _idaapi.MC12_std
MC12_stop = _idaapi.MC12_stop
MC12_sts = _idaapi.MC12_sts
MC12_stx = _idaapi.MC12_stx
MC12_sty = _idaapi.MC12_sty
MC12_suba = _idaapi.MC12_suba
MC12_subb = _idaapi.MC12_subb
MC12_subd = _idaapi.MC12_subd
MC12_swi = _idaapi.MC12_swi
MC12_tab = _idaapi.MC12_tab
MC12_tap = _idaapi.MC12_tap
MC12_tba = _idaapi.MC12_tba
MC12_tbeq = _idaapi.MC12_tbeq
MC12_tbl = _idaapi.MC12_tbl
MC12_tbne = _idaapi.MC12_tbne
MC12_tfr = _idaapi.MC12_tfr
MC12_tpa = _idaapi.MC12_tpa
MC12_trap = _idaapi.MC12_trap
MC12_tst = _idaapi.MC12_tst
MC12_tsta = _idaapi.MC12_tsta
MC12_tstb = _idaapi.MC12_tstb
MC12_tsx = _idaapi.MC12_tsx
MC12_tsy = _idaapi.MC12_tsy
MC12_txs = _idaapi.MC12_txs
MC12_tys = _idaapi.MC12_tys
MC12_wai = _idaapi.MC12_wai
MC12_wav = _idaapi.MC12_wav
MC12_wavr = _idaapi.MC12_wavr
MC12_xgdx = _idaapi.MC12_xgdx
MC12_xgdy = _idaapi.MC12_xgdy
MC12_skip1 = _idaapi.MC12_skip1
MC12_skip2 = _idaapi.MC12_skip2
MC12X_addx = _idaapi.MC12X_addx
MC12X_addy = _idaapi.MC12X_addy
MC12X_aded = _idaapi.MC12X_aded
MC12X_adex = _idaapi.MC12X_adex
MC12X_adey = _idaapi.MC12X_adey
MC12X_andx = _idaapi.MC12X_andx
MC12X_andy = _idaapi.MC12X_andy
MC12X_aslw = _idaapi.MC12X_aslw
MC12X_aslx = _idaapi.MC12X_aslx
MC12X_asly = _idaapi.MC12X_asly
MC12X_asrw = _idaapi.MC12X_asrw
MC12X_asrx = _idaapi.MC12X_asrx
MC12X_asry = _idaapi.MC12X_asry
MC12X_bitx = _idaapi.MC12X_bitx
MC12X_bity = _idaapi.MC12X_bity
MC12X_btas = _idaapi.MC12X_btas
MC12X_clrw = _idaapi.MC12X_clrw
MC12X_clrx = _idaapi.MC12X_clrx
MC12X_clry = _idaapi.MC12X_clry
MC12X_comw = _idaapi.MC12X_comw
MC12X_comx = _idaapi.MC12X_comx
MC12X_comy = _idaapi.MC12X_comy
MC12X_cped = _idaapi.MC12X_cped
MC12X_cpes = _idaapi.MC12X_cpes
MC12X_cpex = _idaapi.MC12X_cpex
MC12X_cpey = _idaapi.MC12X_cpey
MC12X_decw = _idaapi.MC12X_decw
MC12X_decx = _idaapi.MC12X_decx
MC12X_decy = _idaapi.MC12X_decy
MC12X_eorx = _idaapi.MC12X_eorx
MC12X_eory = _idaapi.MC12X_eory
MC12X_gldaa = _idaapi.MC12X_gldaa
MC12X_gldab = _idaapi.MC12X_gldab
MC12X_gldd = _idaapi.MC12X_gldd
MC12X_glds = _idaapi.MC12X_glds
MC12X_gldx = _idaapi.MC12X_gldx
MC12X_gldy = _idaapi.MC12X_gldy
MC12X_gstaa = _idaapi.MC12X_gstaa
MC12X_gstab = _idaapi.MC12X_gstab
MC12X_gstd = _idaapi.MC12X_gstd
MC12X_gsts = _idaapi.MC12X_gsts
MC12X_gstx = _idaapi.MC12X_gstx
MC12X_gsty = _idaapi.MC12X_gsty
MC12X_incw = _idaapi.MC12X_incw
MC12X_incx = _idaapi.MC12X_incx
MC12X_incy = _idaapi.MC12X_incy
MC12X_lsrw = _idaapi.MC12X_lsrw
MC12X_lsrx = _idaapi.MC12X_lsrx
MC12X_lsry = _idaapi.MC12X_lsry
MC12X_negw = _idaapi.MC12X_negw
MC12X_negx = _idaapi.MC12X_negx
MC12X_negy = _idaapi.MC12X_negy
MC12X_orx = _idaapi.MC12X_orx
MC12X_ory = _idaapi.MC12X_ory
MC12X_pshcw = _idaapi.MC12X_pshcw
MC12X_pulcw = _idaapi.MC12X_pulcw
MC12X_rolw = _idaapi.MC12X_rolw
MC12X_rolx = _idaapi.MC12X_rolx
MC12X_roly = _idaapi.MC12X_roly
MC12X_rorw = _idaapi.MC12X_rorw
MC12X_rorx = _idaapi.MC12X_rorx
MC12X_rory = _idaapi.MC12X_rory
MC12X_sbed = _idaapi.MC12X_sbed
MC12X_sbex = _idaapi.MC12X_sbex
MC12X_sbey = _idaapi.MC12X_sbey
MC12X_subx = _idaapi.MC12X_subx
MC12X_suby = _idaapi.MC12X_suby
MC12X_tstw = _idaapi.MC12X_tstw
MC12X_tstx = _idaapi.MC12X_tstx
MC12X_tsty = _idaapi.MC12X_tsty
MC12X_sys = _idaapi.MC12X_sys
MC12XGATE_adc = _idaapi.MC12XGATE_adc
MC12XGATE_add = _idaapi.MC12XGATE_add
MC12XGATE_addh = _idaapi.MC12XGATE_addh
MC12XGATE_addl = _idaapi.MC12XGATE_addl
MC12XGATE_and = _idaapi.MC12XGATE_and
MC12XGATE_andh = _idaapi.MC12XGATE_andh
MC12XGATE_andl = _idaapi.MC12XGATE_andl
MC12XGATE_asr = _idaapi.MC12XGATE_asr
MC12XGATE_bcc = _idaapi.MC12XGATE_bcc
MC12XGATE_bcs = _idaapi.MC12XGATE_bcs
MC12XGATE_beq = _idaapi.MC12XGATE_beq
MC12XGATE_bfext = _idaapi.MC12XGATE_bfext
MC12XGATE_bffo = _idaapi.MC12XGATE_bffo
MC12XGATE_bfins = _idaapi.MC12XGATE_bfins
MC12XGATE_bfinsi = _idaapi.MC12XGATE_bfinsi
MC12XGATE_bfinsx = _idaapi.MC12XGATE_bfinsx
MC12XGATE_bge = _idaapi.MC12XGATE_bge
MC12XGATE_bgt = _idaapi.MC12XGATE_bgt
MC12XGATE_bhi = _idaapi.MC12XGATE_bhi
MC12XGATE_bhs = _idaapi.MC12XGATE_bhs
MC12XGATE_bith = _idaapi.MC12XGATE_bith
MC12XGATE_bitl = _idaapi.MC12XGATE_bitl
MC12XGATE_ble = _idaapi.MC12XGATE_ble
MC12XGATE_blo = _idaapi.MC12XGATE_blo
MC12XGATE_bls = _idaapi.MC12XGATE_bls
MC12XGATE_blt = _idaapi.MC12XGATE_blt
MC12XGATE_bmi = _idaapi.MC12XGATE_bmi
MC12XGATE_bne = _idaapi.MC12XGATE_bne
MC12XGATE_bpl = _idaapi.MC12XGATE_bpl
MC12XGATE_bra = _idaapi.MC12XGATE_bra
MC12XGATE_brk = _idaapi.MC12XGATE_brk
MC12XGATE_bvc = _idaapi.MC12XGATE_bvc
MC12XGATE_bvs = _idaapi.MC12XGATE_bvs
MC12XGATE_cmp = _idaapi.MC12XGATE_cmp
MC12XGATE_cmpl = _idaapi.MC12XGATE_cmpl
MC12XGATE_com = _idaapi.MC12XGATE_com
MC12XGATE_cpc = _idaapi.MC12XGATE_cpc
MC12XGATE_cpch = _idaapi.MC12XGATE_cpch
MC12XGATE_csem = _idaapi.MC12XGATE_csem
MC12XGATE_csl = _idaapi.MC12XGATE_csl
MC12XGATE_csr = _idaapi.MC12XGATE_csr
MC12XGATE_jal = _idaapi.MC12XGATE_jal
MC12XGATE_ldb = _idaapi.MC12XGATE_ldb
MC12XGATE_ldh = _idaapi.MC12XGATE_ldh
MC12XGATE_ldl = _idaapi.MC12XGATE_ldl
MC12XGATE_ldw = _idaapi.MC12XGATE_ldw
MC12XGATE_lsl = _idaapi.MC12XGATE_lsl
MC12XGATE_lsr = _idaapi.MC12XGATE_lsr
MC12XGATE_mov = _idaapi.MC12XGATE_mov
MC12XGATE_neg = _idaapi.MC12XGATE_neg
MC12XGATE_nop = _idaapi.MC12XGATE_nop
MC12XGATE_or = _idaapi.MC12XGATE_or
MC12XGATE_orh = _idaapi.MC12XGATE_orh
MC12XGATE_orl = _idaapi.MC12XGATE_orl
MC12XGATE_par = _idaapi.MC12XGATE_par
MC12XGATE_rol = _idaapi.MC12XGATE_rol
MC12XGATE_ror = _idaapi.MC12XGATE_ror
MC12XGATE_rts = _idaapi.MC12XGATE_rts
MC12XGATE_sbc = _idaapi.MC12XGATE_sbc
MC12XGATE_sex = _idaapi.MC12XGATE_sex
MC12XGATE_sif = _idaapi.MC12XGATE_sif
MC12XGATE_ssem = _idaapi.MC12XGATE_ssem
MC12XGATE_stb = _idaapi.MC12XGATE_stb
MC12XGATE_stw = _idaapi.MC12XGATE_stw
MC12XGATE_sub = _idaapi.MC12XGATE_sub
MC12XGATE_subh = _idaapi.MC12XGATE_subh
MC12XGATE_subl = _idaapi.MC12XGATE_subl
MC12XGATE_tfr = _idaapi.MC12XGATE_tfr
MC12XGATE_tst = _idaapi.MC12XGATE_tst
MC12XGATE_xnor = _idaapi.MC12XGATE_xnor
MC12XGATE_xnorh = _idaapi.MC12XGATE_xnorh
MC12XGATE_xnorl = _idaapi.MC12XGATE_xnorl
MC12XGATE_add16 = _idaapi.MC12XGATE_add16
MC12XGATE_and16 = _idaapi.MC12XGATE_and16
MC12XGATE_cmp16 = _idaapi.MC12XGATE_cmp16
MC12XGATE_ldw16 = _idaapi.MC12XGATE_ldw16
MC12XGATE_or16 = _idaapi.MC12XGATE_or16
MC12XGATE_sub16 = _idaapi.MC12XGATE_sub16
MC12XGATE_xnor16 = _idaapi.MC12XGATE_xnor16
MC12_last = _idaapi.MC12_last
MC6816_null = _idaapi.MC6816_null
MC6816_ldaa = _idaapi.MC6816_ldaa
MC6816_ldab = _idaapi.MC6816_ldab
MC6816_ldd = _idaapi.MC6816_ldd
MC6816_lde = _idaapi.MC6816_lde
MC6816_lded = _idaapi.MC6816_lded
MC6816_movb = _idaapi.MC6816_movb
MC6816_movw = _idaapi.MC6816_movw
MC6816_staa = _idaapi.MC6816_staa
MC6816_stab = _idaapi.MC6816_stab
MC6816_std = _idaapi.MC6816_std
MC6816_ste = _idaapi.MC6816_ste
MC6816_sted = _idaapi.MC6816_sted
MC6816_tab = _idaapi.MC6816_tab
MC6816_tba = _idaapi.MC6816_tba
MC6816_tde = _idaapi.MC6816_tde
MC6816_ted = _idaapi.MC6816_ted
MC6816_xgab = _idaapi.MC6816_xgab
MC6816_xgde = _idaapi.MC6816_xgde
MC6816_aba = _idaapi.MC6816_aba
MC6816_adca = _idaapi.MC6816_adca
MC6816_adcb = _idaapi.MC6816_adcb
MC6816_adcd = _idaapi.MC6816_adcd
MC6816_adce = _idaapi.MC6816_adce
MC6816_adda = _idaapi.MC6816_adda
MC6816_addb = _idaapi.MC6816_addb
MC6816_addd = _idaapi.MC6816_addd
MC6816_adde = _idaapi.MC6816_adde
MC6816_ade = _idaapi.MC6816_ade
MC6816_sba = _idaapi.MC6816_sba
MC6816_sbca = _idaapi.MC6816_sbca
MC6816_sbcb = _idaapi.MC6816_sbcb
MC6816_sbcd = _idaapi.MC6816_sbcd
MC6816_sbce = _idaapi.MC6816_sbce
MC6816_sde = _idaapi.MC6816_sde
MC6816_suba = _idaapi.MC6816_suba
MC6816_subb = _idaapi.MC6816_subb
MC6816_subd = _idaapi.MC6816_subd
MC6816_sube = _idaapi.MC6816_sube
MC6816_daa = _idaapi.MC6816_daa
MC6816_sxt = _idaapi.MC6816_sxt
MC6816_cba = _idaapi.MC6816_cba
MC6816_cmpa = _idaapi.MC6816_cmpa
MC6816_cmpb = _idaapi.MC6816_cmpb
MC6816_cpd = _idaapi.MC6816_cpd
MC6816_cpe = _idaapi.MC6816_cpe
MC6816_tst = _idaapi.MC6816_tst
MC6816_tsta = _idaapi.MC6816_tsta
MC6816_tstb = _idaapi.MC6816_tstb
MC6816_tstd = _idaapi.MC6816_tstd
MC6816_tste = _idaapi.MC6816_tste
MC6816_tstw = _idaapi.MC6816_tstw
MC6816_ediv = _idaapi.MC6816_ediv
MC6816_edivs = _idaapi.MC6816_edivs
MC6816_emul = _idaapi.MC6816_emul
MC6816_emuls = _idaapi.MC6816_emuls
MC6816_fdiv = _idaapi.MC6816_fdiv
MC6816_fmuls = _idaapi.MC6816_fmuls
MC6816_idiv = _idaapi.MC6816_idiv
MC6816_mul = _idaapi.MC6816_mul
MC6816_dec = _idaapi.MC6816_dec
MC6816_deca = _idaapi.MC6816_deca
MC6816_decb = _idaapi.MC6816_decb
MC6816_decw = _idaapi.MC6816_decw
MC6816_inc = _idaapi.MC6816_inc
MC6816_inca = _idaapi.MC6816_inca
MC6816_incb = _idaapi.MC6816_incb
MC6816_incw = _idaapi.MC6816_incw
MC6816_clr = _idaapi.MC6816_clr
MC6816_clra = _idaapi.MC6816_clra
MC6816_clrb = _idaapi.MC6816_clrb
MC6816_clrd = _idaapi.MC6816_clrd
MC6816_clre = _idaapi.MC6816_clre
MC6816_clrw = _idaapi.MC6816_clrw
MC6816_com = _idaapi.MC6816_com
MC6816_coma = _idaapi.MC6816_coma
MC6816_comb = _idaapi.MC6816_comb
MC6816_comd = _idaapi.MC6816_comd
MC6816_come = _idaapi.MC6816_come
MC6816_comw = _idaapi.MC6816_comw
MC6816_neg = _idaapi.MC6816_neg
MC6816_nega = _idaapi.MC6816_nega
MC6816_negb = _idaapi.MC6816_negb
MC6816_negd = _idaapi.MC6816_negd
MC6816_nege = _idaapi.MC6816_nege
MC6816_negw = _idaapi.MC6816_negw
MC6816_anda = _idaapi.MC6816_anda
MC6816_andb = _idaapi.MC6816_andb
MC6816_andd = _idaapi.MC6816_andd
MC6816_ande = _idaapi.MC6816_ande
MC6816_eora = _idaapi.MC6816_eora
MC6816_eorb = _idaapi.MC6816_eorb
MC6816_eord = _idaapi.MC6816_eord
MC6816_eore = _idaapi.MC6816_eore
MC6816_oraa = _idaapi.MC6816_oraa
MC6816_orab = _idaapi.MC6816_orab
MC6816_ord = _idaapi.MC6816_ord
MC6816_ore = _idaapi.MC6816_ore
MC6816_bita = _idaapi.MC6816_bita
MC6816_bitb = _idaapi.MC6816_bitb
MC6816_bclr = _idaapi.MC6816_bclr
MC6816_bclrw = _idaapi.MC6816_bclrw
MC6816_bset = _idaapi.MC6816_bset
MC6816_bsetw = _idaapi.MC6816_bsetw
MC6816_lsr = _idaapi.MC6816_lsr
MC6816_lsra = _idaapi.MC6816_lsra
MC6816_lsrb = _idaapi.MC6816_lsrb
MC6816_lsrd = _idaapi.MC6816_lsrd
MC6816_lsre = _idaapi.MC6816_lsre
MC6816_lsrw = _idaapi.MC6816_lsrw
MC6816_asl = _idaapi.MC6816_asl
MC6816_asla = _idaapi.MC6816_asla
MC6816_aslb = _idaapi.MC6816_aslb
MC6816_asld = _idaapi.MC6816_asld
MC6816_asle = _idaapi.MC6816_asle
MC6816_aslw = _idaapi.MC6816_aslw
MC6816_asr = _idaapi.MC6816_asr
MC6816_asra = _idaapi.MC6816_asra
MC6816_asrb = _idaapi.MC6816_asrb
MC6816_asrd = _idaapi.MC6816_asrd
MC6816_asre = _idaapi.MC6816_asre
MC6816_asrw = _idaapi.MC6816_asrw
MC6816_rol = _idaapi.MC6816_rol
MC6816_rola = _idaapi.MC6816_rola
MC6816_rolb = _idaapi.MC6816_rolb
MC6816_rold = _idaapi.MC6816_rold
MC6816_role = _idaapi.MC6816_role
MC6816_rolw = _idaapi.MC6816_rolw
MC6816_ror = _idaapi.MC6816_ror
MC6816_rora = _idaapi.MC6816_rora
MC6816_rorb = _idaapi.MC6816_rorb
MC6816_rord = _idaapi.MC6816_rord
MC6816_rore = _idaapi.MC6816_rore
MC6816_rorw = _idaapi.MC6816_rorw
MC6816_bra = _idaapi.MC6816_bra
MC6816_brn = _idaapi.MC6816_brn
MC6816_bcc = _idaapi.MC6816_bcc
MC6816_bcs = _idaapi.MC6816_bcs
MC6816_beq = _idaapi.MC6816_beq
MC6816_bmi = _idaapi.MC6816_bmi
MC6816_bne = _idaapi.MC6816_bne
MC6816_bpl = _idaapi.MC6816_bpl
MC6816_bvc = _idaapi.MC6816_bvc
MC6816_bvs = _idaapi.MC6816_bvs
MC6816_bhi = _idaapi.MC6816_bhi
MC6816_bls = _idaapi.MC6816_bls
MC6816_bge = _idaapi.MC6816_bge
MC6816_bgt = _idaapi.MC6816_bgt
MC6816_ble = _idaapi.MC6816_ble
MC6816_blt = _idaapi.MC6816_blt
MC6816_lbra = _idaapi.MC6816_lbra
MC6816_lbrn = _idaapi.MC6816_lbrn
MC6816_lbcc = _idaapi.MC6816_lbcc
MC6816_lbcs = _idaapi.MC6816_lbcs
MC6816_lbeq = _idaapi.MC6816_lbeq
MC6816_lbev = _idaapi.MC6816_lbev
MC6816_lbmi = _idaapi.MC6816_lbmi
MC6816_lbmv = _idaapi.MC6816_lbmv
MC6816_lbne = _idaapi.MC6816_lbne
MC6816_lbpl = _idaapi.MC6816_lbpl
MC6816_lbvc = _idaapi.MC6816_lbvc
MC6816_lbvs = _idaapi.MC6816_lbvs
MC6816_lbhi = _idaapi.MC6816_lbhi
MC6816_lbls = _idaapi.MC6816_lbls
MC6816_lbge = _idaapi.MC6816_lbge
MC6816_lbgt = _idaapi.MC6816_lbgt
MC6816_lble = _idaapi.MC6816_lble
MC6816_lblt = _idaapi.MC6816_lblt
MC6816_brclr = _idaapi.MC6816_brclr
MC6816_brset = _idaapi.MC6816_brset
MC6816_jmp = _idaapi.MC6816_jmp
MC6816_bsr = _idaapi.MC6816_bsr
MC6816_jsr = _idaapi.MC6816_jsr
MC6816_lbsr = _idaapi.MC6816_lbsr
MC6816_rts = _idaapi.MC6816_rts
MC6816_rti = _idaapi.MC6816_rti
MC6816_swi = _idaapi.MC6816_swi
MC6816_abx = _idaapi.MC6816_abx
MC6816_aby = _idaapi.MC6816_aby
MC6816_abz = _idaapi.MC6816_abz
MC6816_adx = _idaapi.MC6816_adx
MC6816_ady = _idaapi.MC6816_ady
MC6816_adz = _idaapi.MC6816_adz
MC6816_aex = _idaapi.MC6816_aex
MC6816_aey = _idaapi.MC6816_aey
MC6816_aez = _idaapi.MC6816_aez
MC6816_aix = _idaapi.MC6816_aix
MC6816_aiy = _idaapi.MC6816_aiy
MC6816_aiz = _idaapi.MC6816_aiz
MC6816_cpx = _idaapi.MC6816_cpx
MC6816_cpy = _idaapi.MC6816_cpy
MC6816_cpz = _idaapi.MC6816_cpz
MC6816_ldx = _idaapi.MC6816_ldx
MC6816_ldy = _idaapi.MC6816_ldy
MC6816_ldz = _idaapi.MC6816_ldz
MC6816_stx = _idaapi.MC6816_stx
MC6816_sty = _idaapi.MC6816_sty
MC6816_stz = _idaapi.MC6816_stz
MC6816_tsx = _idaapi.MC6816_tsx
MC6816_tsy = _idaapi.MC6816_tsy
MC6816_tsz = _idaapi.MC6816_tsz
MC6816_txs = _idaapi.MC6816_txs
MC6816_txy = _idaapi.MC6816_txy
MC6816_txz = _idaapi.MC6816_txz
MC6816_tys = _idaapi.MC6816_tys
MC6816_tyx = _idaapi.MC6816_tyx
MC6816_tyz = _idaapi.MC6816_tyz
MC6816_tzs = _idaapi.MC6816_tzs
MC6816_tzx = _idaapi.MC6816_tzx
MC6816_tzy = _idaapi.MC6816_tzy
MC6816_xgdx = _idaapi.MC6816_xgdx
MC6816_xgdy = _idaapi.MC6816_xgdy
MC6816_xgdz = _idaapi.MC6816_xgdz
MC6816_xgex = _idaapi.MC6816_xgex
MC6816_xgey = _idaapi.MC6816_xgey
MC6816_xgez = _idaapi.MC6816_xgez
MC6816_tbek = _idaapi.MC6816_tbek
MC6816_tbsk = _idaapi.MC6816_tbsk
MC6816_tbxk = _idaapi.MC6816_tbxk
MC6816_tbyk = _idaapi.MC6816_tbyk
MC6816_tbzk = _idaapi.MC6816_tbzk
MC6816_tekb = _idaapi.MC6816_tekb
MC6816_tskb = _idaapi.MC6816_tskb
MC6816_txkb = _idaapi.MC6816_txkb
MC6816_tykb = _idaapi.MC6816_tykb
MC6816_tzkb = _idaapi.MC6816_tzkb
MC6816_ais = _idaapi.MC6816_ais
MC6816_cps = _idaapi.MC6816_cps
MC6816_lds = _idaapi.MC6816_lds
MC6816_sts = _idaapi.MC6816_sts
MC6816_psha = _idaapi.MC6816_psha
MC6816_pshb = _idaapi.MC6816_pshb
MC6816_pshm = _idaapi.MC6816_pshm
MC6816_pula = _idaapi.MC6816_pula
MC6816_pulb = _idaapi.MC6816_pulb
MC6816_pulm = _idaapi.MC6816_pulm
MC6816_andp = _idaapi.MC6816_andp
MC6816_orp = _idaapi.MC6816_orp
MC6816_tap = _idaapi.MC6816_tap
MC6816_tdp = _idaapi.MC6816_tdp
MC6816_tpa = _idaapi.MC6816_tpa
MC6816_tpd = _idaapi.MC6816_tpd
MC6816_ace = _idaapi.MC6816_ace
MC6816_aced = _idaapi.MC6816_aced
MC6816_aslm = _idaapi.MC6816_aslm
MC6816_asrm = _idaapi.MC6816_asrm
MC6816_clrm = _idaapi.MC6816_clrm
MC6816_ldhi = _idaapi.MC6816_ldhi
MC6816_mac = _idaapi.MC6816_mac
MC6816_pshmac = _idaapi.MC6816_pshmac
MC6816_pulmac = _idaapi.MC6816_pulmac
MC6816_rmac = _idaapi.MC6816_rmac
MC6816_tdmsk = _idaapi.MC6816_tdmsk
MC6816_tedm = _idaapi.MC6816_tedm
MC6816_tem = _idaapi.MC6816_tem
MC6816_tmer = _idaapi.MC6816_tmer
MC6816_tmet = _idaapi.MC6816_tmet
MC6816_tmxed = _idaapi.MC6816_tmxed
MC6816_lpstop = _idaapi.MC6816_lpstop
MC6816_wai = _idaapi.MC6816_wai
MC6816_bgnd = _idaapi.MC6816_bgnd
MC6816_nop = _idaapi.MC6816_nop
MC6816_last = _idaapi.MC6816_last
I960_null = _idaapi.I960_null
I960_addc = _idaapi.I960_addc
I960_addi = _idaapi.I960_addi
I960_addo = _idaapi.I960_addo
I960_alterbit = _idaapi.I960_alterbit
I960_and = _idaapi.I960_and
I960_andnot = _idaapi.I960_andnot
I960_atadd = _idaapi.I960_atadd
I960_atmod = _idaapi.I960_atmod
I960_b = _idaapi.I960_b
I960_bal = _idaapi.I960_bal
I960_balx = _idaapi.I960_balx
I960_bbc = _idaapi.I960_bbc
I960_bbs = _idaapi.I960_bbs
I960_bno = _idaapi.I960_bno
I960_bg = _idaapi.I960_bg
I960_be = _idaapi.I960_be
I960_bge = _idaapi.I960_bge
I960_bl = _idaapi.I960_bl
I960_bne = _idaapi.I960_bne
I960_ble = _idaapi.I960_ble
I960_bo = _idaapi.I960_bo
I960_bx = _idaapi.I960_bx
I960_call = _idaapi.I960_call
I960_calls = _idaapi.I960_calls
I960_callx = _idaapi.I960_callx
I960_chkbit = _idaapi.I960_chkbit
I960_clrbit = _idaapi.I960_clrbit
I960_cmpdeci = _idaapi.I960_cmpdeci
I960_cmpdeco = _idaapi.I960_cmpdeco
I960_cmpi = _idaapi.I960_cmpi
I960_cmpibno = _idaapi.I960_cmpibno
I960_cmpibg = _idaapi.I960_cmpibg
I960_cmpibe = _idaapi.I960_cmpibe
I960_cmpibge = _idaapi.I960_cmpibge
I960_cmpibl = _idaapi.I960_cmpibl
I960_cmpibne = _idaapi.I960_cmpibne
I960_cmpible = _idaapi.I960_cmpible
I960_cmpibo = _idaapi.I960_cmpibo
I960_cmpinci = _idaapi.I960_cmpinci
I960_cmpinco = _idaapi.I960_cmpinco
I960_cmpo = _idaapi.I960_cmpo
I960_cmpobg = _idaapi.I960_cmpobg
I960_cmpobe = _idaapi.I960_cmpobe
I960_cmpobge = _idaapi.I960_cmpobge
I960_cmpobl = _idaapi.I960_cmpobl
I960_cmpobne = _idaapi.I960_cmpobne
I960_cmpoble = _idaapi.I960_cmpoble
I960_concmpi = _idaapi.I960_concmpi
I960_concmpo = _idaapi.I960_concmpo
I960_divi = _idaapi.I960_divi
I960_divo = _idaapi.I960_divo
I960_ediv = _idaapi.I960_ediv
I960_emul = _idaapi.I960_emul
I960_eshro = _idaapi.I960_eshro
I960_extract = _idaapi.I960_extract
I960_faultno = _idaapi.I960_faultno
I960_faultg = _idaapi.I960_faultg
I960_faulte = _idaapi.I960_faulte
I960_faultge = _idaapi.I960_faultge
I960_faultl = _idaapi.I960_faultl
I960_faultne = _idaapi.I960_faultne
I960_faultle = _idaapi.I960_faultle
I960_faulto = _idaapi.I960_faulto
I960_flushreg = _idaapi.I960_flushreg
I960_fmark = _idaapi.I960_fmark
I960_ld = _idaapi.I960_ld
I960_lda = _idaapi.I960_lda
I960_ldib = _idaapi.I960_ldib
I960_ldis = _idaapi.I960_ldis
I960_ldl = _idaapi.I960_ldl
I960_ldob = _idaapi.I960_ldob
I960_ldos = _idaapi.I960_ldos
I960_ldq = _idaapi.I960_ldq
I960_ldt = _idaapi.I960_ldt
I960_mark = _idaapi.I960_mark
I960_modac = _idaapi.I960_modac
I960_modi = _idaapi.I960_modi
I960_modify = _idaapi.I960_modify
I960_modpc = _idaapi.I960_modpc
I960_modtc = _idaapi.I960_modtc
I960_mov = _idaapi.I960_mov
I960_movl = _idaapi.I960_movl
I960_movq = _idaapi.I960_movq
I960_movt = _idaapi.I960_movt
I960_muli = _idaapi.I960_muli
I960_mulo = _idaapi.I960_mulo
I960_nand = _idaapi.I960_nand
I960_nor = _idaapi.I960_nor
I960_not = _idaapi.I960_not
I960_notand = _idaapi.I960_notand
I960_notbit = _idaapi.I960_notbit
I960_notor = _idaapi.I960_notor
I960_or = _idaapi.I960_or
I960_ornot = _idaapi.I960_ornot
I960_remi = _idaapi.I960_remi
I960_remo = _idaapi.I960_remo
I960_ret = _idaapi.I960_ret
I960_rotate = _idaapi.I960_rotate
I960_scanbit = _idaapi.I960_scanbit
I960_scanbyte = _idaapi.I960_scanbyte
I960_setbit = _idaapi.I960_setbit
I960_shli = _idaapi.I960_shli
I960_shlo = _idaapi.I960_shlo
I960_shrdi = _idaapi.I960_shrdi
I960_shri = _idaapi.I960_shri
I960_shro = _idaapi.I960_shro
I960_spanbit = _idaapi.I960_spanbit
I960_st = _idaapi.I960_st
I960_stib = _idaapi.I960_stib
I960_stis = _idaapi.I960_stis
I960_stl = _idaapi.I960_stl
I960_stob = _idaapi.I960_stob
I960_stos = _idaapi.I960_stos
I960_stq = _idaapi.I960_stq
I960_stt = _idaapi.I960_stt
I960_subc = _idaapi.I960_subc
I960_subi = _idaapi.I960_subi
I960_subo = _idaapi.I960_subo
I960_syncf = _idaapi.I960_syncf
I960_testno = _idaapi.I960_testno
I960_testg = _idaapi.I960_testg
I960_teste = _idaapi.I960_teste
I960_testge = _idaapi.I960_testge
I960_testl = _idaapi.I960_testl
I960_testne = _idaapi.I960_testne
I960_testle = _idaapi.I960_testle
I960_testo = _idaapi.I960_testo
I960_xnor = _idaapi.I960_xnor
I960_xor = _idaapi.I960_xor
I960_sdma = _idaapi.I960_sdma
I960_sysctl = _idaapi.I960_sysctl
I960_udma = _idaapi.I960_udma
I960_dcinva = _idaapi.I960_dcinva
I960_cmpob = _idaapi.I960_cmpob
I960_cmpib = _idaapi.I960_cmpib
I960_cmpos = _idaapi.I960_cmpos
I960_cmpis = _idaapi.I960_cmpis
I960_bswap = _idaapi.I960_bswap
I960_intdis = _idaapi.I960_intdis
I960_inten = _idaapi.I960_inten
I960_synmov = _idaapi.I960_synmov
I960_synmovl = _idaapi.I960_synmovl
I960_synmovq = _idaapi.I960_synmovq
I960_cmpstr = _idaapi.I960_cmpstr
I960_movqstr = _idaapi.I960_movqstr
I960_movstr = _idaapi.I960_movstr
I960_inspacc = _idaapi.I960_inspacc
I960_ldphy = _idaapi.I960_ldphy
I960_synld = _idaapi.I960_synld
I960_fill = _idaapi.I960_fill
I960_daddc = _idaapi.I960_daddc
I960_dsubc = _idaapi.I960_dsubc
I960_dmovt = _idaapi.I960_dmovt
I960_condrec = _idaapi.I960_condrec
I960_receive = _idaapi.I960_receive
I960_intctl = _idaapi.I960_intctl
I960_icctl = _idaapi.I960_icctl
I960_dcctl = _idaapi.I960_dcctl
I960_halt = _idaapi.I960_halt
I960_send = _idaapi.I960_send
I960_sendserv = _idaapi.I960_sendserv
I960_resumprcs = _idaapi.I960_resumprcs
I960_schedprcs = _idaapi.I960_schedprcs
I960_saveprcs = _idaapi.I960_saveprcs
I960_condwait = _idaapi.I960_condwait
I960_wait = _idaapi.I960_wait
I960_signal = _idaapi.I960_signal
I960_ldtime = _idaapi.I960_ldtime
I960_addono = _idaapi.I960_addono
I960_addino = _idaapi.I960_addino
I960_subono = _idaapi.I960_subono
I960_subino = _idaapi.I960_subino
I960_selno = _idaapi.I960_selno
I960_addog = _idaapi.I960_addog
I960_addig = _idaapi.I960_addig
I960_subog = _idaapi.I960_subog
I960_subig = _idaapi.I960_subig
I960_selg = _idaapi.I960_selg
I960_addoe = _idaapi.I960_addoe
I960_addie = _idaapi.I960_addie
I960_suboe = _idaapi.I960_suboe
I960_subie = _idaapi.I960_subie
I960_sele = _idaapi.I960_sele
I960_addoge = _idaapi.I960_addoge
I960_addige = _idaapi.I960_addige
I960_suboge = _idaapi.I960_suboge
I960_subige = _idaapi.I960_subige
I960_selge = _idaapi.I960_selge
I960_addol = _idaapi.I960_addol
I960_addil = _idaapi.I960_addil
I960_subol = _idaapi.I960_subol
I960_subil = _idaapi.I960_subil
I960_sell = _idaapi.I960_sell
I960_addone = _idaapi.I960_addone
I960_addine = _idaapi.I960_addine
I960_subone = _idaapi.I960_subone
I960_subine = _idaapi.I960_subine
I960_selne = _idaapi.I960_selne
I960_addole = _idaapi.I960_addole
I960_addile = _idaapi.I960_addile
I960_subole = _idaapi.I960_subole
I960_subile = _idaapi.I960_subile
I960_selle = _idaapi.I960_selle
I960_addoo = _idaapi.I960_addoo
I960_addio = _idaapi.I960_addio
I960_suboo = _idaapi.I960_suboo
I960_subio = _idaapi.I960_subio
I960_selo = _idaapi.I960_selo
I960_faddr = _idaapi.I960_faddr
I960_fp_first = _idaapi.I960_fp_first
I960_faddrl = _idaapi.I960_faddrl
I960_fatanr = _idaapi.I960_fatanr
I960_fatanrl = _idaapi.I960_fatanrl
I960_fclassr = _idaapi.I960_fclassr
I960_fclassrl = _idaapi.I960_fclassrl
I960_fcmpor = _idaapi.I960_fcmpor
I960_fcmporl = _idaapi.I960_fcmporl
I960_fcmpr = _idaapi.I960_fcmpr
I960_fcmprl = _idaapi.I960_fcmprl
I960_fcosr = _idaapi.I960_fcosr
I960_fcosrl = _idaapi.I960_fcosrl
I960_fcpyrsre = _idaapi.I960_fcpyrsre
I960_fcpysre = _idaapi.I960_fcpysre
I960_fcvtilr = _idaapi.I960_fcvtilr
I960_fcvtir = _idaapi.I960_fcvtir
I960_fcvtri = _idaapi.I960_fcvtri
I960_fcvtril = _idaapi.I960_fcvtril
I960_fcvtzri = _idaapi.I960_fcvtzri
I960_fcvtzril = _idaapi.I960_fcvtzril
I960_fdivr = _idaapi.I960_fdivr
I960_fdivrl = _idaapi.I960_fdivrl
I960_fexpr = _idaapi.I960_fexpr
I960_fexprl = _idaapi.I960_fexprl
I960_flogbnr = _idaapi.I960_flogbnr
I960_flogbnrl = _idaapi.I960_flogbnrl
I960_flogepr = _idaapi.I960_flogepr
I960_flogeprl = _idaapi.I960_flogeprl
I960_flogr = _idaapi.I960_flogr
I960_flogrl = _idaapi.I960_flogrl
I960_fmovr = _idaapi.I960_fmovr
I960_fmovre = _idaapi.I960_fmovre
I960_fmovrl = _idaapi.I960_fmovrl
I960_fmulr = _idaapi.I960_fmulr
I960_fmulrl = _idaapi.I960_fmulrl
I960_fremr = _idaapi.I960_fremr
I960_fremrl = _idaapi.I960_fremrl
I960_froundr = _idaapi.I960_froundr
I960_froundrl = _idaapi.I960_froundrl
I960_fscaler = _idaapi.I960_fscaler
I960_fscalerl = _idaapi.I960_fscalerl
I960_fsinr = _idaapi.I960_fsinr
I960_fsinrl = _idaapi.I960_fsinrl
I960_fsqrtr = _idaapi.I960_fsqrtr
I960_fsqrtrl = _idaapi.I960_fsqrtrl
I960_fsubr = _idaapi.I960_fsubr
I960_fsubrl = _idaapi.I960_fsubrl
I960_ftanr = _idaapi.I960_ftanr
I960_ftanrl = _idaapi.I960_ftanrl
I960_fp_last = _idaapi.I960_fp_last
I960_last = _idaapi.I960_last
F2MC_null = _idaapi.F2MC_null
F2MC_mov = _idaapi.F2MC_mov
F2MC_movn = _idaapi.F2MC_movn
F2MC_movx = _idaapi.F2MC_movx
F2MC_xch = _idaapi.F2MC_xch
F2MC_movw = _idaapi.F2MC_movw
F2MC_xchw = _idaapi.F2MC_xchw
F2MC_movl = _idaapi.F2MC_movl
F2MC_add = _idaapi.F2MC_add
F2MC_addc1 = _idaapi.F2MC_addc1
F2MC_addc2 = _idaapi.F2MC_addc2
F2MC_adddc = _idaapi.F2MC_adddc
F2MC_sub = _idaapi.F2MC_sub
F2MC_subc1 = _idaapi.F2MC_subc1
F2MC_subc2 = _idaapi.F2MC_subc2
F2MC_subdc = _idaapi.F2MC_subdc
F2MC_addw1 = _idaapi.F2MC_addw1
F2MC_addw2 = _idaapi.F2MC_addw2
F2MC_addcw = _idaapi.F2MC_addcw
F2MC_subw1 = _idaapi.F2MC_subw1
F2MC_subw2 = _idaapi.F2MC_subw2
F2MC_subcw = _idaapi.F2MC_subcw
F2MC_addl = _idaapi.F2MC_addl
F2MC_subl = _idaapi.F2MC_subl
F2MC_inc = _idaapi.F2MC_inc
F2MC_dec = _idaapi.F2MC_dec
F2MC_incw = _idaapi.F2MC_incw
F2MC_decw = _idaapi.F2MC_decw
F2MC_incl = _idaapi.F2MC_incl
F2MC_decl = _idaapi.F2MC_decl
F2MC_cmp1 = _idaapi.F2MC_cmp1
F2MC_cmp2 = _idaapi.F2MC_cmp2
F2MC_cmpw1 = _idaapi.F2MC_cmpw1
F2MC_cmpw2 = _idaapi.F2MC_cmpw2
F2MC_cmpl = _idaapi.F2MC_cmpl
F2MC_divu1 = _idaapi.F2MC_divu1
F2MC_divu2 = _idaapi.F2MC_divu2
F2MC_divuw = _idaapi.F2MC_divuw
F2MC_mulu1 = _idaapi.F2MC_mulu1
F2MC_mulu2 = _idaapi.F2MC_mulu2
F2MC_muluw1 = _idaapi.F2MC_muluw1
F2MC_muluw2 = _idaapi.F2MC_muluw2
F2MC_div1 = _idaapi.F2MC_div1
F2MC_div2 = _idaapi.F2MC_div2
F2MC_divw = _idaapi.F2MC_divw
F2MC_mul1 = _idaapi.F2MC_mul1
F2MC_mul2 = _idaapi.F2MC_mul2
F2MC_mulw1 = _idaapi.F2MC_mulw1
F2MC_mulw2 = _idaapi.F2MC_mulw2
F2MC_and = _idaapi.F2MC_and
F2MC_or = _idaapi.F2MC_or
F2MC_xor = _idaapi.F2MC_xor
F2MC_not = _idaapi.F2MC_not
F2MC_andw1 = _idaapi.F2MC_andw1
F2MC_andw2 = _idaapi.F2MC_andw2
F2MC_orw1 = _idaapi.F2MC_orw1
F2MC_orw2 = _idaapi.F2MC_orw2
F2MC_xorw1 = _idaapi.F2MC_xorw1
F2MC_xorw2 = _idaapi.F2MC_xorw2
F2MC_notw = _idaapi.F2MC_notw
F2MC_andl = _idaapi.F2MC_andl
F2MC_orl = _idaapi.F2MC_orl
F2MC_xorl = _idaapi.F2MC_xorl
F2MC_neg = _idaapi.F2MC_neg
F2MC_negw = _idaapi.F2MC_negw
F2MC_nrml = _idaapi.F2MC_nrml
F2MC_rorc = _idaapi.F2MC_rorc
F2MC_rolc = _idaapi.F2MC_rolc
F2MC_asr = _idaapi.F2MC_asr
F2MC_lsr = _idaapi.F2MC_lsr
F2MC_lsl = _idaapi.F2MC_lsl
F2MC_asrw1 = _idaapi.F2MC_asrw1
F2MC_asrw2 = _idaapi.F2MC_asrw2
F2MC_lsrw1 = _idaapi.F2MC_lsrw1
F2MC_lsrw2 = _idaapi.F2MC_lsrw2
F2MC_lslw1 = _idaapi.F2MC_lslw1
F2MC_lslw2 = _idaapi.F2MC_lslw2
F2MC_asrl = _idaapi.F2MC_asrl
F2MC_lsrl = _idaapi.F2MC_lsrl
F2MC_lsll = _idaapi.F2MC_lsll
F2MC_bz = _idaapi.F2MC_bz
F2MC_bnz = _idaapi.F2MC_bnz
F2MC_bc = _idaapi.F2MC_bc
F2MC_bnc = _idaapi.F2MC_bnc
F2MC_bn = _idaapi.F2MC_bn
F2MC_bp = _idaapi.F2MC_bp
F2MC_bv = _idaapi.F2MC_bv
F2MC_bnv = _idaapi.F2MC_bnv
F2MC_bt = _idaapi.F2MC_bt
F2MC_bnt = _idaapi.F2MC_bnt
F2MC_blt = _idaapi.F2MC_blt
F2MC_bge = _idaapi.F2MC_bge
F2MC_ble = _idaapi.F2MC_ble
F2MC_bgt = _idaapi.F2MC_bgt
F2MC_bls = _idaapi.F2MC_bls
F2MC_bhi = _idaapi.F2MC_bhi
F2MC_bra = _idaapi.F2MC_bra
F2MC_jmp = _idaapi.F2MC_jmp
F2MC_jmpp = _idaapi.F2MC_jmpp
F2MC_call = _idaapi.F2MC_call
F2MC_callv = _idaapi.F2MC_callv
F2MC_callp = _idaapi.F2MC_callp
F2MC_cbne = _idaapi.F2MC_cbne
F2MC_cwbne = _idaapi.F2MC_cwbne
F2MC_dbnz = _idaapi.F2MC_dbnz
F2MC_dwbnz = _idaapi.F2MC_dwbnz
F2MC_int = _idaapi.F2MC_int
F2MC_intp = _idaapi.F2MC_intp
F2MC_int9 = _idaapi.F2MC_int9
F2MC_reti = _idaapi.F2MC_reti
F2MC_link = _idaapi.F2MC_link
F2MC_unlink = _idaapi.F2MC_unlink
F2MC_ret = _idaapi.F2MC_ret
F2MC_retp = _idaapi.F2MC_retp
F2MC_pushw = _idaapi.F2MC_pushw
F2MC_popw = _idaapi.F2MC_popw
F2MC_jctx = _idaapi.F2MC_jctx
F2MC_movea = _idaapi.F2MC_movea
F2MC_addsp = _idaapi.F2MC_addsp
F2MC_nop = _idaapi.F2MC_nop
F2MC_adb = _idaapi.F2MC_adb
F2MC_dtb = _idaapi.F2MC_dtb
F2MC_pcb = _idaapi.F2MC_pcb
F2MC_spb = _idaapi.F2MC_spb
F2MC_ncc = _idaapi.F2MC_ncc
F2MC_cmr = _idaapi.F2MC_cmr
F2MC_movb = _idaapi.F2MC_movb
F2MC_setb = _idaapi.F2MC_setb
F2MC_clrb = _idaapi.F2MC_clrb
F2MC_bbc = _idaapi.F2MC_bbc
F2MC_bbs = _idaapi.F2MC_bbs
F2MC_sbbs = _idaapi.F2MC_sbbs
F2MC_wbts = _idaapi.F2MC_wbts
F2MC_wbtc = _idaapi.F2MC_wbtc
F2MC_swap = _idaapi.F2MC_swap
F2MC_swapw = _idaapi.F2MC_swapw
F2MC_ext = _idaapi.F2MC_ext
F2MC_extw = _idaapi.F2MC_extw
F2MC_zext = _idaapi.F2MC_zext
F2MC_zextw = _idaapi.F2MC_zextw
F2MC_movsi = _idaapi.F2MC_movsi
F2MC_movsd = _idaapi.F2MC_movsd
F2MC_sceqi = _idaapi.F2MC_sceqi
F2MC_sceqd = _idaapi.F2MC_sceqd
F2MC_filsi = _idaapi.F2MC_filsi
F2MC_movswi = _idaapi.F2MC_movswi
F2MC_movswd = _idaapi.F2MC_movswd
F2MC_scweqi = _idaapi.F2MC_scweqi
F2MC_scweqd = _idaapi.F2MC_scweqd
F2MC_filswi = _idaapi.F2MC_filswi
F2MC_bz16 = _idaapi.F2MC_bz16
F2MC_bnz16 = _idaapi.F2MC_bnz16
F2MC_bc16 = _idaapi.F2MC_bc16
F2MC_bnc16 = _idaapi.F2MC_bnc16
F2MC_bn16 = _idaapi.F2MC_bn16
F2MC_bp16 = _idaapi.F2MC_bp16
F2MC_bv16 = _idaapi.F2MC_bv16
F2MC_bnv16 = _idaapi.F2MC_bnv16
F2MC_bt16 = _idaapi.F2MC_bt16
F2MC_bnt16 = _idaapi.F2MC_bnt16
F2MC_blt16 = _idaapi.F2MC_blt16
F2MC_bge16 = _idaapi.F2MC_bge16
F2MC_ble16 = _idaapi.F2MC_ble16
F2MC_bgt16 = _idaapi.F2MC_bgt16
F2MC_bls16 = _idaapi.F2MC_bls16
F2MC_bhi16 = _idaapi.F2MC_bhi16
F2MC_cbne16 = _idaapi.F2MC_cbne16
F2MC_cwbne16 = _idaapi.F2MC_cwbne16
F2MC_dbnz16 = _idaapi.F2MC_dbnz16
F2MC_dwbnz16 = _idaapi.F2MC_dwbnz16
F2MC_bbc16 = _idaapi.F2MC_bbc16
F2MC_bbs16 = _idaapi.F2MC_bbs16
F2MC_sbbs16 = _idaapi.F2MC_sbbs16
F2MC_last = _idaapi.F2MC_last
TMS320C3X_null = _idaapi.TMS320C3X_null
TMS320C3X_ABSF = _idaapi.TMS320C3X_ABSF
TMS320C3X_ABSI = _idaapi.TMS320C3X_ABSI
TMS320C3X_ADDC = _idaapi.TMS320C3X_ADDC
TMS320C3X_ADDF = _idaapi.TMS320C3X_ADDF
TMS320C3X_ADDI = _idaapi.TMS320C3X_ADDI
TMS320C3X_AND = _idaapi.TMS320C3X_AND
TMS320C3X_ANDN = _idaapi.TMS320C3X_ANDN
TMS320C3X_ASH = _idaapi.TMS320C3X_ASH
TMS320C3X_CMPF = _idaapi.TMS320C3X_CMPF
TMS320C3X_CMPI = _idaapi.TMS320C3X_CMPI
TMS320C3X_FIX = _idaapi.TMS320C3X_FIX
TMS320C3X_FLOAT = _idaapi.TMS320C3X_FLOAT
TMS320C3X_IDLE = _idaapi.TMS320C3X_IDLE
TMS320C3X_IDLE2 = _idaapi.TMS320C3X_IDLE2
TMS320C3X_LDE = _idaapi.TMS320C3X_LDE
TMS320C3X_LDF = _idaapi.TMS320C3X_LDF
TMS320C3X_LDFI = _idaapi.TMS320C3X_LDFI
TMS320C3X_LDI = _idaapi.TMS320C3X_LDI
TMS320C3X_LDII = _idaapi.TMS320C3X_LDII
TMS320C3X_LDM = _idaapi.TMS320C3X_LDM
TMS320C3X_LSH = _idaapi.TMS320C3X_LSH
TMS320C3X_MPYF = _idaapi.TMS320C3X_MPYF
TMS320C3X_MPYI = _idaapi.TMS320C3X_MPYI
TMS320C3X_NEGB = _idaapi.TMS320C3X_NEGB
TMS320C3X_NEGF = _idaapi.TMS320C3X_NEGF
TMS320C3X_NEGI = _idaapi.TMS320C3X_NEGI
TMS320C3X_NOP = _idaapi.TMS320C3X_NOP
TMS320C3X_NORM = _idaapi.TMS320C3X_NORM
TMS320C3X_NOT = _idaapi.TMS320C3X_NOT
TMS320C3X_POP = _idaapi.TMS320C3X_POP
TMS320C3X_POPF = _idaapi.TMS320C3X_POPF
TMS320C3X_PUSH = _idaapi.TMS320C3X_PUSH
TMS320C3X_PUSHF = _idaapi.TMS320C3X_PUSHF
TMS320C3X_OR = _idaapi.TMS320C3X_OR
TMS320C3X_LOPOWER = _idaapi.TMS320C3X_LOPOWER
TMS320C3X_MAXSPEED = _idaapi.TMS320C3X_MAXSPEED
TMS320C3X_RND = _idaapi.TMS320C3X_RND
TMS320C3X_ROL = _idaapi.TMS320C3X_ROL
TMS320C3X_ROLC = _idaapi.TMS320C3X_ROLC
TMS320C3X_ROR = _idaapi.TMS320C3X_ROR
TMS320C3X_RORC = _idaapi.TMS320C3X_RORC
TMS320C3X_RPTS = _idaapi.TMS320C3X_RPTS
TMS320C3X_STF = _idaapi.TMS320C3X_STF
TMS320C3X_STFI = _idaapi.TMS320C3X_STFI
TMS320C3X_STI = _idaapi.TMS320C3X_STI
TMS320C3X_STII = _idaapi.TMS320C3X_STII
TMS320C3X_SIGI = _idaapi.TMS320C3X_SIGI
TMS320C3X_SUBB = _idaapi.TMS320C3X_SUBB
TMS320C3X_SUBC = _idaapi.TMS320C3X_SUBC
TMS320C3X_SUBF = _idaapi.TMS320C3X_SUBF
TMS320C3X_SUBI = _idaapi.TMS320C3X_SUBI
TMS320C3X_SUBRB = _idaapi.TMS320C3X_SUBRB
TMS320C3X_SUBRF = _idaapi.TMS320C3X_SUBRF
TMS320C3X_SUBRI = _idaapi.TMS320C3X_SUBRI
TMS320C3X_TSTB = _idaapi.TMS320C3X_TSTB
TMS320C3X_XOR = _idaapi.TMS320C3X_XOR
TMS320C3X_IACK = _idaapi.TMS320C3X_IACK
TMS320C3X_ADDC3 = _idaapi.TMS320C3X_ADDC3
TMS320C3X_ADDF3 = _idaapi.TMS320C3X_ADDF3
TMS320C3X_ADDI3 = _idaapi.TMS320C3X_ADDI3
TMS320C3X_AND3 = _idaapi.TMS320C3X_AND3
TMS320C3X_ANDN3 = _idaapi.TMS320C3X_ANDN3
TMS320C3X_ASH3 = _idaapi.TMS320C3X_ASH3
TMS320C3X_CMPF3 = _idaapi.TMS320C3X_CMPF3
TMS320C3X_CMPI3 = _idaapi.TMS320C3X_CMPI3
TMS320C3X_LSH3 = _idaapi.TMS320C3X_LSH3
TMS320C3X_MPYF3 = _idaapi.TMS320C3X_MPYF3
TMS320C3X_MPYI3 = _idaapi.TMS320C3X_MPYI3
TMS320C3X_OR3 = _idaapi.TMS320C3X_OR3
TMS320C3X_SUBB3 = _idaapi.TMS320C3X_SUBB3
TMS320C3X_SUBF3 = _idaapi.TMS320C3X_SUBF3
TMS320C3X_SUBI3 = _idaapi.TMS320C3X_SUBI3
TMS320C3X_TSTB3 = _idaapi.TMS320C3X_TSTB3
TMS320C3X_XOR3 = _idaapi.TMS320C3X_XOR3
TMS320C3X_LDFcond = _idaapi.TMS320C3X_LDFcond
TMS320C3X_LDIcond = _idaapi.TMS320C3X_LDIcond
TMS320C3X_BR = _idaapi.TMS320C3X_BR
TMS320C3X_BRD = _idaapi.TMS320C3X_BRD
TMS320C3X_CALL = _idaapi.TMS320C3X_CALL
TMS320C3X_RPTB = _idaapi.TMS320C3X_RPTB
TMS320C3X_SWI = _idaapi.TMS320C3X_SWI
TMS320C3X_Bcond = _idaapi.TMS320C3X_Bcond
TMS320C3X_DBcond = _idaapi.TMS320C3X_DBcond
TMS320C3X_CALLcond = _idaapi.TMS320C3X_CALLcond
TMS320C3X_TRAPcond = _idaapi.TMS320C3X_TRAPcond
TMS320C3X_RETIcond = _idaapi.TMS320C3X_RETIcond
TMS320C3X_RETScond = _idaapi.TMS320C3X_RETScond
TMS320C3X_RETIU = _idaapi.TMS320C3X_RETIU
TMS320C3X_RETSU = _idaapi.TMS320C3X_RETSU
TMS320C3X_NONE = _idaapi.TMS320C3X_NONE
TMS320C3X_MV_IDX = _idaapi.TMS320C3X_MV_IDX
TMS320C3X_last = _idaapi.TMS320C3X_last
TMS320C54_null = _idaapi.TMS320C54_null
TMS320C54_add1 = _idaapi.TMS320C54_add1
TMS320C54_add2 = _idaapi.TMS320C54_add2
TMS320C54_add3 = _idaapi.TMS320C54_add3
TMS320C54_addc = _idaapi.TMS320C54_addc
TMS320C54_addm = _idaapi.TMS320C54_addm
TMS320C54_adds = _idaapi.TMS320C54_adds
TMS320C54_sub1 = _idaapi.TMS320C54_sub1
TMS320C54_sub2 = _idaapi.TMS320C54_sub2
TMS320C54_sub3 = _idaapi.TMS320C54_sub3
TMS320C54_subb = _idaapi.TMS320C54_subb
TMS320C54_subc = _idaapi.TMS320C54_subc
TMS320C54_subs = _idaapi.TMS320C54_subs
TMS320C54_mpy2 = _idaapi.TMS320C54_mpy2
TMS320C54_mpy3 = _idaapi.TMS320C54_mpy3
TMS320C54_mpyr2 = _idaapi.TMS320C54_mpyr2
TMS320C54_mpya = _idaapi.TMS320C54_mpya
TMS320C54_mpyu = _idaapi.TMS320C54_mpyu
TMS320C54_squr = _idaapi.TMS320C54_squr
TMS320C54_mac2 = _idaapi.TMS320C54_mac2
TMS320C54_mac3 = _idaapi.TMS320C54_mac3
TMS320C54_macr2 = _idaapi.TMS320C54_macr2
TMS320C54_macr3 = _idaapi.TMS320C54_macr3
TMS320C54_maca1 = _idaapi.TMS320C54_maca1
TMS320C54_maca2 = _idaapi.TMS320C54_maca2
TMS320C54_maca3 = _idaapi.TMS320C54_maca3
TMS320C54_macar1 = _idaapi.TMS320C54_macar1
TMS320C54_macar2 = _idaapi.TMS320C54_macar2
TMS320C54_macar3 = _idaapi.TMS320C54_macar3
TMS320C54_macd = _idaapi.TMS320C54_macd
TMS320C54_macp = _idaapi.TMS320C54_macp
TMS320C54_macsu = _idaapi.TMS320C54_macsu
TMS320C54_mas2 = _idaapi.TMS320C54_mas2
TMS320C54_mas3 = _idaapi.TMS320C54_mas3
TMS320C54_masr2 = _idaapi.TMS320C54_masr2
TMS320C54_masr3 = _idaapi.TMS320C54_masr3
TMS320C54_masa1 = _idaapi.TMS320C54_masa1
TMS320C54_masa2 = _idaapi.TMS320C54_masa2
TMS320C54_masa3 = _idaapi.TMS320C54_masa3
TMS320C54_masar1 = _idaapi.TMS320C54_masar1
TMS320C54_masar2 = _idaapi.TMS320C54_masar2
TMS320C54_masar3 = _idaapi.TMS320C54_masar3
TMS320C54_squra = _idaapi.TMS320C54_squra
TMS320C54_squrs = _idaapi.TMS320C54_squrs
TMS320C54_dadd2 = _idaapi.TMS320C54_dadd2
TMS320C54_dadd3 = _idaapi.TMS320C54_dadd3
TMS320C54_dadst = _idaapi.TMS320C54_dadst
TMS320C54_drsub = _idaapi.TMS320C54_drsub
TMS320C54_dsadt = _idaapi.TMS320C54_dsadt
TMS320C54_dsub = _idaapi.TMS320C54_dsub
TMS320C54_dsubt = _idaapi.TMS320C54_dsubt
TMS320C54_abdst = _idaapi.TMS320C54_abdst
TMS320C54_abs1 = _idaapi.TMS320C54_abs1
TMS320C54_abs2 = _idaapi.TMS320C54_abs2
TMS320C54_cmpl1 = _idaapi.TMS320C54_cmpl1
TMS320C54_cmpl2 = _idaapi.TMS320C54_cmpl2
TMS320C54_delay = _idaapi.TMS320C54_delay
TMS320C54_exp = _idaapi.TMS320C54_exp
TMS320C54_firs = _idaapi.TMS320C54_firs
TMS320C54_lms = _idaapi.TMS320C54_lms
TMS320C54_max = _idaapi.TMS320C54_max
TMS320C54_min = _idaapi.TMS320C54_min
TMS320C54_neg1 = _idaapi.TMS320C54_neg1
TMS320C54_neg2 = _idaapi.TMS320C54_neg2
TMS320C54_norm1 = _idaapi.TMS320C54_norm1
TMS320C54_norm2 = _idaapi.TMS320C54_norm2
TMS320C54_poly = _idaapi.TMS320C54_poly
TMS320C54_rnd1 = _idaapi.TMS320C54_rnd1
TMS320C54_rnd2 = _idaapi.TMS320C54_rnd2
TMS320C54_sat = _idaapi.TMS320C54_sat
TMS320C54_sqdst = _idaapi.TMS320C54_sqdst
TMS320C54_and1 = _idaapi.TMS320C54_and1
TMS320C54_and2 = _idaapi.TMS320C54_and2
TMS320C54_and3 = _idaapi.TMS320C54_and3
TMS320C54_andm = _idaapi.TMS320C54_andm
TMS320C54_or1 = _idaapi.TMS320C54_or1
TMS320C54_or2 = _idaapi.TMS320C54_or2
TMS320C54_or3 = _idaapi.TMS320C54_or3
TMS320C54_orm = _idaapi.TMS320C54_orm
TMS320C54_xor1 = _idaapi.TMS320C54_xor1
TMS320C54_xor2 = _idaapi.TMS320C54_xor2
TMS320C54_xor3 = _idaapi.TMS320C54_xor3
TMS320C54_xorm = _idaapi.TMS320C54_xorm
TMS320C54_rol = _idaapi.TMS320C54_rol
TMS320C54_roltc = _idaapi.TMS320C54_roltc
TMS320C54_ror = _idaapi.TMS320C54_ror
TMS320C54_sfta2 = _idaapi.TMS320C54_sfta2
TMS320C54_sfta3 = _idaapi.TMS320C54_sfta3
TMS320C54_sftc = _idaapi.TMS320C54_sftc
TMS320C54_sftl2 = _idaapi.TMS320C54_sftl2
TMS320C54_sftl3 = _idaapi.TMS320C54_sftl3
TMS320C54_bit = _idaapi.TMS320C54_bit
TMS320C54_bitf = _idaapi.TMS320C54_bitf
TMS320C54_bitt = _idaapi.TMS320C54_bitt
TMS320C54_cmpm = _idaapi.TMS320C54_cmpm
TMS320C54_cmpr = _idaapi.TMS320C54_cmpr
TMS320C54_b = _idaapi.TMS320C54_b
TMS320C54_bd = _idaapi.TMS320C54_bd
TMS320C54_bacc = _idaapi.TMS320C54_bacc
TMS320C54_baccd = _idaapi.TMS320C54_baccd
TMS320C54_banz = _idaapi.TMS320C54_banz
TMS320C54_banzd = _idaapi.TMS320C54_banzd
TMS320C54_bc2 = _idaapi.TMS320C54_bc2
TMS320C54_bc3 = _idaapi.TMS320C54_bc3
TMS320C54_bcd2 = _idaapi.TMS320C54_bcd2
TMS320C54_bcd3 = _idaapi.TMS320C54_bcd3
TMS320C54_fb = _idaapi.TMS320C54_fb
TMS320C54_fbd = _idaapi.TMS320C54_fbd
TMS320C54_fbacc = _idaapi.TMS320C54_fbacc
TMS320C54_fbaccd = _idaapi.TMS320C54_fbaccd
TMS320C54_cala = _idaapi.TMS320C54_cala
TMS320C54_calad = _idaapi.TMS320C54_calad
TMS320C54_call = _idaapi.TMS320C54_call
TMS320C54_calld = _idaapi.TMS320C54_calld
TMS320C54_cc2 = _idaapi.TMS320C54_cc2
TMS320C54_cc3 = _idaapi.TMS320C54_cc3
TMS320C54_ccd2 = _idaapi.TMS320C54_ccd2
TMS320C54_ccd3 = _idaapi.TMS320C54_ccd3
TMS320C54_fcala = _idaapi.TMS320C54_fcala
TMS320C54_fcalad = _idaapi.TMS320C54_fcalad
TMS320C54_fcall = _idaapi.TMS320C54_fcall
TMS320C54_fcalld = _idaapi.TMS320C54_fcalld
TMS320C54_intr = _idaapi.TMS320C54_intr
TMS320C54_trap = _idaapi.TMS320C54_trap
TMS320C54_fret = _idaapi.TMS320C54_fret
TMS320C54_fretd = _idaapi.TMS320C54_fretd
TMS320C54_frete = _idaapi.TMS320C54_frete
TMS320C54_freted = _idaapi.TMS320C54_freted
TMS320C54_rc1 = _idaapi.TMS320C54_rc1
TMS320C54_rc2 = _idaapi.TMS320C54_rc2
TMS320C54_rc3 = _idaapi.TMS320C54_rc3
TMS320C54_rcd1 = _idaapi.TMS320C54_rcd1
TMS320C54_rcd2 = _idaapi.TMS320C54_rcd2
TMS320C54_rcd3 = _idaapi.TMS320C54_rcd3
TMS320C54_ret = _idaapi.TMS320C54_ret
TMS320C54_retd = _idaapi.TMS320C54_retd
TMS320C54_rete = _idaapi.TMS320C54_rete
TMS320C54_reted = _idaapi.TMS320C54_reted
TMS320C54_retf = _idaapi.TMS320C54_retf
TMS320C54_retfd = _idaapi.TMS320C54_retfd
TMS320C54_rpt = _idaapi.TMS320C54_rpt
TMS320C54_rptb = _idaapi.TMS320C54_rptb
TMS320C54_rptbd = _idaapi.TMS320C54_rptbd
TMS320C54_rptz = _idaapi.TMS320C54_rptz
TMS320C54_frame = _idaapi.TMS320C54_frame
TMS320C54_popd = _idaapi.TMS320C54_popd
TMS320C54_popm = _idaapi.TMS320C54_popm
TMS320C54_pshd = _idaapi.TMS320C54_pshd
TMS320C54_pshm = _idaapi.TMS320C54_pshm
TMS320C54_idle = _idaapi.TMS320C54_idle
TMS320C54_mar = _idaapi.TMS320C54_mar
TMS320C54_nop = _idaapi.TMS320C54_nop
TMS320C54_reset = _idaapi.TMS320C54_reset
TMS320C54_rsbx1 = _idaapi.TMS320C54_rsbx1
TMS320C54_rsbx2 = _idaapi.TMS320C54_rsbx2
TMS320C54_ssbx1 = _idaapi.TMS320C54_ssbx1
TMS320C54_ssbx2 = _idaapi.TMS320C54_ssbx2
TMS320C54_xc2 = _idaapi.TMS320C54_xc2
TMS320C54_xc3 = _idaapi.TMS320C54_xc3
TMS320C54_dld = _idaapi.TMS320C54_dld
TMS320C54_ld1 = _idaapi.TMS320C54_ld1
TMS320C54_ld2 = _idaapi.TMS320C54_ld2
TMS320C54_ld3 = _idaapi.TMS320C54_ld3
TMS320C54_ldm = _idaapi.TMS320C54_ldm
TMS320C54_ldr = _idaapi.TMS320C54_ldr
TMS320C54_ldu = _idaapi.TMS320C54_ldu
TMS320C54_ltd = _idaapi.TMS320C54_ltd
TMS320C54_dst = _idaapi.TMS320C54_dst
TMS320C54_st = _idaapi.TMS320C54_st
TMS320C54_sth2 = _idaapi.TMS320C54_sth2
TMS320C54_sth3 = _idaapi.TMS320C54_sth3
TMS320C54_stl2 = _idaapi.TMS320C54_stl2
TMS320C54_stl3 = _idaapi.TMS320C54_stl3
TMS320C54_stlm = _idaapi.TMS320C54_stlm
TMS320C54_stm = _idaapi.TMS320C54_stm
TMS320C54_cmps = _idaapi.TMS320C54_cmps
TMS320C54_saccd = _idaapi.TMS320C54_saccd
TMS320C54_srccd = _idaapi.TMS320C54_srccd
TMS320C54_strcd = _idaapi.TMS320C54_strcd
TMS320C54_st_ld = _idaapi.TMS320C54_st_ld
TMS320C54_ld_mac = _idaapi.TMS320C54_ld_mac
TMS320C54_ld_macr = _idaapi.TMS320C54_ld_macr
TMS320C54_ld_mas = _idaapi.TMS320C54_ld_mas
TMS320C54_ld_masr = _idaapi.TMS320C54_ld_masr
TMS320C54_st_add = _idaapi.TMS320C54_st_add
TMS320C54_st_sub = _idaapi.TMS320C54_st_sub
TMS320C54_st_mac = _idaapi.TMS320C54_st_mac
TMS320C54_st_macr = _idaapi.TMS320C54_st_macr
TMS320C54_st_mas = _idaapi.TMS320C54_st_mas
TMS320C54_st_masr = _idaapi.TMS320C54_st_masr
TMS320C54_st_mpy = _idaapi.TMS320C54_st_mpy
TMS320C54_mvdd = _idaapi.TMS320C54_mvdd
TMS320C54_mvdk = _idaapi.TMS320C54_mvdk
TMS320C54_mvdm = _idaapi.TMS320C54_mvdm
TMS320C54_mvdp = _idaapi.TMS320C54_mvdp
TMS320C54_mvkd = _idaapi.TMS320C54_mvkd
TMS320C54_mvmd = _idaapi.TMS320C54_mvmd
TMS320C54_mvmm = _idaapi.TMS320C54_mvmm
TMS320C54_mvpd = _idaapi.TMS320C54_mvpd
TMS320C54_portr = _idaapi.TMS320C54_portr
TMS320C54_portw = _idaapi.TMS320C54_portw
TMS320C54_reada = _idaapi.TMS320C54_reada
TMS320C54_writa = _idaapi.TMS320C54_writa
TMS320C54_last = _idaapi.TMS320C54_last
TMS320C55_null = _idaapi.TMS320C55_null
TMS320C55_abdst = _idaapi.TMS320C55_abdst
TMS320C55_abs1 = _idaapi.TMS320C55_abs1
TMS320C55_abs2 = _idaapi.TMS320C55_abs2
TMS320C55_add1 = _idaapi.TMS320C55_add1
TMS320C55_add2 = _idaapi.TMS320C55_add2
TMS320C55_add3 = _idaapi.TMS320C55_add3
TMS320C55_add4 = _idaapi.TMS320C55_add4
TMS320C55_addv1 = _idaapi.TMS320C55_addv1
TMS320C55_addv2 = _idaapi.TMS320C55_addv2
TMS320C55_addrv1 = _idaapi.TMS320C55_addrv1
TMS320C55_addrv2 = _idaapi.TMS320C55_addrv2
TMS320C55_maxdiff = _idaapi.TMS320C55_maxdiff
TMS320C55_dmaxdiff = _idaapi.TMS320C55_dmaxdiff
TMS320C55_mindiff = _idaapi.TMS320C55_mindiff
TMS320C55_dmindiff = _idaapi.TMS320C55_dmindiff
TMS320C55_addsubcc4 = _idaapi.TMS320C55_addsubcc4
TMS320C55_addsubcc5 = _idaapi.TMS320C55_addsubcc5
TMS320C55_addsub2cc = _idaapi.TMS320C55_addsub2cc
TMS320C55_sftcc = _idaapi.TMS320C55_sftcc
TMS320C55_subc2 = _idaapi.TMS320C55_subc2
TMS320C55_subc3 = _idaapi.TMS320C55_subc3
TMS320C55_addsub = _idaapi.TMS320C55_addsub
TMS320C55_subadd = _idaapi.TMS320C55_subadd
TMS320C55_mpy_mpy = _idaapi.TMS320C55_mpy_mpy
TMS320C55_mpy_mpyr = _idaapi.TMS320C55_mpy_mpyr
TMS320C55_mpy_mpy40 = _idaapi.TMS320C55_mpy_mpy40
TMS320C55_mpy_mpyr40 = _idaapi.TMS320C55_mpy_mpyr40
TMS320C55_mac_mpy = _idaapi.TMS320C55_mac_mpy
TMS320C55_macr_mpyr = _idaapi.TMS320C55_macr_mpyr
TMS320C55_mac40_mpy40 = _idaapi.TMS320C55_mac40_mpy40
TMS320C55_macr40_mpyr40 = _idaapi.TMS320C55_macr40_mpyr40
TMS320C55_mas_mpy = _idaapi.TMS320C55_mas_mpy
TMS320C55_masr_mpyr = _idaapi.TMS320C55_masr_mpyr
TMS320C55_mas40_mpy40 = _idaapi.TMS320C55_mas40_mpy40
TMS320C55_masr40_mpyr40 = _idaapi.TMS320C55_masr40_mpyr40
TMS320C55_amar_mpy = _idaapi.TMS320C55_amar_mpy
TMS320C55_amar_mpyr = _idaapi.TMS320C55_amar_mpyr
TMS320C55_amar_mpy40 = _idaapi.TMS320C55_amar_mpy40
TMS320C55_amar_mpyr40 = _idaapi.TMS320C55_amar_mpyr40
TMS320C55_mac_mac = _idaapi.TMS320C55_mac_mac
TMS320C55_macr_macr = _idaapi.TMS320C55_macr_macr
TMS320C55_mac40_mac40 = _idaapi.TMS320C55_mac40_mac40
TMS320C55_macr40_macr40 = _idaapi.TMS320C55_macr40_macr40
TMS320C55_mas_mac = _idaapi.TMS320C55_mas_mac
TMS320C55_masr_macr = _idaapi.TMS320C55_masr_macr
TMS320C55_mas40_mac40 = _idaapi.TMS320C55_mas40_mac40
TMS320C55_masr40_macr40 = _idaapi.TMS320C55_masr40_macr40
TMS320C55_amar_mac = _idaapi.TMS320C55_amar_mac
TMS320C55_amar_macr = _idaapi.TMS320C55_amar_macr
TMS320C55_amar_mac40 = _idaapi.TMS320C55_amar_mac40
TMS320C55_amar_macr40 = _idaapi.TMS320C55_amar_macr40
TMS320C55_mas_mas = _idaapi.TMS320C55_mas_mas
TMS320C55_masr_masr = _idaapi.TMS320C55_masr_masr
TMS320C55_mas40_mas40 = _idaapi.TMS320C55_mas40_mas40
TMS320C55_masr40_masr40 = _idaapi.TMS320C55_masr40_masr40
TMS320C55_amar_mas = _idaapi.TMS320C55_amar_mas
TMS320C55_amar_masr = _idaapi.TMS320C55_amar_masr
TMS320C55_amar_mas40 = _idaapi.TMS320C55_amar_mas40
TMS320C55_amar_masr40 = _idaapi.TMS320C55_amar_masr40
TMS320C55_mpy_mac = _idaapi.TMS320C55_mpy_mac
TMS320C55_mpyr_macr = _idaapi.TMS320C55_mpyr_macr
TMS320C55_mpy40_mac40 = _idaapi.TMS320C55_mpy40_mac40
TMS320C55_mpyr40_macr40 = _idaapi.TMS320C55_mpyr40_macr40
TMS320C55_amar3 = _idaapi.TMS320C55_amar3
TMS320C55_firsadd = _idaapi.TMS320C55_firsadd
TMS320C55_firssub = _idaapi.TMS320C55_firssub
TMS320C55_mpym_mov = _idaapi.TMS320C55_mpym_mov
TMS320C55_mpymr_mov = _idaapi.TMS320C55_mpymr_mov
TMS320C55_macm_mov = _idaapi.TMS320C55_macm_mov
TMS320C55_macmr_mov = _idaapi.TMS320C55_macmr_mov
TMS320C55_masm_mov = _idaapi.TMS320C55_masm_mov
TMS320C55_masmr_mov = _idaapi.TMS320C55_masmr_mov
TMS320C55_add_mov = _idaapi.TMS320C55_add_mov
TMS320C55_sub_mov = _idaapi.TMS320C55_sub_mov
TMS320C55_mov_mov = _idaapi.TMS320C55_mov_mov
TMS320C55_mov_aadd = _idaapi.TMS320C55_mov_aadd
TMS320C55_mov_add = _idaapi.TMS320C55_mov_add
TMS320C55_amar_amar = _idaapi.TMS320C55_amar_amar
TMS320C55_add_asub = _idaapi.TMS320C55_add_asub
TMS320C55_btst_mov = _idaapi.TMS320C55_btst_mov
TMS320C55_mov_asub = _idaapi.TMS320C55_mov_asub
TMS320C55_lms = _idaapi.TMS320C55_lms
TMS320C55_max1 = _idaapi.TMS320C55_max1
TMS320C55_max2 = _idaapi.TMS320C55_max2
TMS320C55_min1 = _idaapi.TMS320C55_min1
TMS320C55_min2 = _idaapi.TMS320C55_min2
TMS320C55_cmp = _idaapi.TMS320C55_cmp
TMS320C55_cmpu = _idaapi.TMS320C55_cmpu
TMS320C55_aadd = _idaapi.TMS320C55_aadd
TMS320C55_asub = _idaapi.TMS320C55_asub
TMS320C55_amov = _idaapi.TMS320C55_amov
TMS320C55_amar1 = _idaapi.TMS320C55_amar1
TMS320C55_sqr1 = _idaapi.TMS320C55_sqr1
TMS320C55_sqr2 = _idaapi.TMS320C55_sqr2
TMS320C55_sqrr1 = _idaapi.TMS320C55_sqrr1
TMS320C55_sqrr2 = _idaapi.TMS320C55_sqrr2
TMS320C55_mpy1 = _idaapi.TMS320C55_mpy1
TMS320C55_mpy2 = _idaapi.TMS320C55_mpy2
TMS320C55_mpy3 = _idaapi.TMS320C55_mpy3
TMS320C55_mpyr1 = _idaapi.TMS320C55_mpyr1
TMS320C55_mpyr2 = _idaapi.TMS320C55_mpyr2
TMS320C55_mpyr3 = _idaapi.TMS320C55_mpyr3
TMS320C55_mpyk2 = _idaapi.TMS320C55_mpyk2
TMS320C55_mpyk3 = _idaapi.TMS320C55_mpyk3
TMS320C55_mpykr2 = _idaapi.TMS320C55_mpykr2
TMS320C55_mpykr3 = _idaapi.TMS320C55_mpykr3
TMS320C55_mpym2 = _idaapi.TMS320C55_mpym2
TMS320C55_mpym3 = _idaapi.TMS320C55_mpym3
TMS320C55_mpymr2 = _idaapi.TMS320C55_mpymr2
TMS320C55_mpymr3 = _idaapi.TMS320C55_mpymr3
TMS320C55_mpym403 = _idaapi.TMS320C55_mpym403
TMS320C55_mpymr403 = _idaapi.TMS320C55_mpymr403
TMS320C55_mpymu3 = _idaapi.TMS320C55_mpymu3
TMS320C55_mpymru3 = _idaapi.TMS320C55_mpymru3
TMS320C55_sqrm = _idaapi.TMS320C55_sqrm
TMS320C55_sqrmr = _idaapi.TMS320C55_sqrmr
TMS320C55_mpymk = _idaapi.TMS320C55_mpymk
TMS320C55_mpymkr = _idaapi.TMS320C55_mpymkr
TMS320C55_sqa1 = _idaapi.TMS320C55_sqa1
TMS320C55_sqa2 = _idaapi.TMS320C55_sqa2
TMS320C55_sqar1 = _idaapi.TMS320C55_sqar1
TMS320C55_sqar2 = _idaapi.TMS320C55_sqar2
TMS320C55_mac3 = _idaapi.TMS320C55_mac3
TMS320C55_mac4 = _idaapi.TMS320C55_mac4
TMS320C55_macr3 = _idaapi.TMS320C55_macr3
TMS320C55_macr4 = _idaapi.TMS320C55_macr4
TMS320C55_mack3 = _idaapi.TMS320C55_mack3
TMS320C55_mack4 = _idaapi.TMS320C55_mack4
TMS320C55_mackr3 = _idaapi.TMS320C55_mackr3
TMS320C55_mackr4 = _idaapi.TMS320C55_mackr4
TMS320C55_macm2 = _idaapi.TMS320C55_macm2
TMS320C55_macm3 = _idaapi.TMS320C55_macm3
TMS320C55_macm4 = _idaapi.TMS320C55_macm4
TMS320C55_macmr2 = _idaapi.TMS320C55_macmr2
TMS320C55_macmr3 = _idaapi.TMS320C55_macmr3
TMS320C55_macmr4 = _idaapi.TMS320C55_macmr4
TMS320C55_macm403 = _idaapi.TMS320C55_macm403
TMS320C55_macm404 = _idaapi.TMS320C55_macm404
TMS320C55_macmr403 = _idaapi.TMS320C55_macmr403
TMS320C55_macmr404 = _idaapi.TMS320C55_macmr404
TMS320C55_macmz = _idaapi.TMS320C55_macmz
TMS320C55_macmrz = _idaapi.TMS320C55_macmrz
TMS320C55_sqam2 = _idaapi.TMS320C55_sqam2
TMS320C55_sqam3 = _idaapi.TMS320C55_sqam3
TMS320C55_sqamr2 = _idaapi.TMS320C55_sqamr2
TMS320C55_sqamr3 = _idaapi.TMS320C55_sqamr3
TMS320C55_macmk3 = _idaapi.TMS320C55_macmk3
TMS320C55_macmk4 = _idaapi.TMS320C55_macmk4
TMS320C55_macmkr3 = _idaapi.TMS320C55_macmkr3
TMS320C55_macmkr4 = _idaapi.TMS320C55_macmkr4
TMS320C55_sqs1 = _idaapi.TMS320C55_sqs1
TMS320C55_sqs2 = _idaapi.TMS320C55_sqs2
TMS320C55_sqsr1 = _idaapi.TMS320C55_sqsr1
TMS320C55_sqsr2 = _idaapi.TMS320C55_sqsr2
TMS320C55_mas2 = _idaapi.TMS320C55_mas2
TMS320C55_mas3 = _idaapi.TMS320C55_mas3
TMS320C55_masr2 = _idaapi.TMS320C55_masr2
TMS320C55_masr3 = _idaapi.TMS320C55_masr3
TMS320C55_masm2 = _idaapi.TMS320C55_masm2
TMS320C55_masm3 = _idaapi.TMS320C55_masm3
TMS320C55_masm4 = _idaapi.TMS320C55_masm4
TMS320C55_masmr2 = _idaapi.TMS320C55_masmr2
TMS320C55_masmr3 = _idaapi.TMS320C55_masmr3
TMS320C55_masmr4 = _idaapi.TMS320C55_masmr4
TMS320C55_masm403 = _idaapi.TMS320C55_masm403
TMS320C55_masm404 = _idaapi.TMS320C55_masm404
TMS320C55_masmr403 = _idaapi.TMS320C55_masmr403
TMS320C55_masmr404 = _idaapi.TMS320C55_masmr404
TMS320C55_sqsm2 = _idaapi.TMS320C55_sqsm2
TMS320C55_sqsm3 = _idaapi.TMS320C55_sqsm3
TMS320C55_sqsmr2 = _idaapi.TMS320C55_sqsmr2
TMS320C55_sqsmr3 = _idaapi.TMS320C55_sqsmr3
TMS320C55_neg1 = _idaapi.TMS320C55_neg1
TMS320C55_neg2 = _idaapi.TMS320C55_neg2
TMS320C55_mant_nexp = _idaapi.TMS320C55_mant_nexp
TMS320C55_exp = _idaapi.TMS320C55_exp
TMS320C55_cmpand = _idaapi.TMS320C55_cmpand
TMS320C55_cmpandu = _idaapi.TMS320C55_cmpandu
TMS320C55_cmpor = _idaapi.TMS320C55_cmpor
TMS320C55_cmporu = _idaapi.TMS320C55_cmporu
TMS320C55_round1 = _idaapi.TMS320C55_round1
TMS320C55_round2 = _idaapi.TMS320C55_round2
TMS320C55_sat1 = _idaapi.TMS320C55_sat1
TMS320C55_sat2 = _idaapi.TMS320C55_sat2
TMS320C55_satr1 = _idaapi.TMS320C55_satr1
TMS320C55_satr2 = _idaapi.TMS320C55_satr2
TMS320C55_sfts2 = _idaapi.TMS320C55_sfts2
TMS320C55_sfts3 = _idaapi.TMS320C55_sfts3
TMS320C55_sftsc2 = _idaapi.TMS320C55_sftsc2
TMS320C55_sftsc3 = _idaapi.TMS320C55_sftsc3
TMS320C55_sqdst = _idaapi.TMS320C55_sqdst
TMS320C55_sub1 = _idaapi.TMS320C55_sub1
TMS320C55_sub2 = _idaapi.TMS320C55_sub2
TMS320C55_sub3 = _idaapi.TMS320C55_sub3
TMS320C55_sub4 = _idaapi.TMS320C55_sub4
TMS320C55_band = _idaapi.TMS320C55_band
TMS320C55_bfxpa = _idaapi.TMS320C55_bfxpa
TMS320C55_bfxtr = _idaapi.TMS320C55_bfxtr
TMS320C55_btst = _idaapi.TMS320C55_btst
TMS320C55_bnot = _idaapi.TMS320C55_bnot
TMS320C55_bclr2 = _idaapi.TMS320C55_bclr2
TMS320C55_bset2 = _idaapi.TMS320C55_bset2
TMS320C55_btstset = _idaapi.TMS320C55_btstset
TMS320C55_btstclr = _idaapi.TMS320C55_btstclr
TMS320C55_btstnot = _idaapi.TMS320C55_btstnot
TMS320C55_btstp = _idaapi.TMS320C55_btstp
TMS320C55_bclr1 = _idaapi.TMS320C55_bclr1
TMS320C55_bset1 = _idaapi.TMS320C55_bset1
TMS320C55_amar2 = _idaapi.TMS320C55_amar2
TMS320C55_popboth = _idaapi.TMS320C55_popboth
TMS320C55_pshboth = _idaapi.TMS320C55_pshboth
TMS320C55_bcnt = _idaapi.TMS320C55_bcnt
TMS320C55_not1 = _idaapi.TMS320C55_not1
TMS320C55_not2 = _idaapi.TMS320C55_not2
TMS320C55_and1 = _idaapi.TMS320C55_and1
TMS320C55_and2 = _idaapi.TMS320C55_and2
TMS320C55_and3 = _idaapi.TMS320C55_and3
TMS320C55_or1 = _idaapi.TMS320C55_or1
TMS320C55_or2 = _idaapi.TMS320C55_or2
TMS320C55_or3 = _idaapi.TMS320C55_or3
TMS320C55_xor1 = _idaapi.TMS320C55_xor1
TMS320C55_xor2 = _idaapi.TMS320C55_xor2
TMS320C55_xor3 = _idaapi.TMS320C55_xor3
TMS320C55_sftl2 = _idaapi.TMS320C55_sftl2
TMS320C55_sftl3 = _idaapi.TMS320C55_sftl3
TMS320C55_rol = _idaapi.TMS320C55_rol
TMS320C55_ror = _idaapi.TMS320C55_ror
TMS320C55_swap = _idaapi.TMS320C55_swap
TMS320C55_swapp = _idaapi.TMS320C55_swapp
TMS320C55_swap4 = _idaapi.TMS320C55_swap4
TMS320C55_mov2 = _idaapi.TMS320C55_mov2
TMS320C55_mov3 = _idaapi.TMS320C55_mov3
TMS320C55_mov402 = _idaapi.TMS320C55_mov402
TMS320C55_delay = _idaapi.TMS320C55_delay
TMS320C55_pop1 = _idaapi.TMS320C55_pop1
TMS320C55_pop2 = _idaapi.TMS320C55_pop2
TMS320C55_psh1 = _idaapi.TMS320C55_psh1
TMS320C55_psh2 = _idaapi.TMS320C55_psh2
TMS320C55_bcc = _idaapi.TMS320C55_bcc
TMS320C55_bccu = _idaapi.TMS320C55_bccu
TMS320C55_b = _idaapi.TMS320C55_b
TMS320C55_callcc = _idaapi.TMS320C55_callcc
TMS320C55_call = _idaapi.TMS320C55_call
TMS320C55_xcc = _idaapi.TMS320C55_xcc
TMS320C55_xccpart = _idaapi.TMS320C55_xccpart
TMS320C55_idle = _idaapi.TMS320C55_idle
TMS320C55_nop = _idaapi.TMS320C55_nop
TMS320C55_nop_16 = _idaapi.TMS320C55_nop_16
TMS320C55_rptblocal = _idaapi.TMS320C55_rptblocal
TMS320C55_rptb = _idaapi.TMS320C55_rptb
TMS320C55_rptcc = _idaapi.TMS320C55_rptcc
TMS320C55_rpt = _idaapi.TMS320C55_rpt
TMS320C55_rptadd = _idaapi.TMS320C55_rptadd
TMS320C55_rptsub = _idaapi.TMS320C55_rptsub
TMS320C55_retcc = _idaapi.TMS320C55_retcc
TMS320C55_ret = _idaapi.TMS320C55_ret
TMS320C55_reti = _idaapi.TMS320C55_reti
TMS320C55_intr = _idaapi.TMS320C55_intr
TMS320C55_reset = _idaapi.TMS320C55_reset
TMS320C55_trap = _idaapi.TMS320C55_trap
TMS320C55_last = _idaapi.TMS320C55_last
TRIMEDIA_null = _idaapi.TRIMEDIA_null
TRIMEDIA_igtri = _idaapi.TRIMEDIA_igtri
TRIMEDIA_igeqi = _idaapi.TRIMEDIA_igeqi
TRIMEDIA_ilesi = _idaapi.TRIMEDIA_ilesi
TRIMEDIA_ineqi = _idaapi.TRIMEDIA_ineqi
TRIMEDIA_ieqli = _idaapi.TRIMEDIA_ieqli
TRIMEDIA_iaddi = _idaapi.TRIMEDIA_iaddi
TRIMEDIA_ild16d = _idaapi.TRIMEDIA_ild16d
TRIMEDIA_ld32d = _idaapi.TRIMEDIA_ld32d
TRIMEDIA_uld8d = _idaapi.TRIMEDIA_uld8d
TRIMEDIA_lsri = _idaapi.TRIMEDIA_lsri
TRIMEDIA_asri = _idaapi.TRIMEDIA_asri
TRIMEDIA_asli = _idaapi.TRIMEDIA_asli
TRIMEDIA_iadd = _idaapi.TRIMEDIA_iadd
TRIMEDIA_isub = _idaapi.TRIMEDIA_isub
TRIMEDIA_igeq = _idaapi.TRIMEDIA_igeq
TRIMEDIA_igtr = _idaapi.TRIMEDIA_igtr
TRIMEDIA_bitand = _idaapi.TRIMEDIA_bitand
TRIMEDIA_bitor = _idaapi.TRIMEDIA_bitor
TRIMEDIA_asr = _idaapi.TRIMEDIA_asr
TRIMEDIA_asl = _idaapi.TRIMEDIA_asl
TRIMEDIA_ifloat = _idaapi.TRIMEDIA_ifloat
TRIMEDIA_ifixrz = _idaapi.TRIMEDIA_ifixrz
TRIMEDIA_fadd = _idaapi.TRIMEDIA_fadd
TRIMEDIA_imin = _idaapi.TRIMEDIA_imin
TRIMEDIA_imax = _idaapi.TRIMEDIA_imax
TRIMEDIA_iavgonep = _idaapi.TRIMEDIA_iavgonep
TRIMEDIA_ume8uu = _idaapi.TRIMEDIA_ume8uu
TRIMEDIA_imul = _idaapi.TRIMEDIA_imul
TRIMEDIA_fmul = _idaapi.TRIMEDIA_fmul
TRIMEDIA_h_st8d = _idaapi.TRIMEDIA_h_st8d
TRIMEDIA_h_st16d = _idaapi.TRIMEDIA_h_st16d
TRIMEDIA_h_st32d = _idaapi.TRIMEDIA_h_st32d
TRIMEDIA_isubi = _idaapi.TRIMEDIA_isubi
TRIMEDIA_ugtr = _idaapi.TRIMEDIA_ugtr
TRIMEDIA_ugtri = _idaapi.TRIMEDIA_ugtri
TRIMEDIA_ugeq = _idaapi.TRIMEDIA_ugeq
TRIMEDIA_ugeqi = _idaapi.TRIMEDIA_ugeqi
TRIMEDIA_ieql = _idaapi.TRIMEDIA_ieql
TRIMEDIA_ueqli = _idaapi.TRIMEDIA_ueqli
TRIMEDIA_ineq = _idaapi.TRIMEDIA_ineq
TRIMEDIA_uneqi = _idaapi.TRIMEDIA_uneqi
TRIMEDIA_ulesi = _idaapi.TRIMEDIA_ulesi
TRIMEDIA_ileqi = _idaapi.TRIMEDIA_ileqi
TRIMEDIA_uleqi = _idaapi.TRIMEDIA_uleqi
TRIMEDIA_h_iabs = _idaapi.TRIMEDIA_h_iabs
TRIMEDIA_carry = _idaapi.TRIMEDIA_carry
TRIMEDIA_izero = _idaapi.TRIMEDIA_izero
TRIMEDIA_inonzero = _idaapi.TRIMEDIA_inonzero
TRIMEDIA_bitxor = _idaapi.TRIMEDIA_bitxor
TRIMEDIA_bitandinv = _idaapi.TRIMEDIA_bitandinv
TRIMEDIA_bitinv = _idaapi.TRIMEDIA_bitinv
TRIMEDIA_sex16 = _idaapi.TRIMEDIA_sex16
TRIMEDIA_packbytes = _idaapi.TRIMEDIA_packbytes
TRIMEDIA_pack16lsb = _idaapi.TRIMEDIA_pack16lsb
TRIMEDIA_pack16msb = _idaapi.TRIMEDIA_pack16msb
TRIMEDIA_ubytesel = _idaapi.TRIMEDIA_ubytesel
TRIMEDIA_ibytesel = _idaapi.TRIMEDIA_ibytesel
TRIMEDIA_mergelsb = _idaapi.TRIMEDIA_mergelsb
TRIMEDIA_mergemsb = _idaapi.TRIMEDIA_mergemsb
TRIMEDIA_ume8ii = _idaapi.TRIMEDIA_ume8ii
TRIMEDIA_h_dspiabs = _idaapi.TRIMEDIA_h_dspiabs
TRIMEDIA_dspiadd = _idaapi.TRIMEDIA_dspiadd
TRIMEDIA_dspuadd = _idaapi.TRIMEDIA_dspuadd
TRIMEDIA_dspisub = _idaapi.TRIMEDIA_dspisub
TRIMEDIA_dspusub = _idaapi.TRIMEDIA_dspusub
TRIMEDIA_dspidualadd = _idaapi.TRIMEDIA_dspidualadd
TRIMEDIA_dspidualsub = _idaapi.TRIMEDIA_dspidualsub
TRIMEDIA_h_dspidualabs = _idaapi.TRIMEDIA_h_dspidualabs
TRIMEDIA_quadavg = _idaapi.TRIMEDIA_quadavg
TRIMEDIA_iclipi = _idaapi.TRIMEDIA_iclipi
TRIMEDIA_uclipi = _idaapi.TRIMEDIA_uclipi
TRIMEDIA_uclipu = _idaapi.TRIMEDIA_uclipu
TRIMEDIA_iflip = _idaapi.TRIMEDIA_iflip
TRIMEDIA_dspuquadaddui = _idaapi.TRIMEDIA_dspuquadaddui
TRIMEDIA_quadumin = _idaapi.TRIMEDIA_quadumin
TRIMEDIA_quadumax = _idaapi.TRIMEDIA_quadumax
TRIMEDIA_dualiclipi = _idaapi.TRIMEDIA_dualiclipi
TRIMEDIA_dualuclipi = _idaapi.TRIMEDIA_dualuclipi
TRIMEDIA_quadumulmsb = _idaapi.TRIMEDIA_quadumulmsb
TRIMEDIA_ufir8uu = _idaapi.TRIMEDIA_ufir8uu
TRIMEDIA_ifir8ui = _idaapi.TRIMEDIA_ifir8ui
TRIMEDIA_ifir8ii = _idaapi.TRIMEDIA_ifir8ii
TRIMEDIA_ifir16 = _idaapi.TRIMEDIA_ifir16
TRIMEDIA_ufir16 = _idaapi.TRIMEDIA_ufir16
TRIMEDIA_dspidualmul = _idaapi.TRIMEDIA_dspidualmul
TRIMEDIA_lsr = _idaapi.TRIMEDIA_lsr
TRIMEDIA_rol = _idaapi.TRIMEDIA_rol
TRIMEDIA_roli = _idaapi.TRIMEDIA_roli
TRIMEDIA_funshift1 = _idaapi.TRIMEDIA_funshift1
TRIMEDIA_funshift2 = _idaapi.TRIMEDIA_funshift2
TRIMEDIA_funshift3 = _idaapi.TRIMEDIA_funshift3
TRIMEDIA_dualasr = _idaapi.TRIMEDIA_dualasr
TRIMEDIA_mergedual16lsb = _idaapi.TRIMEDIA_mergedual16lsb
TRIMEDIA_fdiv = _idaapi.TRIMEDIA_fdiv
TRIMEDIA_fdivflags = _idaapi.TRIMEDIA_fdivflags
TRIMEDIA_fsqrt = _idaapi.TRIMEDIA_fsqrt
TRIMEDIA_fsqrtflags = _idaapi.TRIMEDIA_fsqrtflags
TRIMEDIA_faddflags = _idaapi.TRIMEDIA_faddflags
TRIMEDIA_fsub = _idaapi.TRIMEDIA_fsub
TRIMEDIA_fsubflags = _idaapi.TRIMEDIA_fsubflags
TRIMEDIA_fabsval = _idaapi.TRIMEDIA_fabsval
TRIMEDIA_fabsvalflags = _idaapi.TRIMEDIA_fabsvalflags
TRIMEDIA_ifloatrz = _idaapi.TRIMEDIA_ifloatrz
TRIMEDIA_ifloatrzflags = _idaapi.TRIMEDIA_ifloatrzflags
TRIMEDIA_ufloatrz = _idaapi.TRIMEDIA_ufloatrz
TRIMEDIA_ufloatrzflags = _idaapi.TRIMEDIA_ufloatrzflags
TRIMEDIA_ifixieee = _idaapi.TRIMEDIA_ifixieee
TRIMEDIA_ifixieeeflags = _idaapi.TRIMEDIA_ifixieeeflags
TRIMEDIA_ufixieee = _idaapi.TRIMEDIA_ufixieee
TRIMEDIA_ufixieeeflags = _idaapi.TRIMEDIA_ufixieeeflags
TRIMEDIA_ufixrz = _idaapi.TRIMEDIA_ufixrz
TRIMEDIA_ufixrzflags = _idaapi.TRIMEDIA_ufixrzflags
TRIMEDIA_ufloat = _idaapi.TRIMEDIA_ufloat
TRIMEDIA_ufloatflags = _idaapi.TRIMEDIA_ufloatflags
TRIMEDIA_ifixrzflags = _idaapi.TRIMEDIA_ifixrzflags
TRIMEDIA_ifloatflags = _idaapi.TRIMEDIA_ifloatflags
TRIMEDIA_umul = _idaapi.TRIMEDIA_umul
TRIMEDIA_imulm = _idaapi.TRIMEDIA_imulm
TRIMEDIA_umulm = _idaapi.TRIMEDIA_umulm
TRIMEDIA_dspimul = _idaapi.TRIMEDIA_dspimul
TRIMEDIA_dspumul = _idaapi.TRIMEDIA_dspumul
TRIMEDIA_fmulflags = _idaapi.TRIMEDIA_fmulflags
TRIMEDIA_fgtr = _idaapi.TRIMEDIA_fgtr
TRIMEDIA_fgtrflags = _idaapi.TRIMEDIA_fgtrflags
TRIMEDIA_fgeq = _idaapi.TRIMEDIA_fgeq
TRIMEDIA_fgeqflags = _idaapi.TRIMEDIA_fgeqflags
TRIMEDIA_feql = _idaapi.TRIMEDIA_feql
TRIMEDIA_feqlflags = _idaapi.TRIMEDIA_feqlflags
TRIMEDIA_fneq = _idaapi.TRIMEDIA_fneq
TRIMEDIA_fneqflags = _idaapi.TRIMEDIA_fneqflags
TRIMEDIA_fsign = _idaapi.TRIMEDIA_fsign
TRIMEDIA_fsignflags = _idaapi.TRIMEDIA_fsignflags
TRIMEDIA_cycles = _idaapi.TRIMEDIA_cycles
TRIMEDIA_hicycles = _idaapi.TRIMEDIA_hicycles
TRIMEDIA_readdpc = _idaapi.TRIMEDIA_readdpc
TRIMEDIA_readspc = _idaapi.TRIMEDIA_readspc
TRIMEDIA_readpcsw = _idaapi.TRIMEDIA_readpcsw
TRIMEDIA_writespc = _idaapi.TRIMEDIA_writespc
TRIMEDIA_writedpc = _idaapi.TRIMEDIA_writedpc
TRIMEDIA_writepcsw = _idaapi.TRIMEDIA_writepcsw
TRIMEDIA_curcycles = _idaapi.TRIMEDIA_curcycles
TRIMEDIA_jmpt = _idaapi.TRIMEDIA_jmpt
TRIMEDIA_ijmpt = _idaapi.TRIMEDIA_ijmpt
TRIMEDIA_jmpi = _idaapi.TRIMEDIA_jmpi
TRIMEDIA_ijmpi = _idaapi.TRIMEDIA_ijmpi
TRIMEDIA_jmpf = _idaapi.TRIMEDIA_jmpf
TRIMEDIA_ijmpf = _idaapi.TRIMEDIA_ijmpf
TRIMEDIA_iclr = _idaapi.TRIMEDIA_iclr
TRIMEDIA_uimm = _idaapi.TRIMEDIA_uimm
TRIMEDIA_ild8d = _idaapi.TRIMEDIA_ild8d
TRIMEDIA_ild8r = _idaapi.TRIMEDIA_ild8r
TRIMEDIA_uld8r = _idaapi.TRIMEDIA_uld8r
TRIMEDIA_ild16r = _idaapi.TRIMEDIA_ild16r
TRIMEDIA_ild16x = _idaapi.TRIMEDIA_ild16x
TRIMEDIA_uld16d = _idaapi.TRIMEDIA_uld16d
TRIMEDIA_uld16r = _idaapi.TRIMEDIA_uld16r
TRIMEDIA_uld16x = _idaapi.TRIMEDIA_uld16x
TRIMEDIA_ld32r = _idaapi.TRIMEDIA_ld32r
TRIMEDIA_ld32x = _idaapi.TRIMEDIA_ld32x
TRIMEDIA_rdtag = _idaapi.TRIMEDIA_rdtag
TRIMEDIA_rdstatus = _idaapi.TRIMEDIA_rdstatus
TRIMEDIA_dcb = _idaapi.TRIMEDIA_dcb
TRIMEDIA_dinvalid = _idaapi.TRIMEDIA_dinvalid
TRIMEDIA_prefd = _idaapi.TRIMEDIA_prefd
TRIMEDIA_prefr = _idaapi.TRIMEDIA_prefr
TRIMEDIA_pref16x = _idaapi.TRIMEDIA_pref16x
TRIMEDIA_pref32x = _idaapi.TRIMEDIA_pref32x
TRIMEDIA_allocd = _idaapi.TRIMEDIA_allocd
TRIMEDIA_allocr = _idaapi.TRIMEDIA_allocr
TRIMEDIA_allocx = _idaapi.TRIMEDIA_allocx
TRIMEDIA_nop = _idaapi.TRIMEDIA_nop
TRIMEDIA_alloc = _idaapi.TRIMEDIA_alloc
TRIMEDIA_dspiabs = _idaapi.TRIMEDIA_dspiabs
TRIMEDIA_dspidualabs = _idaapi.TRIMEDIA_dspidualabs
TRIMEDIA_iabs = _idaapi.TRIMEDIA_iabs
TRIMEDIA_ild16 = _idaapi.TRIMEDIA_ild16
TRIMEDIA_ild8 = _idaapi.TRIMEDIA_ild8
TRIMEDIA_ineg = _idaapi.TRIMEDIA_ineg
TRIMEDIA_ld32 = _idaapi.TRIMEDIA_ld32
TRIMEDIA_pref = _idaapi.TRIMEDIA_pref
TRIMEDIA_sex8 = _idaapi.TRIMEDIA_sex8
TRIMEDIA_st16 = _idaapi.TRIMEDIA_st16
TRIMEDIA_st16d = _idaapi.TRIMEDIA_st16d
TRIMEDIA_st32 = _idaapi.TRIMEDIA_st32
TRIMEDIA_st32d = _idaapi.TRIMEDIA_st32d
TRIMEDIA_st8 = _idaapi.TRIMEDIA_st8
TRIMEDIA_st8d = _idaapi.TRIMEDIA_st8d
TRIMEDIA_uld16 = _idaapi.TRIMEDIA_uld16
TRIMEDIA_uld8 = _idaapi.TRIMEDIA_uld8
TRIMEDIA_zex16 = _idaapi.TRIMEDIA_zex16
TRIMEDIA_zex8 = _idaapi.TRIMEDIA_zex8
TRIMEDIA_ident = _idaapi.TRIMEDIA_ident
TRIMEDIA_iles = _idaapi.TRIMEDIA_iles
TRIMEDIA_ileq = _idaapi.TRIMEDIA_ileq
TRIMEDIA_ules = _idaapi.TRIMEDIA_ules
TRIMEDIA_uleq = _idaapi.TRIMEDIA_uleq
TRIMEDIA_fles = _idaapi.TRIMEDIA_fles
TRIMEDIA_fleq = _idaapi.TRIMEDIA_fleq
TRIMEDIA_ueql = _idaapi.TRIMEDIA_ueql
TRIMEDIA_uneq = _idaapi.TRIMEDIA_uneq
TRIMEDIA_flesflags = _idaapi.TRIMEDIA_flesflags
TRIMEDIA_fleqflags = _idaapi.TRIMEDIA_fleqflags
TRIMEDIA_borrow = _idaapi.TRIMEDIA_borrow
TRIMEDIA_umin = _idaapi.TRIMEDIA_umin
TRIMEDIA_lsl = _idaapi.TRIMEDIA_lsl
TRIMEDIA_lsli = _idaapi.TRIMEDIA_lsli
TRIMEDIA_last = _idaapi.TRIMEDIA_last
NEC_78K_0_null = _idaapi.NEC_78K_0_null
NEC_78K_0_mov = _idaapi.NEC_78K_0_mov
NEC_78K_0_xch = _idaapi.NEC_78K_0_xch
NEC_78K_0_movw = _idaapi.NEC_78K_0_movw
NEC_78K_0_xchw = _idaapi.NEC_78K_0_xchw
NEC_78K_0_add = _idaapi.NEC_78K_0_add
NEC_78K_0_addc = _idaapi.NEC_78K_0_addc
NEC_78K_0_sub = _idaapi.NEC_78K_0_sub
NEC_78K_0_subc = _idaapi.NEC_78K_0_subc
NEC_78K_0_and = _idaapi.NEC_78K_0_and
NEC_78K_0_or = _idaapi.NEC_78K_0_or
NEC_78K_0_xor = _idaapi.NEC_78K_0_xor
NEC_78K_0_cmp = _idaapi.NEC_78K_0_cmp
NEC_78K_0_addw = _idaapi.NEC_78K_0_addw
NEC_78K_0_subw = _idaapi.NEC_78K_0_subw
NEC_78K_0_cmpw = _idaapi.NEC_78K_0_cmpw
NEC_78K_0_mulu = _idaapi.NEC_78K_0_mulu
NEC_78K_0_divuw = _idaapi.NEC_78K_0_divuw
NEC_78K_0_inc = _idaapi.NEC_78K_0_inc
NEC_78K_0_dec = _idaapi.NEC_78K_0_dec
NEC_78K_0_incw = _idaapi.NEC_78K_0_incw
NEC_78K_0_decw = _idaapi.NEC_78K_0_decw
NEC_78K_0_ror = _idaapi.NEC_78K_0_ror
NEC_78K_0_rol = _idaapi.NEC_78K_0_rol
NEC_78K_0_rorc = _idaapi.NEC_78K_0_rorc
NEC_78K_0_rolc = _idaapi.NEC_78K_0_rolc
NEC_78K_0_ror4 = _idaapi.NEC_78K_0_ror4
NEC_78K_0_rol4 = _idaapi.NEC_78K_0_rol4
NEC_78K_0_adjba = _idaapi.NEC_78K_0_adjba
NEC_78K_0_adjbs = _idaapi.NEC_78K_0_adjbs
NEC_78K_0_mov1 = _idaapi.NEC_78K_0_mov1
NEC_78K_0_and1 = _idaapi.NEC_78K_0_and1
NEC_78K_0_or1 = _idaapi.NEC_78K_0_or1
NEC_78K_0_xor1 = _idaapi.NEC_78K_0_xor1
NEC_78K_0_set1 = _idaapi.NEC_78K_0_set1
NEC_78K_0_clr1 = _idaapi.NEC_78K_0_clr1
NEC_78K_0_not1 = _idaapi.NEC_78K_0_not1
NEC_78K_0_call = _idaapi.NEC_78K_0_call
NEC_78K_0_callf = _idaapi.NEC_78K_0_callf
NEC_78K_0_callt = _idaapi.NEC_78K_0_callt
NEC_78K_0_brk = _idaapi.NEC_78K_0_brk
NEC_78K_0_ret = _idaapi.NEC_78K_0_ret
NEC_78K_0_retb = _idaapi.NEC_78K_0_retb
NEC_78K_0_reti = _idaapi.NEC_78K_0_reti
NEC_78K_0_push = _idaapi.NEC_78K_0_push
NEC_78K_0_pop = _idaapi.NEC_78K_0_pop
NEC_78K_0_br = _idaapi.NEC_78K_0_br
NEC_78K_0_bc = _idaapi.NEC_78K_0_bc
NEC_78K_0_bnc = _idaapi.NEC_78K_0_bnc
NEC_78K_0_bz = _idaapi.NEC_78K_0_bz
NEC_78K_0_bnz = _idaapi.NEC_78K_0_bnz
NEC_78K_0_bt = _idaapi.NEC_78K_0_bt
NEC_78K_0_bf = _idaapi.NEC_78K_0_bf
NEC_78K_0_btclr = _idaapi.NEC_78K_0_btclr
NEC_78K_0_dbnz = _idaapi.NEC_78K_0_dbnz
NEC_78K_0_sel = _idaapi.NEC_78K_0_sel
NEC_78K_0_nop = _idaapi.NEC_78K_0_nop
NEC_78K_0_EI = _idaapi.NEC_78K_0_EI
NEC_78K_0_DI = _idaapi.NEC_78K_0_DI
NEC_78K_0_HALT = _idaapi.NEC_78K_0_HALT
NEC_78K_0_STOP = _idaapi.NEC_78K_0_STOP
NEC_78K_0_last = _idaapi.NEC_78K_0_last
NEC_78K_0S_null = _idaapi.NEC_78K_0S_null
NEC_78K_0S_cmp = _idaapi.NEC_78K_0S_cmp
NEC_78K_0S_xor = _idaapi.NEC_78K_0S_xor
NEC_78K_0S_and = _idaapi.NEC_78K_0S_and
NEC_78K_0S_or = _idaapi.NEC_78K_0S_or
NEC_78K_0S_add = _idaapi.NEC_78K_0S_add
NEC_78K_0S_sub = _idaapi.NEC_78K_0S_sub
NEC_78K_0S_addc = _idaapi.NEC_78K_0S_addc
NEC_78K_0S_subc = _idaapi.NEC_78K_0S_subc
NEC_78K_0S_subw = _idaapi.NEC_78K_0S_subw
NEC_78K_0S_addw = _idaapi.NEC_78K_0S_addw
NEC_78K_0S_cmpw = _idaapi.NEC_78K_0S_cmpw
NEC_78K_0S_inc = _idaapi.NEC_78K_0S_inc
NEC_78K_0S_dec = _idaapi.NEC_78K_0S_dec
NEC_78K_0S_incw = _idaapi.NEC_78K_0S_incw
NEC_78K_0S_decw = _idaapi.NEC_78K_0S_decw
NEC_78K_0S_ror = _idaapi.NEC_78K_0S_ror
NEC_78K_0S_rol = _idaapi.NEC_78K_0S_rol
NEC_78K_0S_rorc = _idaapi.NEC_78K_0S_rorc
NEC_78K_0S_rolc = _idaapi.NEC_78K_0S_rolc
NEC_78K_0S_call = _idaapi.NEC_78K_0S_call
NEC_78K_0S_callt = _idaapi.NEC_78K_0S_callt
NEC_78K_0S_ret = _idaapi.NEC_78K_0S_ret
NEC_78K_0S_reti = _idaapi.NEC_78K_0S_reti
NEC_78K_0S_mov = _idaapi.NEC_78K_0S_mov
NEC_78K_0S_xch = _idaapi.NEC_78K_0S_xch
NEC_78K_0S_xchw = _idaapi.NEC_78K_0S_xchw
NEC_78K_0S_set1 = _idaapi.NEC_78K_0S_set1
NEC_78K_0S_clr1 = _idaapi.NEC_78K_0S_clr1
NEC_78K_0S_not1 = _idaapi.NEC_78K_0S_not1
NEC_78K_0S_push = _idaapi.NEC_78K_0S_push
NEC_78K_0S_pop = _idaapi.NEC_78K_0S_pop
NEC_78K_0S_movw = _idaapi.NEC_78K_0S_movw
NEC_78K_0S_br = _idaapi.NEC_78K_0S_br
NEC_78K_0S_bc = _idaapi.NEC_78K_0S_bc
NEC_78K_0S_bnc = _idaapi.NEC_78K_0S_bnc
NEC_78K_0S_bz = _idaapi.NEC_78K_0S_bz
NEC_78K_0S_bnz = _idaapi.NEC_78K_0S_bnz
NEC_78K_0S_bt = _idaapi.NEC_78K_0S_bt
NEC_78K_0S_bf = _idaapi.NEC_78K_0S_bf
NEC_78K_0S_dbnz = _idaapi.NEC_78K_0S_dbnz
NEC_78K_0S_nop = _idaapi.NEC_78K_0S_nop
NEC_78K_0S_EI = _idaapi.NEC_78K_0S_EI
NEC_78K_0S_DI = _idaapi.NEC_78K_0S_DI
NEC_78K_0S_HALT = _idaapi.NEC_78K_0S_HALT
NEC_78K_0S_STOP = _idaapi.NEC_78K_0S_STOP
NEC_78K_0S_last = _idaapi.NEC_78K_0S_last
M16C_null = _idaapi.M16C_null
M16C_abs = _idaapi.M16C_abs
M16C_adc = _idaapi.M16C_adc
M16C_adcf = _idaapi.M16C_adcf
M16C_add = _idaapi.M16C_add
M16C_adjnz = _idaapi.M16C_adjnz
M16C_and = _idaapi.M16C_and
M16C_band = _idaapi.M16C_band
M16C_bclr = _idaapi.M16C_bclr
M16C_bmcnd = _idaapi.M16C_bmcnd
M16C_bmgeu = _idaapi.M16C_bmgeu
M16C_bmgtu = _idaapi.M16C_bmgtu
M16C_bmeq = _idaapi.M16C_bmeq
M16C_bmn = _idaapi.M16C_bmn
M16C_bmle = _idaapi.M16C_bmle
M16C_bmo = _idaapi.M16C_bmo
M16C_bmge = _idaapi.M16C_bmge
M16C_bmltu = _idaapi.M16C_bmltu
M16C_bmleu = _idaapi.M16C_bmleu
M16C_bmne = _idaapi.M16C_bmne
M16C_bmpz = _idaapi.M16C_bmpz
M16C_bmgt = _idaapi.M16C_bmgt
M16C_bmno = _idaapi.M16C_bmno
M16C_bmlt = _idaapi.M16C_bmlt
M16C_bnand = _idaapi.M16C_bnand
M16C_bnor = _idaapi.M16C_bnor
M16C_bnot = _idaapi.M16C_bnot
M16C_bntst = _idaapi.M16C_bntst
M16C_bnxor = _idaapi.M16C_bnxor
M16C_bor = _idaapi.M16C_bor
M16C_brk = _idaapi.M16C_brk
M16C_bset = _idaapi.M16C_bset
M16C_btst = _idaapi.M16C_btst
M16C_btstc = _idaapi.M16C_btstc
M16C_btsts = _idaapi.M16C_btsts
M16C_bxor = _idaapi.M16C_bxor
M16C_cmp = _idaapi.M16C_cmp
M16C_dadc = _idaapi.M16C_dadc
M16C_dadd = _idaapi.M16C_dadd
M16C_dec = _idaapi.M16C_dec
M16C_div = _idaapi.M16C_div
M16C_divu = _idaapi.M16C_divu
M16C_divx = _idaapi.M16C_divx
M16C_dsbb = _idaapi.M16C_dsbb
M16C_dsub = _idaapi.M16C_dsub
M16C_enter = _idaapi.M16C_enter
M16C_exitd = _idaapi.M16C_exitd
M16C_exts = _idaapi.M16C_exts
M16C_fclr = _idaapi.M16C_fclr
M16C_fset = _idaapi.M16C_fset
M16C_inc = _idaapi.M16C_inc
M16C_int = _idaapi.M16C_int
M16C_into = _idaapi.M16C_into
M16C_jcnd = _idaapi.M16C_jcnd
M16C_jgeu = _idaapi.M16C_jgeu
M16C_jgtu = _idaapi.M16C_jgtu
M16C_jeq = _idaapi.M16C_jeq
M16C_jn = _idaapi.M16C_jn
M16C_jle = _idaapi.M16C_jle
M16C_jo = _idaapi.M16C_jo
M16C_jge = _idaapi.M16C_jge
M16C_jltu = _idaapi.M16C_jltu
M16C_jleu = _idaapi.M16C_jleu
M16C_jne = _idaapi.M16C_jne
M16C_jpz = _idaapi.M16C_jpz
M16C_jgt = _idaapi.M16C_jgt
M16C_jno = _idaapi.M16C_jno
M16C_jlt = _idaapi.M16C_jlt
M16C_jmp = _idaapi.M16C_jmp
M16C_jmpi = _idaapi.M16C_jmpi
M16C_jmps = _idaapi.M16C_jmps
M16C_jsr = _idaapi.M16C_jsr
M16C_jsri = _idaapi.M16C_jsri
M16C_jsrs = _idaapi.M16C_jsrs
M16C_ldc = _idaapi.M16C_ldc
M16C_ldctx = _idaapi.M16C_ldctx
M16C_lde = _idaapi.M16C_lde
M16C_ldintb = _idaapi.M16C_ldintb
M16C_ldipl = _idaapi.M16C_ldipl
M16C_mov = _idaapi.M16C_mov
M16C_mova = _idaapi.M16C_mova
M16C_movhh = _idaapi.M16C_movhh
M16C_movhl = _idaapi.M16C_movhl
M16C_movlh = _idaapi.M16C_movlh
M16C_movll = _idaapi.M16C_movll
M16C_mul = _idaapi.M16C_mul
M16C_mulu = _idaapi.M16C_mulu
M16C_neg = _idaapi.M16C_neg
M16C_nop = _idaapi.M16C_nop
M16C_not = _idaapi.M16C_not
M16C_or = _idaapi.M16C_or
M16C_pop = _idaapi.M16C_pop
M16C_popc = _idaapi.M16C_popc
M16C_popm = _idaapi.M16C_popm
M16C_push = _idaapi.M16C_push
M16C_pusha = _idaapi.M16C_pusha
M16C_pushc = _idaapi.M16C_pushc
M16C_pushm = _idaapi.M16C_pushm
M16C_reit = _idaapi.M16C_reit
M16C_rmpa = _idaapi.M16C_rmpa
M16C_rolc = _idaapi.M16C_rolc
M16C_rorc = _idaapi.M16C_rorc
M16C_rot = _idaapi.M16C_rot
M16C_rts = _idaapi.M16C_rts
M16C_sbb = _idaapi.M16C_sbb
M16C_sbjnz = _idaapi.M16C_sbjnz
M16C_sha = _idaapi.M16C_sha
M16C_shl = _idaapi.M16C_shl
M16C_smovb = _idaapi.M16C_smovb
M16C_smovf = _idaapi.M16C_smovf
M16C_sstr = _idaapi.M16C_sstr
M16C_stc = _idaapi.M16C_stc
M16C_stctx = _idaapi.M16C_stctx
M16C_ste = _idaapi.M16C_ste
M16C_stnz = _idaapi.M16C_stnz
M16C_stz = _idaapi.M16C_stz
M16C_stzx = _idaapi.M16C_stzx
M16C_sub = _idaapi.M16C_sub
M16C_tst = _idaapi.M16C_tst
M16C_und = _idaapi.M16C_und
M16C_wait = _idaapi.M16C_wait
M16C_xchg = _idaapi.M16C_xchg
M16C_xor = _idaapi.M16C_xor
M16C_last = _idaapi.M16C_last
m32r_null = _idaapi.m32r_null
m32r_add = _idaapi.m32r_add
m32r_add3 = _idaapi.m32r_add3
m32r_addi = _idaapi.m32r_addi
m32r_addv = _idaapi.m32r_addv
m32r_addv3 = _idaapi.m32r_addv3
m32r_addx = _idaapi.m32r_addx
m32r_and = _idaapi.m32r_and
m32r_and3 = _idaapi.m32r_and3
m32r_bc = _idaapi.m32r_bc
m32r_beq = _idaapi.m32r_beq
m32r_beqz = _idaapi.m32r_beqz
m32r_bgez = _idaapi.m32r_bgez
m32r_bgtz = _idaapi.m32r_bgtz
m32r_bl = _idaapi.m32r_bl
m32r_blez = _idaapi.m32r_blez
m32r_bltz = _idaapi.m32r_bltz
m32r_bnc = _idaapi.m32r_bnc
m32r_bne = _idaapi.m32r_bne
m32r_bnez = _idaapi.m32r_bnez
m32r_bra = _idaapi.m32r_bra
m32r_cmp = _idaapi.m32r_cmp
m32r_cmpi = _idaapi.m32r_cmpi
m32r_cmpu = _idaapi.m32r_cmpu
m32r_cmpui = _idaapi.m32r_cmpui
m32r_div = _idaapi.m32r_div
m32r_divu = _idaapi.m32r_divu
m32r_jl = _idaapi.m32r_jl
m32r_jmp = _idaapi.m32r_jmp
m32r_ld = _idaapi.m32r_ld
m32r_ld24 = _idaapi.m32r_ld24
m32r_ldb = _idaapi.m32r_ldb
m32r_ldh = _idaapi.m32r_ldh
m32r_ldi = _idaapi.m32r_ldi
m32r_ldub = _idaapi.m32r_ldub
m32r_lduh = _idaapi.m32r_lduh
m32r_lock = _idaapi.m32r_lock
m32r_machi = _idaapi.m32r_machi
m32r_maclo = _idaapi.m32r_maclo
m32r_macwhi = _idaapi.m32r_macwhi
m32r_macwlo = _idaapi.m32r_macwlo
m32r_mul = _idaapi.m32r_mul
m32r_mulhi = _idaapi.m32r_mulhi
m32r_mullo = _idaapi.m32r_mullo
m32r_mulwhi = _idaapi.m32r_mulwhi
m32r_mulwlo = _idaapi.m32r_mulwlo
m32r_mv = _idaapi.m32r_mv
m32r_mvfachi = _idaapi.m32r_mvfachi
m32r_mvfaclo = _idaapi.m32r_mvfaclo
m32r_mvfacmi = _idaapi.m32r_mvfacmi
m32r_mvfc = _idaapi.m32r_mvfc
m32r_mvtachi = _idaapi.m32r_mvtachi
m32r_mvtaclo = _idaapi.m32r_mvtaclo
m32r_mvtc = _idaapi.m32r_mvtc
m32r_neg = _idaapi.m32r_neg
m32r_nop = _idaapi.m32r_nop
m32r_not = _idaapi.m32r_not
m32r_or = _idaapi.m32r_or
m32r_or3 = _idaapi.m32r_or3
m32r_push = _idaapi.m32r_push
m32r_pop = _idaapi.m32r_pop
m32r_rac = _idaapi.m32r_rac
m32r_rach = _idaapi.m32r_rach
m32r_rem = _idaapi.m32r_rem
m32r_remu = _idaapi.m32r_remu
m32r_rte = _idaapi.m32r_rte
m32r_seth = _idaapi.m32r_seth
m32r_sll = _idaapi.m32r_sll
m32r_sll3 = _idaapi.m32r_sll3
m32r_slli = _idaapi.m32r_slli
m32r_sra = _idaapi.m32r_sra
m32r_sra3 = _idaapi.m32r_sra3
m32r_srai = _idaapi.m32r_srai
m32r_srl = _idaapi.m32r_srl
m32r_srl3 = _idaapi.m32r_srl3
m32r_srli = _idaapi.m32r_srli
m32r_st = _idaapi.m32r_st
m32r_stb = _idaapi.m32r_stb
m32r_sth = _idaapi.m32r_sth
m32r_sub = _idaapi.m32r_sub
m32r_subv = _idaapi.m32r_subv
m32r_subx = _idaapi.m32r_subx
m32r_trap = _idaapi.m32r_trap
m32r_unlock = _idaapi.m32r_unlock
m32r_xor = _idaapi.m32r_xor
m32r_xor3 = _idaapi.m32r_xor3
m32rx_bcl = _idaapi.m32rx_bcl
m32rx_bncl = _idaapi.m32rx_bncl
m32rx_cmpeq = _idaapi.m32rx_cmpeq
m32rx_cmpz = _idaapi.m32rx_cmpz
m32rx_divh = _idaapi.m32rx_divh
m32rx_jc = _idaapi.m32rx_jc
m32rx_jnc = _idaapi.m32rx_jnc
m32rx_machi = _idaapi.m32rx_machi
m32rx_maclo = _idaapi.m32rx_maclo
m32rx_macwhi = _idaapi.m32rx_macwhi
m32rx_macwlo = _idaapi.m32rx_macwlo
m32rx_mulhi = _idaapi.m32rx_mulhi
m32rx_mullo = _idaapi.m32rx_mullo
m32rx_mulwhi = _idaapi.m32rx_mulwhi
m32rx_mulwlo = _idaapi.m32rx_mulwlo
m32rx_mvfachi = _idaapi.m32rx_mvfachi
m32rx_mvfaclo = _idaapi.m32rx_mvfaclo
m32rx_mvfacmi = _idaapi.m32rx_mvfacmi
m32rx_mvtachi = _idaapi.m32rx_mvtachi
m32rx_mvtaclo = _idaapi.m32rx_mvtaclo
m32rx_rac = _idaapi.m32rx_rac
m32rx_rach = _idaapi.m32rx_rach
m32rx_satb = _idaapi.m32rx_satb
m32rx_sath = _idaapi.m32rx_sath
m32rx_sat = _idaapi.m32rx_sat
m32rx_pcmpbz = _idaapi.m32rx_pcmpbz
m32rx_sadd = _idaapi.m32rx_sadd
m32rx_macwu1 = _idaapi.m32rx_macwu1
m32rx_msblo = _idaapi.m32rx_msblo
m32rx_mulwu1 = _idaapi.m32rx_mulwu1
m32rx_maclh1 = _idaapi.m32rx_maclh1
m32rx_sc = _idaapi.m32rx_sc
m32rx_snc = _idaapi.m32rx_snc
m32r_fadd = _idaapi.m32r_fadd
m32r_fsub = _idaapi.m32r_fsub
m32r_fmul = _idaapi.m32r_fmul
m32r_fdiv = _idaapi.m32r_fdiv
m32r_fmadd = _idaapi.m32r_fmadd
m32r_fmsub = _idaapi.m32r_fmsub
m32r_itof = _idaapi.m32r_itof
m32r_utof = _idaapi.m32r_utof
m32r_ftoi = _idaapi.m32r_ftoi
m32r_ftos = _idaapi.m32r_ftos
m32r_fcmp = _idaapi.m32r_fcmp
m32r_fcmpe = _idaapi.m32r_fcmpe
m32r_bset = _idaapi.m32r_bset
m32r_bclr = _idaapi.m32r_bclr
m32r_btst = _idaapi.m32r_btst
m32r_setpsw = _idaapi.m32r_setpsw
m32r_clrpsw = _idaapi.m32r_clrpsw
m32r_last = _idaapi.m32r_last
m740_null = _idaapi.m740_null
m740_adc = _idaapi.m740_adc
m740_and = _idaapi.m740_and
m740_asl = _idaapi.m740_asl
m740_bbc = _idaapi.m740_bbc
m740_bbs = _idaapi.m740_bbs
m740_bcc = _idaapi.m740_bcc
m740_bcs = _idaapi.m740_bcs
m740_beq = _idaapi.m740_beq
m740_bit = _idaapi.m740_bit
m740_bmi = _idaapi.m740_bmi
m740_bne = _idaapi.m740_bne
m740_bpl = _idaapi.m740_bpl
m740_bra = _idaapi.m740_bra
m740_brk = _idaapi.m740_brk
m740_bvc = _idaapi.m740_bvc
m740_bvs = _idaapi.m740_bvs
m740_clb = _idaapi.m740_clb
m740_clc = _idaapi.m740_clc
m740_cld = _idaapi.m740_cld
m740_cli = _idaapi.m740_cli
m740_clt = _idaapi.m740_clt
m740_clv = _idaapi.m740_clv
m740_cmp = _idaapi.m740_cmp
m740_com = _idaapi.m740_com
m740_cpx = _idaapi.m740_cpx
m740_cpy = _idaapi.m740_cpy
m740_dec = _idaapi.m740_dec
m740_dex = _idaapi.m740_dex
m740_dey = _idaapi.m740_dey
m740_div = _idaapi.m740_div
m740_eor = _idaapi.m740_eor
m740_inc = _idaapi.m740_inc
m740_inx = _idaapi.m740_inx
m740_iny = _idaapi.m740_iny
m740_jmp = _idaapi.m740_jmp
m740_jsr = _idaapi.m740_jsr
m740_lda = _idaapi.m740_lda
m740_ldm = _idaapi.m740_ldm
m740_ldx = _idaapi.m740_ldx
m740_ldy = _idaapi.m740_ldy
m740_lsr = _idaapi.m740_lsr
m740_mul = _idaapi.m740_mul
m740_nop = _idaapi.m740_nop
m740_ora = _idaapi.m740_ora
m740_pha = _idaapi.m740_pha
m740_php = _idaapi.m740_php
m740_pla = _idaapi.m740_pla
m740_plp = _idaapi.m740_plp
m740_rol = _idaapi.m740_rol
m740_ror = _idaapi.m740_ror
m740_rrf = _idaapi.m740_rrf
m740_rti = _idaapi.m740_rti
m740_rts = _idaapi.m740_rts
m740_sbc = _idaapi.m740_sbc
m740_seb = _idaapi.m740_seb
m740_sec = _idaapi.m740_sec
m740_sed = _idaapi.m740_sed
m740_sei = _idaapi.m740_sei
m740_set = _idaapi.m740_set
m740_sta = _idaapi.m740_sta
m740_stp = _idaapi.m740_stp
m740_stx = _idaapi.m740_stx
m740_sty = _idaapi.m740_sty
m740_tax = _idaapi.m740_tax
m740_tay = _idaapi.m740_tay
m740_tst = _idaapi.m740_tst
m740_tsx = _idaapi.m740_tsx
m740_txa = _idaapi.m740_txa
m740_txs = _idaapi.m740_txs
m740_tya = _idaapi.m740_tya
m740_wit = _idaapi.m740_wit
m740_last = _idaapi.m740_last
m7700_null = _idaapi.m7700_null
m7700_adc = _idaapi.m7700_adc
m7700_and = _idaapi.m7700_and
m7700_asl = _idaapi.m7700_asl
m7700_bbc = _idaapi.m7700_bbc
m7700_bbs = _idaapi.m7700_bbs
m7700_bcc = _idaapi.m7700_bcc
m7700_bcs = _idaapi.m7700_bcs
m7700_beq = _idaapi.m7700_beq
m7700_bmi = _idaapi.m7700_bmi
m7700_bne = _idaapi.m7700_bne
m7700_bpl = _idaapi.m7700_bpl
m7700_bra = _idaapi.m7700_bra
m7700_brk = _idaapi.m7700_brk
m7700_bvc = _idaapi.m7700_bvc
m7700_bvs = _idaapi.m7700_bvs
m7700_clb = _idaapi.m7700_clb
m7700_clc = _idaapi.m7700_clc
m7700_cli = _idaapi.m7700_cli
m7700_clm = _idaapi.m7700_clm
m7700_clp = _idaapi.m7700_clp
m7700_clv = _idaapi.m7700_clv
m7700_cmp = _idaapi.m7700_cmp
m7700_cpx = _idaapi.m7700_cpx
m7700_cpy = _idaapi.m7700_cpy
m7700_dec = _idaapi.m7700_dec
m7700_dex = _idaapi.m7700_dex
m7700_dey = _idaapi.m7700_dey
m7700_div = _idaapi.m7700_div
m7700_eor = _idaapi.m7700_eor
m7700_inc = _idaapi.m7700_inc
m7700_inx = _idaapi.m7700_inx
m7700_iny = _idaapi.m7700_iny
m7700_jmp = _idaapi.m7700_jmp
m7700_jsr = _idaapi.m7700_jsr
m7700_lda = _idaapi.m7700_lda
m7700_ldm = _idaapi.m7700_ldm
m7700_ldt = _idaapi.m7700_ldt
m7700_ldx = _idaapi.m7700_ldx
m7700_ldy = _idaapi.m7700_ldy
m7700_lsr = _idaapi.m7700_lsr
m7700_mpy = _idaapi.m7700_mpy
m7700_mvn = _idaapi.m7700_mvn
m7700_mvp = _idaapi.m7700_mvp
m7700_nop = _idaapi.m7700_nop
m7700_ora = _idaapi.m7700_ora
m7700_pea = _idaapi.m7700_pea
m7700_pei = _idaapi.m7700_pei
m7700_per = _idaapi.m7700_per
m7700_pha = _idaapi.m7700_pha
m7700_phb = _idaapi.m7700_phb
m7700_phd = _idaapi.m7700_phd
m7700_phg = _idaapi.m7700_phg
m7700_php = _idaapi.m7700_php
m7700_pht = _idaapi.m7700_pht
m7700_phx = _idaapi.m7700_phx
m7700_phy = _idaapi.m7700_phy
m7700_pla = _idaapi.m7700_pla
m7700_plb = _idaapi.m7700_plb
m7700_pld = _idaapi.m7700_pld
m7700_plp = _idaapi.m7700_plp
m7700_plt = _idaapi.m7700_plt
m7700_plx = _idaapi.m7700_plx
m7700_ply = _idaapi.m7700_ply
m7700_psh = _idaapi.m7700_psh
m7700_pul = _idaapi.m7700_pul
m7700_rla = _idaapi.m7700_rla
m7700_rol = _idaapi.m7700_rol
m7700_ror = _idaapi.m7700_ror
m7700_rti = _idaapi.m7700_rti
m7700_rtl = _idaapi.m7700_rtl
m7700_rts = _idaapi.m7700_rts
m7700_sbc = _idaapi.m7700_sbc
m7700_seb = _idaapi.m7700_seb
m7700_sec = _idaapi.m7700_sec
m7700_sei = _idaapi.m7700_sei
m7700_sem = _idaapi.m7700_sem
m7700_sep = _idaapi.m7700_sep
m7700_sta = _idaapi.m7700_sta
m7700_stp = _idaapi.m7700_stp
m7700_stx = _idaapi.m7700_stx
m7700_sty = _idaapi.m7700_sty
m7700_tad = _idaapi.m7700_tad
m7700_tas = _idaapi.m7700_tas
m7700_tax = _idaapi.m7700_tax
m7700_tay = _idaapi.m7700_tay
m7700_tbd = _idaapi.m7700_tbd
m7700_tbs = _idaapi.m7700_tbs
m7700_tbx = _idaapi.m7700_tbx
m7700_tby = _idaapi.m7700_tby
m7700_tda = _idaapi.m7700_tda
m7700_tdb = _idaapi.m7700_tdb
m7700_tsa = _idaapi.m7700_tsa
m7700_tsb = _idaapi.m7700_tsb
m7700_tsx = _idaapi.m7700_tsx
m7700_txa = _idaapi.m7700_txa
m7700_txb = _idaapi.m7700_txb
m7700_txs = _idaapi.m7700_txs
m7700_txy = _idaapi.m7700_txy
m7700_tya = _idaapi.m7700_tya
m7700_tyb = _idaapi.m7700_tyb
m7700_tyx = _idaapi.m7700_tyx
m7700_wit = _idaapi.m7700_wit
m7700_xab = _idaapi.m7700_xab
m7750_asr = _idaapi.m7750_asr
m7750_divs = _idaapi.m7750_divs
m7750_exts = _idaapi.m7750_exts
m7750_extz = _idaapi.m7750_extz
m7750_mpys = _idaapi.m7750_mpys
m7700_last = _idaapi.m7700_last
m7900_null = _idaapi.m7900_null
m7900_abs = _idaapi.m7900_abs
m7900_absd = _idaapi.m7900_absd
m7900_adc = _idaapi.m7900_adc
m7900_adcb = _idaapi.m7900_adcb
m7900_adcd = _idaapi.m7900_adcd
m7900_add = _idaapi.m7900_add
m7900_addb = _idaapi.m7900_addb
m7900_addd = _idaapi.m7900_addd
m7900_addm = _idaapi.m7900_addm
m7900_addmb = _idaapi.m7900_addmb
m7900_addmd = _idaapi.m7900_addmd
m7900_adds = _idaapi.m7900_adds
m7900_addx = _idaapi.m7900_addx
m7900_addy = _idaapi.m7900_addy
m7900_and = _idaapi.m7900_and
m7900_andb = _idaapi.m7900_andb
m7900_andm = _idaapi.m7900_andm
m7900_andmb = _idaapi.m7900_andmb
m7900_andmd = _idaapi.m7900_andmd
m7900_asl = _idaapi.m7900_asl
m7900_asln = _idaapi.m7900_asln
m7900_asldn = _idaapi.m7900_asldn
m7900_asr = _idaapi.m7900_asr
m7900_asrn = _idaapi.m7900_asrn
m7900_asrdn = _idaapi.m7900_asrdn
m7900_bbc = _idaapi.m7900_bbc
m7900_bbcb = _idaapi.m7900_bbcb
m7900_bbs = _idaapi.m7900_bbs
m7900_bbsb = _idaapi.m7900_bbsb
m7900_bcc = _idaapi.m7900_bcc
m7900_bcs = _idaapi.m7900_bcs
m7900_beq = _idaapi.m7900_beq
m7900_bge = _idaapi.m7900_bge
m7900_bgt = _idaapi.m7900_bgt
m7900_bgtu = _idaapi.m7900_bgtu
m7900_ble = _idaapi.m7900_ble
m7900_bleu = _idaapi.m7900_bleu
m7900_blt = _idaapi.m7900_blt
m7900_bmi = _idaapi.m7900_bmi
m7900_bne = _idaapi.m7900_bne
m7900_bpl = _idaapi.m7900_bpl
m7900_bra = _idaapi.m7900_bra
m7900_bral = _idaapi.m7900_bral
m7900_brk = _idaapi.m7900_brk
m7900_bsc = _idaapi.m7900_bsc
m7900_bsr = _idaapi.m7900_bsr
m7900_bss = _idaapi.m7900_bss
m7900_bvc = _idaapi.m7900_bvc
m7900_bvs = _idaapi.m7900_bvs
m7900_cbeq = _idaapi.m7900_cbeq
m7900_cbeqb = _idaapi.m7900_cbeqb
m7900_cbne = _idaapi.m7900_cbne
m7900_cbneb = _idaapi.m7900_cbneb
m7900_clc = _idaapi.m7900_clc
m7900_cli = _idaapi.m7900_cli
m7900_clm = _idaapi.m7900_clm
m7900_clp = _idaapi.m7900_clp
m7900_clr = _idaapi.m7900_clr
m7900_clrb = _idaapi.m7900_clrb
m7900_clrm = _idaapi.m7900_clrm
m7900_clrmb = _idaapi.m7900_clrmb
m7900_clrx = _idaapi.m7900_clrx
m7900_clry = _idaapi.m7900_clry
m7900_clv = _idaapi.m7900_clv
m7900_cmp = _idaapi.m7900_cmp
m7900_cmpb = _idaapi.m7900_cmpb
m7900_cmpd = _idaapi.m7900_cmpd
m7900_cmpm = _idaapi.m7900_cmpm
m7900_cmpmb = _idaapi.m7900_cmpmb
m7900_cmpmd = _idaapi.m7900_cmpmd
m7900_cpx = _idaapi.m7900_cpx
m7900_cpy = _idaapi.m7900_cpy
m7900_debne = _idaapi.m7900_debne
m7900_dec = _idaapi.m7900_dec
m7900_dex = _idaapi.m7900_dex
m7900_dey = _idaapi.m7900_dey
m7900_div = _idaapi.m7900_div
m7900_divs = _idaapi.m7900_divs
m7900_dxbne = _idaapi.m7900_dxbne
m7900_dybne = _idaapi.m7900_dybne
m7900_eor = _idaapi.m7900_eor
m7900_eorb = _idaapi.m7900_eorb
m7900_eorm = _idaapi.m7900_eorm
m7900_eormb = _idaapi.m7900_eormb
m7900_eormd = _idaapi.m7900_eormd
m7900_exts = _idaapi.m7900_exts
m7900_extsd = _idaapi.m7900_extsd
m7900_extz = _idaapi.m7900_extz
m7900_extzd = _idaapi.m7900_extzd
m7900_inc = _idaapi.m7900_inc
m7900_inx = _idaapi.m7900_inx
m7900_iny = _idaapi.m7900_iny
m7900_jmp = _idaapi.m7900_jmp
m7900_jmpl = _idaapi.m7900_jmpl
m7900_jsr = _idaapi.m7900_jsr
m7900_jsrl = _idaapi.m7900_jsrl
m7900_lda = _idaapi.m7900_lda
m7900_ldab = _idaapi.m7900_ldab
m7900_ldad = _idaapi.m7900_ldad
m7900_lddn = _idaapi.m7900_lddn
m7900_ldt = _idaapi.m7900_ldt
m7900_ldx = _idaapi.m7900_ldx
m7900_ldxb = _idaapi.m7900_ldxb
m7900_ldy = _idaapi.m7900_ldy
m7900_ldyb = _idaapi.m7900_ldyb
m7900_lsr = _idaapi.m7900_lsr
m7900_lsrn = _idaapi.m7900_lsrn
m7900_lsrdn = _idaapi.m7900_lsrdn
m7900_movm = _idaapi.m7900_movm
m7900_movmb = _idaapi.m7900_movmb
m7900_movr = _idaapi.m7900_movr
m7900_movrb = _idaapi.m7900_movrb
m7900_mpy = _idaapi.m7900_mpy
m7900_mpys = _idaapi.m7900_mpys
m7900_mvn = _idaapi.m7900_mvn
m7900_mvp = _idaapi.m7900_mvp
m7900_neg = _idaapi.m7900_neg
m7900_negd = _idaapi.m7900_negd
m7900_nop = _idaapi.m7900_nop
m7900_ora = _idaapi.m7900_ora
m7900_orab = _idaapi.m7900_orab
m7900_oram = _idaapi.m7900_oram
m7900_oramb = _idaapi.m7900_oramb
m7900_oramd = _idaapi.m7900_oramd
m7900_pea = _idaapi.m7900_pea
m7900_pei = _idaapi.m7900_pei
m7900_per = _idaapi.m7900_per
m7900_pha = _idaapi.m7900_pha
m7900_phb = _idaapi.m7900_phb
m7900_phd = _idaapi.m7900_phd
m7900_phdn = _idaapi.m7900_phdn
m7900_phg = _idaapi.m7900_phg
m7900_phldn = _idaapi.m7900_phldn
m7900_php = _idaapi.m7900_php
m7900_pht = _idaapi.m7900_pht
m7900_phx = _idaapi.m7900_phx
m7900_phy = _idaapi.m7900_phy
m7900_pla = _idaapi.m7900_pla
m7900_plb = _idaapi.m7900_plb
m7900_pld = _idaapi.m7900_pld
m7900_pldn = _idaapi.m7900_pldn
m7900_plp = _idaapi.m7900_plp
m7900_plt = _idaapi.m7900_plt
m7900_plx = _idaapi.m7900_plx
m7900_ply = _idaapi.m7900_ply
m7900_psh = _idaapi.m7900_psh
m7900_pul = _idaapi.m7900_pul
m7900_rla = _idaapi.m7900_rla
m7900_rmpa = _idaapi.m7900_rmpa
m7900_rol = _idaapi.m7900_rol
m7900_roln = _idaapi.m7900_roln
m7900_roldn = _idaapi.m7900_roldn
m7900_ror = _idaapi.m7900_ror
m7900_rorn = _idaapi.m7900_rorn
m7900_rordn = _idaapi.m7900_rordn
m7900_rti = _idaapi.m7900_rti
m7900_rtl = _idaapi.m7900_rtl
m7900_rtld = _idaapi.m7900_rtld
m7900_rts = _idaapi.m7900_rts
m7900_rtsdn = _idaapi.m7900_rtsdn
m7900_sbc = _idaapi.m7900_sbc
m7900_sbcb = _idaapi.m7900_sbcb
m7900_sbcd = _idaapi.m7900_sbcd
m7900_sec = _idaapi.m7900_sec
m7900_sei = _idaapi.m7900_sei
m7900_sem = _idaapi.m7900_sem
m7900_sep = _idaapi.m7900_sep
m7900_sta = _idaapi.m7900_sta
m7900_stab = _idaapi.m7900_stab
m7900_stad = _idaapi.m7900_stad
m7900_stp = _idaapi.m7900_stp
m7900_stx = _idaapi.m7900_stx
m7900_sty = _idaapi.m7900_sty
m7900_sub = _idaapi.m7900_sub
m7900_subb = _idaapi.m7900_subb
m7900_subd = _idaapi.m7900_subd
m7900_subm = _idaapi.m7900_subm
m7900_submb = _idaapi.m7900_submb
m7900_submd = _idaapi.m7900_submd
m7900_subs = _idaapi.m7900_subs
m7900_subx = _idaapi.m7900_subx
m7900_suby = _idaapi.m7900_suby
m7900_tadn = _idaapi.m7900_tadn
m7900_tas = _idaapi.m7900_tas
m7900_tax = _idaapi.m7900_tax
m7900_tay = _idaapi.m7900_tay
m7900_tbdn = _idaapi.m7900_tbdn
m7900_tbs = _idaapi.m7900_tbs
m7900_tbx = _idaapi.m7900_tbx
m7900_tby = _idaapi.m7900_tby
m7900_tdan = _idaapi.m7900_tdan
m7900_tdbn = _idaapi.m7900_tdbn
m7900_tds = _idaapi.m7900_tds
m7900_tsa = _idaapi.m7900_tsa
m7900_tsb = _idaapi.m7900_tsb
m7900_tsd = _idaapi.m7900_tsd
m7900_tsx = _idaapi.m7900_tsx
m7900_txa = _idaapi.m7900_txa
m7900_txb = _idaapi.m7900_txb
m7900_txs = _idaapi.m7900_txs
m7900_txy = _idaapi.m7900_txy
m7900_tya = _idaapi.m7900_tya
m7900_tyb = _idaapi.m7900_tyb
m7900_tyx = _idaapi.m7900_tyx
m7900_wit = _idaapi.m7900_wit
m7900_xab = _idaapi.m7900_xab
m7900_last = _idaapi.m7900_last
st9_null = _idaapi.st9_null
st9_ld = _idaapi.st9_ld
st9_ldw = _idaapi.st9_ldw
st9_ldpp = _idaapi.st9_ldpp
st9_ldpd = _idaapi.st9_ldpd
st9_lddp = _idaapi.st9_lddp
st9_lddd = _idaapi.st9_lddd
st9_add = _idaapi.st9_add
st9_addw = _idaapi.st9_addw
st9_adc = _idaapi.st9_adc
st9_adcw = _idaapi.st9_adcw
st9_sub = _idaapi.st9_sub
st9_subw = _idaapi.st9_subw
st9_sbc = _idaapi.st9_sbc
st9_sbcw = _idaapi.st9_sbcw
st9_and = _idaapi.st9_and
st9_andw = _idaapi.st9_andw
st9_or = _idaapi.st9_or
st9_orw = _idaapi.st9_orw
st9_xor = _idaapi.st9_xor
st9_xorw = _idaapi.st9_xorw
st9_cp = _idaapi.st9_cp
st9_cpw = _idaapi.st9_cpw
st9_tm = _idaapi.st9_tm
st9_tmw = _idaapi.st9_tmw
st9_tcm = _idaapi.st9_tcm
st9_tcmw = _idaapi.st9_tcmw
st9_inc = _idaapi.st9_inc
st9_incw = _idaapi.st9_incw
st9_dec = _idaapi.st9_dec
st9_decw = _idaapi.st9_decw
st9_sla = _idaapi.st9_sla
st9_slaw = _idaapi.st9_slaw
st9_sra = _idaapi.st9_sra
st9_sraw = _idaapi.st9_sraw
st9_rrc = _idaapi.st9_rrc
st9_rrcw = _idaapi.st9_rrcw
st9_rlc = _idaapi.st9_rlc
st9_rlcw = _idaapi.st9_rlcw
st9_ror = _idaapi.st9_ror
st9_rol = _idaapi.st9_rol
st9_clr = _idaapi.st9_clr
st9_cpl = _idaapi.st9_cpl
st9_swap = _idaapi.st9_swap
st9_da = _idaapi.st9_da
st9_push = _idaapi.st9_push
st9_pushw = _idaapi.st9_pushw
st9_pea = _idaapi.st9_pea
st9_pop = _idaapi.st9_pop
st9_popw = _idaapi.st9_popw
st9_pushu = _idaapi.st9_pushu
st9_pushuw = _idaapi.st9_pushuw
st9_peau = _idaapi.st9_peau
st9_popu = _idaapi.st9_popu
st9_popuw = _idaapi.st9_popuw
st9_link = _idaapi.st9_link
st9_unlink = _idaapi.st9_unlink
st9_linku = _idaapi.st9_linku
st9_unlinku = _idaapi.st9_unlinku
st9_mul = _idaapi.st9_mul
st9_div = _idaapi.st9_div
st9_divws = _idaapi.st9_divws
st9_bset = _idaapi.st9_bset
st9_bres = _idaapi.st9_bres
st9_bcpl = _idaapi.st9_bcpl
st9_btset = _idaapi.st9_btset
st9_bld = _idaapi.st9_bld
st9_band = _idaapi.st9_band
st9_bor = _idaapi.st9_bor
st9_bxor = _idaapi.st9_bxor
st9_ret = _idaapi.st9_ret
st9_rets = _idaapi.st9_rets
st9_iret = _idaapi.st9_iret
st9_jrcc = _idaapi.st9_jrcc
st9_jpcc = _idaapi.st9_jpcc
st9_jp = _idaapi.st9_jp
st9_jps = _idaapi.st9_jps
st9_call = _idaapi.st9_call
st9_calls = _idaapi.st9_calls
st9_btjf = _idaapi.st9_btjf
st9_btjt = _idaapi.st9_btjt
st9_djnz = _idaapi.st9_djnz
st9_dwjnz = _idaapi.st9_dwjnz
st9_cpjfi = _idaapi.st9_cpjfi
st9_cpjti = _idaapi.st9_cpjti
st9_xch = _idaapi.st9_xch
st9_srp = _idaapi.st9_srp
st9_srp0 = _idaapi.st9_srp0
st9_srp1 = _idaapi.st9_srp1
st9_spp = _idaapi.st9_spp
st9_ext = _idaapi.st9_ext
st9_ei = _idaapi.st9_ei
st9_di = _idaapi.st9_di
st9_scf = _idaapi.st9_scf
st9_rcf = _idaapi.st9_rcf
st9_ccf = _idaapi.st9_ccf
st9_spm = _idaapi.st9_spm
st9_sdm = _idaapi.st9_sdm
st9_nop = _idaapi.st9_nop
st9_wfi = _idaapi.st9_wfi
st9_halt = _idaapi.st9_halt
st9_etrap = _idaapi.st9_etrap
st9_eret = _idaapi.st9_eret
st9_ald = _idaapi.st9_ald
st9_aldw = _idaapi.st9_aldw
st9_last = _idaapi.st9_last
fr_null = _idaapi.fr_null
fr_add = _idaapi.fr_add
fr_add2 = _idaapi.fr_add2
fr_addc = _idaapi.fr_addc
fr_addn = _idaapi.fr_addn
fr_addn2 = _idaapi.fr_addn2
fr_sub = _idaapi.fr_sub
fr_subc = _idaapi.fr_subc
fr_subn = _idaapi.fr_subn
fr_cmp = _idaapi.fr_cmp
fr_cmp2 = _idaapi.fr_cmp2
fr_and = _idaapi.fr_and
fr_andh = _idaapi.fr_andh
fr_andb = _idaapi.fr_andb
fr_or = _idaapi.fr_or
fr_orh = _idaapi.fr_orh
fr_orb = _idaapi.fr_orb
fr_eor = _idaapi.fr_eor
fr_eorh = _idaapi.fr_eorh
fr_eorb = _idaapi.fr_eorb
fr_bandl = _idaapi.fr_bandl
fr_bandh = _idaapi.fr_bandh
fr_borl = _idaapi.fr_borl
fr_borh = _idaapi.fr_borh
fr_beorl = _idaapi.fr_beorl
fr_beorh = _idaapi.fr_beorh
fr_btstl = _idaapi.fr_btstl
fr_btsth = _idaapi.fr_btsth
fr_mul = _idaapi.fr_mul
fr_mulu = _idaapi.fr_mulu
fr_mulh = _idaapi.fr_mulh
fr_muluh = _idaapi.fr_muluh
fr_div0s = _idaapi.fr_div0s
fr_div0u = _idaapi.fr_div0u
fr_div1 = _idaapi.fr_div1
fr_div2 = _idaapi.fr_div2
fr_div3 = _idaapi.fr_div3
fr_div4s = _idaapi.fr_div4s
fr_lsl = _idaapi.fr_lsl
fr_lsl2 = _idaapi.fr_lsl2
fr_lsr = _idaapi.fr_lsr
fr_lsr2 = _idaapi.fr_lsr2
fr_asr = _idaapi.fr_asr
fr_asr2 = _idaapi.fr_asr2
fr_ldi_32 = _idaapi.fr_ldi_32
fr_ldi_20 = _idaapi.fr_ldi_20
fr_ldi_8 = _idaapi.fr_ldi_8
fr_ld = _idaapi.fr_ld
fr_lduh = _idaapi.fr_lduh
fr_ldub = _idaapi.fr_ldub
fr_st = _idaapi.fr_st
fr_sth = _idaapi.fr_sth
fr_stb = _idaapi.fr_stb
fr_mov = _idaapi.fr_mov
fr_jmp = _idaapi.fr_jmp
fr_call = _idaapi.fr_call
fr_ret = _idaapi.fr_ret
fr_int = _idaapi.fr_int
fr_inte = _idaapi.fr_inte
fr_reti = _idaapi.fr_reti
fr_bra = _idaapi.fr_bra
fr_bno = _idaapi.fr_bno
fr_beq = _idaapi.fr_beq
fr_bne = _idaapi.fr_bne
fr_bc = _idaapi.fr_bc
fr_bnc = _idaapi.fr_bnc
fr_bn = _idaapi.fr_bn
fr_bp = _idaapi.fr_bp
fr_bv = _idaapi.fr_bv
fr_bnv = _idaapi.fr_bnv
fr_blt = _idaapi.fr_blt
fr_bge = _idaapi.fr_bge
fr_ble = _idaapi.fr_ble
fr_bgt = _idaapi.fr_bgt
fr_bls = _idaapi.fr_bls
fr_bhi = _idaapi.fr_bhi
fr_dmov = _idaapi.fr_dmov
fr_dmovh = _idaapi.fr_dmovh
fr_dmovb = _idaapi.fr_dmovb
fr_ldres = _idaapi.fr_ldres
fr_stres = _idaapi.fr_stres
fr_copop = _idaapi.fr_copop
fr_copld = _idaapi.fr_copld
fr_copst = _idaapi.fr_copst
fr_copsv = _idaapi.fr_copsv
fr_nop = _idaapi.fr_nop
fr_andccr = _idaapi.fr_andccr
fr_orccr = _idaapi.fr_orccr
fr_stilm = _idaapi.fr_stilm
fr_addsp = _idaapi.fr_addsp
fr_extsb = _idaapi.fr_extsb
fr_extub = _idaapi.fr_extub
fr_extsh = _idaapi.fr_extsh
fr_extuh = _idaapi.fr_extuh
fr_ldm0 = _idaapi.fr_ldm0
fr_ldm1 = _idaapi.fr_ldm1
fr_stm0 = _idaapi.fr_stm0
fr_stm1 = _idaapi.fr_stm1
fr_enter = _idaapi.fr_enter
fr_leave = _idaapi.fr_leave
fr_xchb = _idaapi.fr_xchb
fr_last = _idaapi.fr_last
ALPHA_null = _idaapi.ALPHA_null
ALPHA_addf = _idaapi.ALPHA_addf
ALPHA_addg = _idaapi.ALPHA_addg
ALPHA_addl = _idaapi.ALPHA_addl
ALPHA_addl_v = _idaapi.ALPHA_addl_v
ALPHA_addq = _idaapi.ALPHA_addq
ALPHA_addq_v = _idaapi.ALPHA_addq_v
ALPHA_adds = _idaapi.ALPHA_adds
ALPHA_addt = _idaapi.ALPHA_addt
ALPHA_amask = _idaapi.ALPHA_amask
ALPHA_and = _idaapi.ALPHA_and
ALPHA_beq = _idaapi.ALPHA_beq
ALPHA_bge = _idaapi.ALPHA_bge
ALPHA_bgt = _idaapi.ALPHA_bgt
ALPHA_bic = _idaapi.ALPHA_bic
ALPHA_bis = _idaapi.ALPHA_bis
ALPHA_blbc = _idaapi.ALPHA_blbc
ALPHA_blbs = _idaapi.ALPHA_blbs
ALPHA_ble = _idaapi.ALPHA_ble
ALPHA_blt = _idaapi.ALPHA_blt
ALPHA_bne = _idaapi.ALPHA_bne
ALPHA_br = _idaapi.ALPHA_br
ALPHA_bsr = _idaapi.ALPHA_bsr
ALPHA_call_pal = _idaapi.ALPHA_call_pal
ALPHA_cmoveq = _idaapi.ALPHA_cmoveq
ALPHA_cmovge = _idaapi.ALPHA_cmovge
ALPHA_cmovgt = _idaapi.ALPHA_cmovgt
ALPHA_cmovlbc = _idaapi.ALPHA_cmovlbc
ALPHA_cmovlbs = _idaapi.ALPHA_cmovlbs
ALPHA_cmovle = _idaapi.ALPHA_cmovle
ALPHA_cmovlt = _idaapi.ALPHA_cmovlt
ALPHA_cmovne = _idaapi.ALPHA_cmovne
ALPHA_cmpbge = _idaapi.ALPHA_cmpbge
ALPHA_cmpeq = _idaapi.ALPHA_cmpeq
ALPHA_cmpgeq = _idaapi.ALPHA_cmpgeq
ALPHA_cmpgle = _idaapi.ALPHA_cmpgle
ALPHA_cmpglt = _idaapi.ALPHA_cmpglt
ALPHA_cmple = _idaapi.ALPHA_cmple
ALPHA_cmplt = _idaapi.ALPHA_cmplt
ALPHA_cmpteq = _idaapi.ALPHA_cmpteq
ALPHA_cmptle = _idaapi.ALPHA_cmptle
ALPHA_cmptlt = _idaapi.ALPHA_cmptlt
ALPHA_cmptun = _idaapi.ALPHA_cmptun
ALPHA_cmpule = _idaapi.ALPHA_cmpule
ALPHA_cmpult = _idaapi.ALPHA_cmpult
ALPHA_cpys = _idaapi.ALPHA_cpys
ALPHA_cpyse = _idaapi.ALPHA_cpyse
ALPHA_cpysn = _idaapi.ALPHA_cpysn
ALPHA_ctlz = _idaapi.ALPHA_ctlz
ALPHA_ctpop = _idaapi.ALPHA_ctpop
ALPHA_cttz = _idaapi.ALPHA_cttz
ALPHA_cvtdg = _idaapi.ALPHA_cvtdg
ALPHA_cvtgd = _idaapi.ALPHA_cvtgd
ALPHA_cvtgf = _idaapi.ALPHA_cvtgf
ALPHA_cvtgq = _idaapi.ALPHA_cvtgq
ALPHA_cvtlq = _idaapi.ALPHA_cvtlq
ALPHA_cvtqf = _idaapi.ALPHA_cvtqf
ALPHA_cvtqg = _idaapi.ALPHA_cvtqg
ALPHA_cvtql = _idaapi.ALPHA_cvtql
ALPHA_cvtqs = _idaapi.ALPHA_cvtqs
ALPHA_cvtqt = _idaapi.ALPHA_cvtqt
ALPHA_cvtst = _idaapi.ALPHA_cvtst
ALPHA_cvttq = _idaapi.ALPHA_cvttq
ALPHA_cvtts = _idaapi.ALPHA_cvtts
ALPHA_divf = _idaapi.ALPHA_divf
ALPHA_divg = _idaapi.ALPHA_divg
ALPHA_divs = _idaapi.ALPHA_divs
ALPHA_divt = _idaapi.ALPHA_divt
ALPHA_ecb = _idaapi.ALPHA_ecb
ALPHA_eqv = _idaapi.ALPHA_eqv
ALPHA_excb = _idaapi.ALPHA_excb
ALPHA_extbl = _idaapi.ALPHA_extbl
ALPHA_extlh = _idaapi.ALPHA_extlh
ALPHA_extll = _idaapi.ALPHA_extll
ALPHA_extqh = _idaapi.ALPHA_extqh
ALPHA_extql = _idaapi.ALPHA_extql
ALPHA_extwh = _idaapi.ALPHA_extwh
ALPHA_extwl = _idaapi.ALPHA_extwl
ALPHA_fbeq = _idaapi.ALPHA_fbeq
ALPHA_fbge = _idaapi.ALPHA_fbge
ALPHA_fbgt = _idaapi.ALPHA_fbgt
ALPHA_fble = _idaapi.ALPHA_fble
ALPHA_fblt = _idaapi.ALPHA_fblt
ALPHA_fbne = _idaapi.ALPHA_fbne
ALPHA_fcmoveq = _idaapi.ALPHA_fcmoveq
ALPHA_fcmovge = _idaapi.ALPHA_fcmovge
ALPHA_fcmovgt = _idaapi.ALPHA_fcmovgt
ALPHA_fcmovle = _idaapi.ALPHA_fcmovle
ALPHA_fcmovlt = _idaapi.ALPHA_fcmovlt
ALPHA_fcmovne = _idaapi.ALPHA_fcmovne
ALPHA_fetch = _idaapi.ALPHA_fetch
ALPHA_fetch_m = _idaapi.ALPHA_fetch_m
ALPHA_ftois = _idaapi.ALPHA_ftois
ALPHA_ftoit = _idaapi.ALPHA_ftoit
ALPHA_implver = _idaapi.ALPHA_implver
ALPHA_insbl = _idaapi.ALPHA_insbl
ALPHA_inslh = _idaapi.ALPHA_inslh
ALPHA_insll = _idaapi.ALPHA_insll
ALPHA_insqh = _idaapi.ALPHA_insqh
ALPHA_insql = _idaapi.ALPHA_insql
ALPHA_inswh = _idaapi.ALPHA_inswh
ALPHA_inswl = _idaapi.ALPHA_inswl
ALPHA_itoff = _idaapi.ALPHA_itoff
ALPHA_itofs = _idaapi.ALPHA_itofs
ALPHA_itoft = _idaapi.ALPHA_itoft
ALPHA_jmp = _idaapi.ALPHA_jmp
ALPHA_jsr = _idaapi.ALPHA_jsr
ALPHA_jsr_coroutine = _idaapi.ALPHA_jsr_coroutine
ALPHA_lda = _idaapi.ALPHA_lda
ALPHA_ldah = _idaapi.ALPHA_ldah
ALPHA_ldbu = _idaapi.ALPHA_ldbu
ALPHA_ldwu = _idaapi.ALPHA_ldwu
ALPHA_ldf = _idaapi.ALPHA_ldf
ALPHA_ldg = _idaapi.ALPHA_ldg
ALPHA_ldl = _idaapi.ALPHA_ldl
ALPHA_ldl_l = _idaapi.ALPHA_ldl_l
ALPHA_ldq = _idaapi.ALPHA_ldq
ALPHA_ldq_l = _idaapi.ALPHA_ldq_l
ALPHA_ldq_u = _idaapi.ALPHA_ldq_u
ALPHA_lds = _idaapi.ALPHA_lds
ALPHA_ldt = _idaapi.ALPHA_ldt
ALPHA_maxsb8 = _idaapi.ALPHA_maxsb8
ALPHA_maxsw4 = _idaapi.ALPHA_maxsw4
ALPHA_maxub8 = _idaapi.ALPHA_maxub8
ALPHA_maxuw4 = _idaapi.ALPHA_maxuw4
ALPHA_mb = _idaapi.ALPHA_mb
ALPHA_mf_fpcr = _idaapi.ALPHA_mf_fpcr
ALPHA_minsb8 = _idaapi.ALPHA_minsb8
ALPHA_minsw4 = _idaapi.ALPHA_minsw4
ALPHA_minub8 = _idaapi.ALPHA_minub8
ALPHA_minuw4 = _idaapi.ALPHA_minuw4
ALPHA_mskbl = _idaapi.ALPHA_mskbl
ALPHA_msklh = _idaapi.ALPHA_msklh
ALPHA_mskll = _idaapi.ALPHA_mskll
ALPHA_mskqh = _idaapi.ALPHA_mskqh
ALPHA_mskql = _idaapi.ALPHA_mskql
ALPHA_mskwh = _idaapi.ALPHA_mskwh
ALPHA_mskwl = _idaapi.ALPHA_mskwl
ALPHA_mt_fpcr = _idaapi.ALPHA_mt_fpcr
ALPHA_mulf = _idaapi.ALPHA_mulf
ALPHA_mulg = _idaapi.ALPHA_mulg
ALPHA_mull = _idaapi.ALPHA_mull
ALPHA_mull_v = _idaapi.ALPHA_mull_v
ALPHA_mulq = _idaapi.ALPHA_mulq
ALPHA_mulq_v = _idaapi.ALPHA_mulq_v
ALPHA_muls = _idaapi.ALPHA_muls
ALPHA_mult = _idaapi.ALPHA_mult
ALPHA_ornot = _idaapi.ALPHA_ornot
ALPHA_perr = _idaapi.ALPHA_perr
ALPHA_pklb = _idaapi.ALPHA_pklb
ALPHA_pkwb = _idaapi.ALPHA_pkwb
ALPHA_rc = _idaapi.ALPHA_rc
ALPHA_ret = _idaapi.ALPHA_ret
ALPHA_rpcc = _idaapi.ALPHA_rpcc
ALPHA_rs = _idaapi.ALPHA_rs
ALPHA_s4addl = _idaapi.ALPHA_s4addl
ALPHA_s4addq = _idaapi.ALPHA_s4addq
ALPHA_s4subl = _idaapi.ALPHA_s4subl
ALPHA_s4subq = _idaapi.ALPHA_s4subq
ALPHA_s8addl = _idaapi.ALPHA_s8addl
ALPHA_s8addq = _idaapi.ALPHA_s8addq
ALPHA_s8subl = _idaapi.ALPHA_s8subl
ALPHA_s8subq = _idaapi.ALPHA_s8subq
ALPHA_sextb = _idaapi.ALPHA_sextb
ALPHA_sextw = _idaapi.ALPHA_sextw
ALPHA_sll = _idaapi.ALPHA_sll
ALPHA_sqrtf = _idaapi.ALPHA_sqrtf
ALPHA_sqrtg = _idaapi.ALPHA_sqrtg
ALPHA_sqrts = _idaapi.ALPHA_sqrts
ALPHA_sqrtt = _idaapi.ALPHA_sqrtt
ALPHA_sra = _idaapi.ALPHA_sra
ALPHA_srl = _idaapi.ALPHA_srl
ALPHA_stb = _idaapi.ALPHA_stb
ALPHA_stf = _idaapi.ALPHA_stf
ALPHA_stg = _idaapi.ALPHA_stg
ALPHA_sts = _idaapi.ALPHA_sts
ALPHA_stl = _idaapi.ALPHA_stl
ALPHA_stl_c = _idaapi.ALPHA_stl_c
ALPHA_stq = _idaapi.ALPHA_stq
ALPHA_stq_c = _idaapi.ALPHA_stq_c
ALPHA_stq_u = _idaapi.ALPHA_stq_u
ALPHA_stt = _idaapi.ALPHA_stt
ALPHA_stw = _idaapi.ALPHA_stw
ALPHA_subf = _idaapi.ALPHA_subf
ALPHA_subg = _idaapi.ALPHA_subg
ALPHA_subl = _idaapi.ALPHA_subl
ALPHA_subl_v = _idaapi.ALPHA_subl_v
ALPHA_subq = _idaapi.ALPHA_subq
ALPHA_subq_v = _idaapi.ALPHA_subq_v
ALPHA_subs = _idaapi.ALPHA_subs
ALPHA_subt = _idaapi.ALPHA_subt
ALPHA_trapb = _idaapi.ALPHA_trapb
ALPHA_umulh = _idaapi.ALPHA_umulh
ALPHA_unpkbl = _idaapi.ALPHA_unpkbl
ALPHA_unpkbw = _idaapi.ALPHA_unpkbw
ALPHA_wh64 = _idaapi.ALPHA_wh64
ALPHA_wmb = _idaapi.ALPHA_wmb
ALPHA_xor = _idaapi.ALPHA_xor
ALPHA_zap = _idaapi.ALPHA_zap
ALPHA_zapnot = _idaapi.ALPHA_zapnot
ALPHA_unop = _idaapi.ALPHA_unop
ALPHA_nop = _idaapi.ALPHA_nop
ALPHA_fnop = _idaapi.ALPHA_fnop
ALPHA_clr = _idaapi.ALPHA_clr
ALPHA_fabs = _idaapi.ALPHA_fabs
ALPHA_fclr = _idaapi.ALPHA_fclr
ALPHA_fmov = _idaapi.ALPHA_fmov
ALPHA_fneg = _idaapi.ALPHA_fneg
ALPHA_mov = _idaapi.ALPHA_mov
ALPHA_negl = _idaapi.ALPHA_negl
ALPHA_negl_v = _idaapi.ALPHA_negl_v
ALPHA_negq = _idaapi.ALPHA_negq
ALPHA_negq_v = _idaapi.ALPHA_negq_v
ALPHA_negf = _idaapi.ALPHA_negf
ALPHA_negg = _idaapi.ALPHA_negg
ALPHA_negs = _idaapi.ALPHA_negs
ALPHA_negt = _idaapi.ALPHA_negt
ALPHA_not = _idaapi.ALPHA_not
ALPHA_sextl = _idaapi.ALPHA_sextl
ALPHA_or = _idaapi.ALPHA_or
ALPHA_andnot = _idaapi.ALPHA_andnot
ALPHA_xornot = _idaapi.ALPHA_xornot
ALPHA_br0 = _idaapi.ALPHA_br0
ALPHA_last = _idaapi.ALPHA_last
KR1878_null = _idaapi.KR1878_null
KR1878_mov = _idaapi.KR1878_mov
KR1878_cmp = _idaapi.KR1878_cmp
KR1878_add = _idaapi.KR1878_add
KR1878_sub = _idaapi.KR1878_sub
KR1878_and = _idaapi.KR1878_and
KR1878_or = _idaapi.KR1878_or
KR1878_xor = _idaapi.KR1878_xor
KR1878_movl = _idaapi.KR1878_movl
KR1878_cmpl = _idaapi.KR1878_cmpl
KR1878_addl = _idaapi.KR1878_addl
KR1878_subl = _idaapi.KR1878_subl
KR1878_bic = _idaapi.KR1878_bic
KR1878_bis = _idaapi.KR1878_bis
KR1878_btg = _idaapi.KR1878_btg
KR1878_btt = _idaapi.KR1878_btt
KR1878_swap = _idaapi.KR1878_swap
KR1878_neg = _idaapi.KR1878_neg
KR1878_not = _idaapi.KR1878_not
KR1878_shl = _idaapi.KR1878_shl
KR1878_shr = _idaapi.KR1878_shr
KR1878_shra = _idaapi.KR1878_shra
KR1878_rlc = _idaapi.KR1878_rlc
KR1878_rrc = _idaapi.KR1878_rrc
KR1878_adc = _idaapi.KR1878_adc
KR1878_sbc = _idaapi.KR1878_sbc
KR1878_ldr = _idaapi.KR1878_ldr
KR1878_mtpr = _idaapi.KR1878_mtpr
KR1878_mfpr = _idaapi.KR1878_mfpr
KR1878_push = _idaapi.KR1878_push
KR1878_pop = _idaapi.KR1878_pop
KR1878_sst = _idaapi.KR1878_sst
KR1878_cst = _idaapi.KR1878_cst
KR1878_tof = _idaapi.KR1878_tof
KR1878_tdc = _idaapi.KR1878_tdc
KR1878_jmp = _idaapi.KR1878_jmp
KR1878_jsr = _idaapi.KR1878_jsr
KR1878_jnz = _idaapi.KR1878_jnz
KR1878_jz = _idaapi.KR1878_jz
KR1878_jns = _idaapi.KR1878_jns
KR1878_js = _idaapi.KR1878_js
KR1878_jnc = _idaapi.KR1878_jnc
KR1878_jc = _idaapi.KR1878_jc
KR1878_ijmp = _idaapi.KR1878_ijmp
KR1878_ijsr = _idaapi.KR1878_ijsr
KR1878_rts = _idaapi.KR1878_rts
KR1878_rtsc = _idaapi.KR1878_rtsc
KR1878_rti = _idaapi.KR1878_rti
KR1878_nop = _idaapi.KR1878_nop
KR1878_wait = _idaapi.KR1878_wait
KR1878_stop = _idaapi.KR1878_stop
KR1878_reset = _idaapi.KR1878_reset
KR1878_sksp = _idaapi.KR1878_sksp
KR1878_last = _idaapi.KR1878_last
AD218X_null = _idaapi.AD218X_null
AD218X_amf_01 = _idaapi.AD218X_amf_01
AD218X_amf_03 = _idaapi.AD218X_amf_03
AD218X_amf_02 = _idaapi.AD218X_amf_02
AD218X_amf_04 = _idaapi.AD218X_amf_04
AD218X_amf_05 = _idaapi.AD218X_amf_05
AD218X_amf_06 = _idaapi.AD218X_amf_06
AD218X_amf_07 = _idaapi.AD218X_amf_07
AD218X_amf_08 = _idaapi.AD218X_amf_08
AD218X_amf_09 = _idaapi.AD218X_amf_09
AD218X_amf_0a = _idaapi.AD218X_amf_0a
AD218X_amf_0b = _idaapi.AD218X_amf_0b
AD218X_amf_0c = _idaapi.AD218X_amf_0c
AD218X_amf_0d = _idaapi.AD218X_amf_0d
AD218X_amf_0e = _idaapi.AD218X_amf_0e
AD218X_amf_0f = _idaapi.AD218X_amf_0f
AD218X_amf_10 = _idaapi.AD218X_amf_10
AD218X_amf_11 = _idaapi.AD218X_amf_11
AD218X_amf_12 = _idaapi.AD218X_amf_12
AD218X_amf_13 = _idaapi.AD218X_amf_13
AD218X_amf_14 = _idaapi.AD218X_amf_14
AD218X_amf_15 = _idaapi.AD218X_amf_15
AD218X_amf_16 = _idaapi.AD218X_amf_16
AD218X_amf_17 = _idaapi.AD218X_amf_17
AD218X_amf_18 = _idaapi.AD218X_amf_18
AD218X_amf_19 = _idaapi.AD218X_amf_19
AD218X_amf_1a = _idaapi.AD218X_amf_1a
AD218X_amf_1b = _idaapi.AD218X_amf_1b
AD218X_amf_1c = _idaapi.AD218X_amf_1c
AD218X_amf_1d = _idaapi.AD218X_amf_1d
AD218X_amf_1e = _idaapi.AD218X_amf_1e
AD218X_amf_1f = _idaapi.AD218X_amf_1f
AD218X_shft_0 = _idaapi.AD218X_shft_0
AD218X_shft_1 = _idaapi.AD218X_shft_1
AD218X_shft_2 = _idaapi.AD218X_shft_2
AD218X_shft_3 = _idaapi.AD218X_shft_3
AD218X_shft_4 = _idaapi.AD218X_shft_4
AD218X_shft_5 = _idaapi.AD218X_shft_5
AD218X_shft_6 = _idaapi.AD218X_shft_6
AD218X_shft_7 = _idaapi.AD218X_shft_7
AD218X_shft_8 = _idaapi.AD218X_shft_8
AD218X_shft_9 = _idaapi.AD218X_shft_9
AD218X_shft_a = _idaapi.AD218X_shft_a
AD218X_shft_b = _idaapi.AD218X_shft_b
AD218X_shft_c = _idaapi.AD218X_shft_c
AD218X_shft_d = _idaapi.AD218X_shft_d
AD218X_shft_e = _idaapi.AD218X_shft_e
AD218X_shft_f = _idaapi.AD218X_shft_f
AD218X_alu_00 = _idaapi.AD218X_alu_00
AD218X_alu_01 = _idaapi.AD218X_alu_01
AD218X_alu_02 = _idaapi.AD218X_alu_02
AD218X_alu_03 = _idaapi.AD218X_alu_03
AD218X_alu_04 = _idaapi.AD218X_alu_04
AD218X_alu_05 = _idaapi.AD218X_alu_05
AD218X_alu_06 = _idaapi.AD218X_alu_06
AD218X_alu_07 = _idaapi.AD218X_alu_07
AD218X_alu_08 = _idaapi.AD218X_alu_08
AD218X_alu_09 = _idaapi.AD218X_alu_09
AD218X_alu_0a = _idaapi.AD218X_alu_0a
AD218X_alu_0b = _idaapi.AD218X_alu_0b
AD218X_alu_0c = _idaapi.AD218X_alu_0c
AD218X_alu_0d = _idaapi.AD218X_alu_0d
AD218X_alu_0e = _idaapi.AD218X_alu_0e
AD218X_alu_0f = _idaapi.AD218X_alu_0f
AD218X_alu_10 = _idaapi.AD218X_alu_10
AD218X_alu_11 = _idaapi.AD218X_alu_11
AD218X_alu_12 = _idaapi.AD218X_alu_12
AD218X_alu_13 = _idaapi.AD218X_alu_13
AD218X_alu_14 = _idaapi.AD218X_alu_14
AD218X_alu_15 = _idaapi.AD218X_alu_15
AD218X_alu_16 = _idaapi.AD218X_alu_16
AD218X_alu_17 = _idaapi.AD218X_alu_17
AD218X_alu_18 = _idaapi.AD218X_alu_18
AD218X_alu_19 = _idaapi.AD218X_alu_19
AD218X_alu_1a = _idaapi.AD218X_alu_1a
AD218X_alu_1b = _idaapi.AD218X_alu_1b
AD218X_alu_1c = _idaapi.AD218X_alu_1c
AD218X_alu_1d = _idaapi.AD218X_alu_1d
AD218X_mac_0 = _idaapi.AD218X_mac_0
AD218X_mac_1 = _idaapi.AD218X_mac_1
AD218X_mac_2 = _idaapi.AD218X_mac_2
AD218X_mac_3 = _idaapi.AD218X_mac_3
AD218X_mac_4 = _idaapi.AD218X_mac_4
AD218X_mac_5 = _idaapi.AD218X_mac_5
AD218X_mac_6 = _idaapi.AD218X_mac_6
AD218X_mac_7 = _idaapi.AD218X_mac_7
AD218X_mac_8 = _idaapi.AD218X_mac_8
AD218X_mac_9 = _idaapi.AD218X_mac_9
AD218X_mac_a = _idaapi.AD218X_mac_a
AD218X_mac_b = _idaapi.AD218X_mac_b
AD218X_amf = _idaapi.AD218X_amf
AD218X_shft = _idaapi.AD218X_shft
AD218X_shifter_0 = _idaapi.AD218X_shifter_0
AD218X_shifter_1 = _idaapi.AD218X_shifter_1
AD218X_shifter_2 = _idaapi.AD218X_shifter_2
AD218X_shifter_3 = _idaapi.AD218X_shifter_3
AD218X_shifter_4 = _idaapi.AD218X_shifter_4
AD218X_shifter_5 = _idaapi.AD218X_shifter_5
AD218X_shifter_6 = _idaapi.AD218X_shifter_6
AD218X_shifter_7 = _idaapi.AD218X_shifter_7
AD218X_move_0 = _idaapi.AD218X_move_0
AD218X_move_1 = _idaapi.AD218X_move_1
AD218X_move_2 = _idaapi.AD218X_move_2
AD218X_move_3 = _idaapi.AD218X_move_3
AD218X_move_4 = _idaapi.AD218X_move_4
AD218X_move_5 = _idaapi.AD218X_move_5
AD218X_move_6 = _idaapi.AD218X_move_6
AD218X_move_7 = _idaapi.AD218X_move_7
AD218X_move_8 = _idaapi.AD218X_move_8
AD218X_move_9 = _idaapi.AD218X_move_9
AD218X_move_a = _idaapi.AD218X_move_a
AD218X_move_b = _idaapi.AD218X_move_b
AD218X_jump = _idaapi.AD218X_jump
AD218X_jump_1 = _idaapi.AD218X_jump_1
AD218X_jump_2 = _idaapi.AD218X_jump_2
AD218X_jump_3 = _idaapi.AD218X_jump_3
AD218X_jump_4 = _idaapi.AD218X_jump_4
AD218X_call = _idaapi.AD218X_call
AD218X_call_1 = _idaapi.AD218X_call_1
AD218X_call_2 = _idaapi.AD218X_call_2
AD218X_rts = _idaapi.AD218X_rts
AD218X_rts_cond = _idaapi.AD218X_rts_cond
AD218X_rti = _idaapi.AD218X_rti
AD218X_rti_cond = _idaapi.AD218X_rti_cond
AD218X_nop = _idaapi.AD218X_nop
AD218X_do = _idaapi.AD218X_do
AD218X_idle = _idaapi.AD218X_idle
AD218X_idle_1 = _idaapi.AD218X_idle_1
AD218X_flag_out = _idaapi.AD218X_flag_out
AD218X_stack_ctl = _idaapi.AD218X_stack_ctl
AD218X_mode_ctl = _idaapi.AD218X_mode_ctl
AD218X_tops_w = _idaapi.AD218X_tops_w
AD218X_tops_r = _idaapi.AD218X_tops_r
AD218X_ints_dis = _idaapi.AD218X_ints_dis
AD218X_ints_ena = _idaapi.AD218X_ints_ena
AD218X_modify = _idaapi.AD218X_modify
AD218X_double_move = _idaapi.AD218X_double_move
AD218X_amf_move_0 = _idaapi.AD218X_amf_move_0
AD218X_amf_move_1 = _idaapi.AD218X_amf_move_1
AD218X_amf_move_2 = _idaapi.AD218X_amf_move_2
AD218X_amf_move_3 = _idaapi.AD218X_amf_move_3
AD218X_amf_move_4 = _idaapi.AD218X_amf_move_4
AD218X_amf_move_5 = _idaapi.AD218X_amf_move_5
AD218X_amf_move_6 = _idaapi.AD218X_amf_move_6
AD218X_amf_move_7 = _idaapi.AD218X_amf_move_7
AD218X_amf_move_8 = _idaapi.AD218X_amf_move_8
AD218X_amf_move_9 = _idaapi.AD218X_amf_move_9
AD218X_amf_move_a = _idaapi.AD218X_amf_move_a
AD218X_last = _idaapi.AD218X_last
OAK_Dsp_null = _idaapi.OAK_Dsp_null
OAK_Dsp_proc = _idaapi.OAK_Dsp_proc
OAK_Dsp_or = _idaapi.OAK_Dsp_or
OAK_Dsp_and = _idaapi.OAK_Dsp_and
OAK_Dsp_xor = _idaapi.OAK_Dsp_xor
OAK_Dsp_add = _idaapi.OAK_Dsp_add
OAK_Dsp_alm_tst0 = _idaapi.OAK_Dsp_alm_tst0
OAK_Dsp_alm_tst1 = _idaapi.OAK_Dsp_alm_tst1
OAK_Dsp_cmp = _idaapi.OAK_Dsp_cmp
OAK_Dsp_sub = _idaapi.OAK_Dsp_sub
OAK_Dsp_alm_msu = _idaapi.OAK_Dsp_alm_msu
OAK_Dsp_addh = _idaapi.OAK_Dsp_addh
OAK_Dsp_addl = _idaapi.OAK_Dsp_addl
OAK_Dsp_subh = _idaapi.OAK_Dsp_subh
OAK_Dsp_subl = _idaapi.OAK_Dsp_subl
OAK_Dsp_sqr = _idaapi.OAK_Dsp_sqr
OAK_Dsp_sqra = _idaapi.OAK_Dsp_sqra
OAK_Dsp_cmpu = _idaapi.OAK_Dsp_cmpu
OAK_Dsp_shr = _idaapi.OAK_Dsp_shr
OAK_Dsp_shr4 = _idaapi.OAK_Dsp_shr4
OAK_Dsp_shl = _idaapi.OAK_Dsp_shl
OAK_Dsp_shl4 = _idaapi.OAK_Dsp_shl4
OAK_Dsp_ror = _idaapi.OAK_Dsp_ror
OAK_Dsp_rol = _idaapi.OAK_Dsp_rol
OAK_Dsp_clr = _idaapi.OAK_Dsp_clr
OAK_Dsp_mod_reserved = _idaapi.OAK_Dsp_mod_reserved
OAK_Dsp_not = _idaapi.OAK_Dsp_not
OAK_Dsp_neg = _idaapi.OAK_Dsp_neg
OAK_Dsp_rnd = _idaapi.OAK_Dsp_rnd
OAK_Dsp_pacr = _idaapi.OAK_Dsp_pacr
OAK_Dsp_clrr = _idaapi.OAK_Dsp_clrr
OAK_Dsp_inc = _idaapi.OAK_Dsp_inc
OAK_Dsp_dec = _idaapi.OAK_Dsp_dec
OAK_Dsp_copy = _idaapi.OAK_Dsp_copy
OAK_Dsp_norm = _idaapi.OAK_Dsp_norm
OAK_Dsp_divs = _idaapi.OAK_Dsp_divs
OAK_Dsp_set = _idaapi.OAK_Dsp_set
OAK_Dsp_rst = _idaapi.OAK_Dsp_rst
OAK_Dsp_chng = _idaapi.OAK_Dsp_chng
OAK_Dsp_addv = _idaapi.OAK_Dsp_addv
OAK_Dsp_alb_tst0 = _idaapi.OAK_Dsp_alb_tst0
OAK_Dsp_alb_tst1 = _idaapi.OAK_Dsp_alb_tst1
OAK_Dsp_cmpv = _idaapi.OAK_Dsp_cmpv
OAK_Dsp_subv = _idaapi.OAK_Dsp_subv
OAK_Dsp_maxd = _idaapi.OAK_Dsp_maxd
OAK_Dsp_max = _idaapi.OAK_Dsp_max
OAK_Dsp_min = _idaapi.OAK_Dsp_min
OAK_Dsp_lim = _idaapi.OAK_Dsp_lim
OAK_Dsp_mpy = _idaapi.OAK_Dsp_mpy
OAK_Dsp_mpysu = _idaapi.OAK_Dsp_mpysu
OAK_Dsp_mac = _idaapi.OAK_Dsp_mac
OAK_Dsp_macus = _idaapi.OAK_Dsp_macus
OAK_Dsp_maa = _idaapi.OAK_Dsp_maa
OAK_Dsp_macuu = _idaapi.OAK_Dsp_macuu
OAK_Dsp_macsu = _idaapi.OAK_Dsp_macsu
OAK_Dsp_maasu = _idaapi.OAK_Dsp_maasu
OAK_Dsp_mpyi = _idaapi.OAK_Dsp_mpyi
OAK_Dsp_msu = _idaapi.OAK_Dsp_msu
OAK_Dsp_tstb = _idaapi.OAK_Dsp_tstb
OAK_Dsp_shfc = _idaapi.OAK_Dsp_shfc
OAK_Dsp_shfi = _idaapi.OAK_Dsp_shfi
OAK_Dsp_exp = _idaapi.OAK_Dsp_exp
OAK_Dsp_mov = _idaapi.OAK_Dsp_mov
OAK_Dsp_movp = _idaapi.OAK_Dsp_movp
OAK_Dsp_movs = _idaapi.OAK_Dsp_movs
OAK_Dsp_movsi = _idaapi.OAK_Dsp_movsi
OAK_Dsp_movr = _idaapi.OAK_Dsp_movr
OAK_Dsp_movd = _idaapi.OAK_Dsp_movd
OAK_Dsp_push = _idaapi.OAK_Dsp_push
OAK_Dsp_pop = _idaapi.OAK_Dsp_pop
OAK_Dsp_swap = _idaapi.OAK_Dsp_swap
OAK_Dsp_banke = _idaapi.OAK_Dsp_banke
OAK_Dsp_rep = _idaapi.OAK_Dsp_rep
OAK_Dsp_bkrep = _idaapi.OAK_Dsp_bkrep
OAK_Dsp_break = _idaapi.OAK_Dsp_break
OAK_Dsp_br = _idaapi.OAK_Dsp_br
OAK_Dsp_brr = _idaapi.OAK_Dsp_brr
OAK_Dsp_br_u = _idaapi.OAK_Dsp_br_u
OAK_Dsp_brr_u = _idaapi.OAK_Dsp_brr_u
OAK_Dsp_call = _idaapi.OAK_Dsp_call
OAK_Dsp_callr = _idaapi.OAK_Dsp_callr
OAK_Dsp_calla = _idaapi.OAK_Dsp_calla
OAK_Dsp_ret = _idaapi.OAK_Dsp_ret
OAK_Dsp_ret_u = _idaapi.OAK_Dsp_ret_u
OAK_Dsp_retd = _idaapi.OAK_Dsp_retd
OAK_Dsp_reti = _idaapi.OAK_Dsp_reti
OAK_Dsp_reti_u = _idaapi.OAK_Dsp_reti_u
OAK_Dsp_retid = _idaapi.OAK_Dsp_retid
OAK_Dsp_rets = _idaapi.OAK_Dsp_rets
OAK_Dsp_cntx = _idaapi.OAK_Dsp_cntx
OAK_Dsp_nop = _idaapi.OAK_Dsp_nop
OAK_Dsp_modr = _idaapi.OAK_Dsp_modr
OAK_Dsp_dint = _idaapi.OAK_Dsp_dint
OAK_Dsp_eint = _idaapi.OAK_Dsp_eint
OAK_Dsp_trap = _idaapi.OAK_Dsp_trap
OAK_Dsp_lpg = _idaapi.OAK_Dsp_lpg
OAK_Dsp_load = _idaapi.OAK_Dsp_load
OAK_Dsp_mov_eu = _idaapi.OAK_Dsp_mov_eu
OAK_Dsp_last = _idaapi.OAK_Dsp_last
T900_null = _idaapi.T900_null
T900_ld = _idaapi.T900_ld
T900_ldw = _idaapi.T900_ldw
T900_push = _idaapi.T900_push
T900_pushw = _idaapi.T900_pushw
T900_pop = _idaapi.T900_pop
T900_popw = _idaapi.T900_popw
T900_lda = _idaapi.T900_lda
T900_ldar = _idaapi.T900_ldar
T900_ex = _idaapi.T900_ex
T900_mirr = _idaapi.T900_mirr
T900_ldi = _idaapi.T900_ldi
T900_ldiw = _idaapi.T900_ldiw
T900_ldir = _idaapi.T900_ldir
T900_ldirw = _idaapi.T900_ldirw
T900_ldd = _idaapi.T900_ldd
T900_lddw = _idaapi.T900_lddw
T900_lddr = _idaapi.T900_lddr
T900_lddrw = _idaapi.T900_lddrw
T900_cpi = _idaapi.T900_cpi
T900_cpir = _idaapi.T900_cpir
T900_cpd = _idaapi.T900_cpd
T900_cpdr = _idaapi.T900_cpdr
T900_add = _idaapi.T900_add
T900_addw = _idaapi.T900_addw
T900_adc = _idaapi.T900_adc
T900_adcw = _idaapi.T900_adcw
T900_sub = _idaapi.T900_sub
T900_subw = _idaapi.T900_subw
T900_sbc = _idaapi.T900_sbc
T900_sbcw = _idaapi.T900_sbcw
T900_cp = _idaapi.T900_cp
T900_cpw = _idaapi.T900_cpw
T900_inc = _idaapi.T900_inc
T900_incw = _idaapi.T900_incw
T900_dec = _idaapi.T900_dec
T900_decw = _idaapi.T900_decw
T900_neg = _idaapi.T900_neg
T900_extz = _idaapi.T900_extz
T900_exts = _idaapi.T900_exts
T900_daa = _idaapi.T900_daa
T900_paa = _idaapi.T900_paa
T900_cpl = _idaapi.T900_cpl
T900_mul = _idaapi.T900_mul
T900_muls = _idaapi.T900_muls
T900_div = _idaapi.T900_div
T900_divs = _idaapi.T900_divs
T900_mula = _idaapi.T900_mula
T900_minc1 = _idaapi.T900_minc1
T900_minc2 = _idaapi.T900_minc2
T900_minc4 = _idaapi.T900_minc4
T900_mdec1 = _idaapi.T900_mdec1
T900_mdec2 = _idaapi.T900_mdec2
T900_mdec4 = _idaapi.T900_mdec4
T900_and = _idaapi.T900_and
T900_andw = _idaapi.T900_andw
T900_or = _idaapi.T900_or
T900_orw = _idaapi.T900_orw
T900_xor = _idaapi.T900_xor
T900_xorw = _idaapi.T900_xorw
T900_ldcf = _idaapi.T900_ldcf
T900_stcf = _idaapi.T900_stcf
T900_andcf = _idaapi.T900_andcf
T900_orcf = _idaapi.T900_orcf
T900_xorcf = _idaapi.T900_xorcf
T900_rcf = _idaapi.T900_rcf
T900_scf = _idaapi.T900_scf
T900_ccf = _idaapi.T900_ccf
T900_zcf = _idaapi.T900_zcf
T900_bit = _idaapi.T900_bit
T900_res = _idaapi.T900_res
T900_set = _idaapi.T900_set
T900_chg = _idaapi.T900_chg
T900_tset = _idaapi.T900_tset
T900_bs1f = _idaapi.T900_bs1f
T900_bs1b = _idaapi.T900_bs1b
T900_nop = _idaapi.T900_nop
T900_ei = _idaapi.T900_ei
T900_di = _idaapi.T900_di
T900_swi = _idaapi.T900_swi
T900_halt = _idaapi.T900_halt
T900_ldc = _idaapi.T900_ldc
T900_ldx = _idaapi.T900_ldx
T900_link = _idaapi.T900_link
T900_unlk = _idaapi.T900_unlk
T900_ldf = _idaapi.T900_ldf
T900_incf = _idaapi.T900_incf
T900_decf = _idaapi.T900_decf
T900_scc = _idaapi.T900_scc
T900_rlc = _idaapi.T900_rlc
T900_rlc_mem = _idaapi.T900_rlc_mem
T900_rlcw_mem = _idaapi.T900_rlcw_mem
T900_rrc = _idaapi.T900_rrc
T900_rrc_mem = _idaapi.T900_rrc_mem
T900_rrcw_mem = _idaapi.T900_rrcw_mem
T900_rl = _idaapi.T900_rl
T900_rl_mem = _idaapi.T900_rl_mem
T900_rlw_mem = _idaapi.T900_rlw_mem
T900_rr = _idaapi.T900_rr
T900_rr_mem = _idaapi.T900_rr_mem
T900_rrw_mem = _idaapi.T900_rrw_mem
T900_sla = _idaapi.T900_sla
T900_sla_mem = _idaapi.T900_sla_mem
T900_slaw_mem = _idaapi.T900_slaw_mem
T900_sra = _idaapi.T900_sra
T900_sra_mem = _idaapi.T900_sra_mem
T900_sraw_mem = _idaapi.T900_sraw_mem
T900_sll = _idaapi.T900_sll
T900_sll_mem = _idaapi.T900_sll_mem
T900_sllw_mem = _idaapi.T900_sllw_mem
T900_srl = _idaapi.T900_srl
T900_srl_mem = _idaapi.T900_srl_mem
T900_srlw_mem = _idaapi.T900_srlw_mem
T900_rld = _idaapi.T900_rld
T900_rrd = _idaapi.T900_rrd
T900_jp = _idaapi.T900_jp
T900_jp_cond = _idaapi.T900_jp_cond
T900_jr = _idaapi.T900_jr
T900_jr_cond = _idaapi.T900_jr_cond
T900_jrl = _idaapi.T900_jrl
T900_jrl_cond = _idaapi.T900_jrl_cond
T900_call = _idaapi.T900_call
T900_calr = _idaapi.T900_calr
T900_djnz = _idaapi.T900_djnz
T900_ret = _idaapi.T900_ret
T900_ret_cond = _idaapi.T900_ret_cond
T900_retd = _idaapi.T900_retd
T900_reti = _idaapi.T900_reti
T900_max = _idaapi.T900_max
T900_normal = _idaapi.T900_normal
T900_last = _idaapi.T900_last
C39_null = _idaapi.C39_null
C39_adc = _idaapi.C39_adc
C39_add = _idaapi.C39_add
C39_anc = _idaapi.C39_anc
C39_and = _idaapi.C39_and
C39_ane = _idaapi.C39_ane
C39_arr = _idaapi.C39_arr
C39_asl = _idaapi.C39_asl
C39_asr = _idaapi.C39_asr
C39_bar = _idaapi.C39_bar
C39_bas = _idaapi.C39_bas
C39_bbr = _idaapi.C39_bbr
C39_bbs = _idaapi.C39_bbs
C39_bcc = _idaapi.C39_bcc
C39_bcs = _idaapi.C39_bcs
C39_beq = _idaapi.C39_beq
C39_bit = _idaapi.C39_bit
C39_bmi = _idaapi.C39_bmi
C39_bne = _idaapi.C39_bne
C39_bpl = _idaapi.C39_bpl
C39_bra = _idaapi.C39_bra
C39_brk = _idaapi.C39_brk
C39_bvc = _idaapi.C39_bvc
C39_bvs = _idaapi.C39_bvs
C39_clc = _idaapi.C39_clc
C39_cld = _idaapi.C39_cld
C39_cli = _idaapi.C39_cli
C39_clv = _idaapi.C39_clv
C39_clw = _idaapi.C39_clw
C39_cmp = _idaapi.C39_cmp
C39_cpx = _idaapi.C39_cpx
C39_cpy = _idaapi.C39_cpy
C39_dcp = _idaapi.C39_dcp
C39_dec = _idaapi.C39_dec
C39_dex = _idaapi.C39_dex
C39_dey = _idaapi.C39_dey
C39_eor = _idaapi.C39_eor
C39_exc = _idaapi.C39_exc
C39_inc = _idaapi.C39_inc
C39_ini = _idaapi.C39_ini
C39_inx = _idaapi.C39_inx
C39_iny = _idaapi.C39_iny
C39_isb = _idaapi.C39_isb
C39_jmp = _idaapi.C39_jmp
C39_jpi = _idaapi.C39_jpi
C39_jsb = _idaapi.C39_jsb
C39_jsr = _idaapi.C39_jsr
C39_lab = _idaapi.C39_lab
C39_lae = _idaapi.C39_lae
C39_lai = _idaapi.C39_lai
C39_lan = _idaapi.C39_lan
C39_lax = _idaapi.C39_lax
C39_lda = _idaapi.C39_lda
C39_ldx = _idaapi.C39_ldx
C39_ldy = _idaapi.C39_ldy
C39_lii = _idaapi.C39_lii
C39_lsr = _idaapi.C39_lsr
C39_lxa = _idaapi.C39_lxa
C39_mpa = _idaapi.C39_mpa
C39_mpy = _idaapi.C39_mpy
C39_neg = _idaapi.C39_neg
C39_nop = _idaapi.C39_nop
C39_nxt = _idaapi.C39_nxt
C39_ora = _idaapi.C39_ora
C39_pha = _idaapi.C39_pha
C39_phi = _idaapi.C39_phi
C39_php = _idaapi.C39_php
C39_phw = _idaapi.C39_phw
C39_phx = _idaapi.C39_phx
C39_phy = _idaapi.C39_phy
C39_pia = _idaapi.C39_pia
C39_pla = _idaapi.C39_pla
C39_pli = _idaapi.C39_pli
C39_plp = _idaapi.C39_plp
C39_plw = _idaapi.C39_plw
C39_plx = _idaapi.C39_plx
C39_ply = _idaapi.C39_ply
C39_psh = _idaapi.C39_psh
C39_pul = _idaapi.C39_pul
C39_rba = _idaapi.C39_rba
C39_rla = _idaapi.C39_rla
C39_rmb = _idaapi.C39_rmb
C39_rnd = _idaapi.C39_rnd
C39_rol = _idaapi.C39_rol
C39_ror = _idaapi.C39_ror
C39_rra = _idaapi.C39_rra
C39_rti = _idaapi.C39_rti
C39_rts = _idaapi.C39_rts
C39_sax = _idaapi.C39_sax
C39_sba = _idaapi.C39_sba
C39_sbc = _idaapi.C39_sbc
C39_sbx = _idaapi.C39_sbx
C39_sec = _idaapi.C39_sec
C39_sed = _idaapi.C39_sed
C39_sei = _idaapi.C39_sei
C39_sha = _idaapi.C39_sha
C39_shs = _idaapi.C39_shs
C39_shx = _idaapi.C39_shx
C39_shy = _idaapi.C39_shy
C39_slo = _idaapi.C39_slo
C39_smb = _idaapi.C39_smb
C39_sre = _idaapi.C39_sre
C39_sta = _idaapi.C39_sta
C39_sti = _idaapi.C39_sti
C39_stx = _idaapi.C39_stx
C39_sty = _idaapi.C39_sty
C39_tax = _idaapi.C39_tax
C39_tay = _idaapi.C39_tay
C39_taw = _idaapi.C39_taw
C39_tip = _idaapi.C39_tip
C39_tsx = _idaapi.C39_tsx
C39_twa = _idaapi.C39_twa
C39_txa = _idaapi.C39_txa
C39_txs = _idaapi.C39_txs
C39_tya = _idaapi.C39_tya
C39_last = _idaapi.C39_last
CR16_null = _idaapi.CR16_null
CR16_addb = _idaapi.CR16_addb
CR16_addw = _idaapi.CR16_addw
CR16_addub = _idaapi.CR16_addub
CR16_adduw = _idaapi.CR16_adduw
CR16_addcb = _idaapi.CR16_addcb
CR16_addcw = _idaapi.CR16_addcw
CR16_andb = _idaapi.CR16_andb
CR16_andw = _idaapi.CR16_andw
CR16_ashub = _idaapi.CR16_ashub
CR16_ashuw = _idaapi.CR16_ashuw
CR16_beq = _idaapi.CR16_beq
CR16_bne = _idaapi.CR16_bne
CR16_bcs = _idaapi.CR16_bcs
CR16_bcc = _idaapi.CR16_bcc
CR16_bhi = _idaapi.CR16_bhi
CR16_bls = _idaapi.CR16_bls
CR16_bgt = _idaapi.CR16_bgt
CR16_ble = _idaapi.CR16_ble
CR16_bfs = _idaapi.CR16_bfs
CR16_bfc = _idaapi.CR16_bfc
CR16_blo = _idaapi.CR16_blo
CR16_bhs = _idaapi.CR16_bhs
CR16_blt = _idaapi.CR16_blt
CR16_bge = _idaapi.CR16_bge
CR16_br = _idaapi.CR16_br
CR16_bal = _idaapi.CR16_bal
CR16_cmpb = _idaapi.CR16_cmpb
CR16_cmpw = _idaapi.CR16_cmpw
CR16_beq1b = _idaapi.CR16_beq1b
CR16_beq1w = _idaapi.CR16_beq1w
CR16_beq0b = _idaapi.CR16_beq0b
CR16_beq0w = _idaapi.CR16_beq0w
CR16_bne1b = _idaapi.CR16_bne1b
CR16_bne1w = _idaapi.CR16_bne1w
CR16_bne0b = _idaapi.CR16_bne0b
CR16_bne0w = _idaapi.CR16_bne0w
CR16_di = _idaapi.CR16_di
CR16_ei = _idaapi.CR16_ei
CR16_excp = _idaapi.CR16_excp
CR16_jeq = _idaapi.CR16_jeq
CR16_jne = _idaapi.CR16_jne
CR16_jcs = _idaapi.CR16_jcs
CR16_jcc = _idaapi.CR16_jcc
CR16_jhi = _idaapi.CR16_jhi
CR16_jls = _idaapi.CR16_jls
CR16_jgt = _idaapi.CR16_jgt
CR16_jle = _idaapi.CR16_jle
CR16_jfs = _idaapi.CR16_jfs
CR16_jfc = _idaapi.CR16_jfc
CR16_jlo = _idaapi.CR16_jlo
CR16_jhs = _idaapi.CR16_jhs
CR16_jlt = _idaapi.CR16_jlt
CR16_jge = _idaapi.CR16_jge
CR16_jump = _idaapi.CR16_jump
CR16_jal = _idaapi.CR16_jal
CR16_loadb = _idaapi.CR16_loadb
CR16_loadw = _idaapi.CR16_loadw
CR16_loadm = _idaapi.CR16_loadm
CR16_lpr = _idaapi.CR16_lpr
CR16_lshb = _idaapi.CR16_lshb
CR16_lshw = _idaapi.CR16_lshw
CR16_movb = _idaapi.CR16_movb
CR16_movw = _idaapi.CR16_movw
CR16_movxb = _idaapi.CR16_movxb
CR16_movzb = _idaapi.CR16_movzb
CR16_movd = _idaapi.CR16_movd
CR16_mulb = _idaapi.CR16_mulb
CR16_mulw = _idaapi.CR16_mulw
CR16_mulsb = _idaapi.CR16_mulsb
CR16_mulsw = _idaapi.CR16_mulsw
CR16_muluw = _idaapi.CR16_muluw
CR16_nop = _idaapi.CR16_nop
CR16_orb = _idaapi.CR16_orb
CR16_orw = _idaapi.CR16_orw
CR16_push = _idaapi.CR16_push
CR16_pop = _idaapi.CR16_pop
CR16_popret = _idaapi.CR16_popret
CR16_retx = _idaapi.CR16_retx
CR16_seq = _idaapi.CR16_seq
CR16_sne = _idaapi.CR16_sne
CR16_scs = _idaapi.CR16_scs
CR16_scc = _idaapi.CR16_scc
CR16_shi = _idaapi.CR16_shi
CR16_sls = _idaapi.CR16_sls
CR16_sgt = _idaapi.CR16_sgt
CR16_sle = _idaapi.CR16_sle
CR16_sfs = _idaapi.CR16_sfs
CR16_sfc = _idaapi.CR16_sfc
CR16_slo = _idaapi.CR16_slo
CR16_shs = _idaapi.CR16_shs
CR16_slt = _idaapi.CR16_slt
CR16_sge = _idaapi.CR16_sge
CR16_spr = _idaapi.CR16_spr
CR16_storb = _idaapi.CR16_storb
CR16_storw = _idaapi.CR16_storw
CR16_storm = _idaapi.CR16_storm
CR16_subb = _idaapi.CR16_subb
CR16_subw = _idaapi.CR16_subw
CR16_subcb = _idaapi.CR16_subcb
CR16_subcw = _idaapi.CR16_subcw
CR16_tbit = _idaapi.CR16_tbit
CR16_tbitb = _idaapi.CR16_tbitb
CR16_tbitw = _idaapi.CR16_tbitw
CR16_sbitb = _idaapi.CR16_sbitb
CR16_sbitw = _idaapi.CR16_sbitw
CR16_cbitb = _idaapi.CR16_cbitb
CR16_cbitw = _idaapi.CR16_cbitw
CR16_wait = _idaapi.CR16_wait
CR16_eiwait = _idaapi.CR16_eiwait
CR16_xorb = _idaapi.CR16_xorb
CR16_xorw = _idaapi.CR16_xorw
CR16_last = _idaapi.CR16_last
mn102_null = _idaapi.mn102_null
mn102_add = _idaapi.mn102_add
mn102_addc = _idaapi.mn102_addc
mn102_addnf = _idaapi.mn102_addnf
mn102_and = _idaapi.mn102_and
mn102_asr = _idaapi.mn102_asr
mn102_bcc = _idaapi.mn102_bcc
mn102_bccx = _idaapi.mn102_bccx
mn102_bclr = _idaapi.mn102_bclr
mn102_bcs = _idaapi.mn102_bcs
mn102_bcsx = _idaapi.mn102_bcsx
mn102_beq = _idaapi.mn102_beq
mn102_beqx = _idaapi.mn102_beqx
mn102_bge = _idaapi.mn102_bge
mn102_bgex = _idaapi.mn102_bgex
mn102_bgt = _idaapi.mn102_bgt
mn102_bgtx = _idaapi.mn102_bgtx
mn102_bhi = _idaapi.mn102_bhi
mn102_bhix = _idaapi.mn102_bhix
mn102_ble = _idaapi.mn102_ble
mn102_blex = _idaapi.mn102_blex
mn102_bls = _idaapi.mn102_bls
mn102_blsx = _idaapi.mn102_blsx
mn102_blt = _idaapi.mn102_blt
mn102_bltx = _idaapi.mn102_bltx
mn102_bnc = _idaapi.mn102_bnc
mn102_bncx = _idaapi.mn102_bncx
mn102_bne = _idaapi.mn102_bne
mn102_bnex = _idaapi.mn102_bnex
mn102_bns = _idaapi.mn102_bns
mn102_bnsx = _idaapi.mn102_bnsx
mn102_bra = _idaapi.mn102_bra
mn102_bset = _idaapi.mn102_bset
mn102_btst = _idaapi.mn102_btst
mn102_bvc = _idaapi.mn102_bvc
mn102_bvcx = _idaapi.mn102_bvcx
mn102_bvs = _idaapi.mn102_bvs
mn102_bvsx = _idaapi.mn102_bvsx
mn102_cmp = _idaapi.mn102_cmp
mn102_divu = _idaapi.mn102_divu
mn102_ext = _idaapi.mn102_ext
mn102_extx = _idaapi.mn102_extx
mn102_extxb = _idaapi.mn102_extxb
mn102_extxbu = _idaapi.mn102_extxbu
mn102_extxu = _idaapi.mn102_extxu
mn102_jmp = _idaapi.mn102_jmp
mn102_jsr = _idaapi.mn102_jsr
mn102_lsr = _idaapi.mn102_lsr
mn102_mov = _idaapi.mn102_mov
mn102_movb = _idaapi.mn102_movb
mn102_movbu = _idaapi.mn102_movbu
mn102_movx = _idaapi.mn102_movx
mn102_mul = _idaapi.mn102_mul
mn102_mulq = _idaapi.mn102_mulq
mn102_mulqh = _idaapi.mn102_mulqh
mn102_mulql = _idaapi.mn102_mulql
mn102_mulu = _idaapi.mn102_mulu
mn102_nop = _idaapi.mn102_nop
mn102_not = _idaapi.mn102_not
mn102_or = _idaapi.mn102_or
mn102_pxst = _idaapi.mn102_pxst
mn102_rol = _idaapi.mn102_rol
mn102_ror = _idaapi.mn102_ror
mn102_rti = _idaapi.mn102_rti
mn102_rts = _idaapi.mn102_rts
mn102_sub = _idaapi.mn102_sub
mn102_subc = _idaapi.mn102_subc
mn102_tbnz = _idaapi.mn102_tbnz
mn102_tbz = _idaapi.mn102_tbz
mn102_xor = _idaapi.mn102_xor
mn102_last = _idaapi.mn102_last
PPC_null = _idaapi.PPC_null
PPC_add = _idaapi.PPC_add
PPC_addc = _idaapi.PPC_addc
PPC_adde = _idaapi.PPC_adde
PPC_addi = _idaapi.PPC_addi
PPC_addic = _idaapi.PPC_addic
PPC_addis = _idaapi.PPC_addis
PPC_addme = _idaapi.PPC_addme
PPC_addze = _idaapi.PPC_addze
PPC_and = _idaapi.PPC_and
PPC_andc = _idaapi.PPC_andc
PPC_andi = _idaapi.PPC_andi
PPC_andis = _idaapi.PPC_andis
PPC_b = _idaapi.PPC_b
PPC_bc = _idaapi.PPC_bc
PPC_bcctr = _idaapi.PPC_bcctr
PPC_bclr = _idaapi.PPC_bclr
PPC_cmp = _idaapi.PPC_cmp
PPC_cmpi = _idaapi.PPC_cmpi
PPC_cmpl = _idaapi.PPC_cmpl
PPC_cmpli = _idaapi.PPC_cmpli
PPC_cntlzd = _idaapi.PPC_cntlzd
PPC_cntlzw = _idaapi.PPC_cntlzw
PPC_crand = _idaapi.PPC_crand
PPC_crandc = _idaapi.PPC_crandc
PPC_creqv = _idaapi.PPC_creqv
PPC_crnand = _idaapi.PPC_crnand
PPC_crnor = _idaapi.PPC_crnor
PPC_cror = _idaapi.PPC_cror
PPC_crorc = _idaapi.PPC_crorc
PPC_crxor = _idaapi.PPC_crxor
PPC_dcba = _idaapi.PPC_dcba
PPC_dcbf = _idaapi.PPC_dcbf
PPC_dcbi = _idaapi.PPC_dcbi
PPC_dcbst = _idaapi.PPC_dcbst
PPC_dcbt = _idaapi.PPC_dcbt
PPC_dcbtst = _idaapi.PPC_dcbtst
PPC_dcbz = _idaapi.PPC_dcbz
PPC_divd = _idaapi.PPC_divd
PPC_divdu = _idaapi.PPC_divdu
PPC_divw = _idaapi.PPC_divw
PPC_divwu = _idaapi.PPC_divwu
PPC_eciwx = _idaapi.PPC_eciwx
PPC_ecowx = _idaapi.PPC_ecowx
PPC_eieio = _idaapi.PPC_eieio
PPC_eqv = _idaapi.PPC_eqv
PPC_extsb = _idaapi.PPC_extsb
PPC_extsh = _idaapi.PPC_extsh
PPC_extsw = _idaapi.PPC_extsw
PPC_fabs = _idaapi.PPC_fabs
PPC_fadd = _idaapi.PPC_fadd
PPC_fadds = _idaapi.PPC_fadds
PPC_fcfid = _idaapi.PPC_fcfid
PPC_fcmpo = _idaapi.PPC_fcmpo
PPC_fcmpu = _idaapi.PPC_fcmpu
PPC_fctid = _idaapi.PPC_fctid
PPC_fctidz = _idaapi.PPC_fctidz
PPC_fctiw = _idaapi.PPC_fctiw
PPC_fctiwz = _idaapi.PPC_fctiwz
PPC_fdiv = _idaapi.PPC_fdiv
PPC_fdivs = _idaapi.PPC_fdivs
PPC_fmadd = _idaapi.PPC_fmadd
PPC_fmadds = _idaapi.PPC_fmadds
PPC_fmr = _idaapi.PPC_fmr
PPC_fmsub = _idaapi.PPC_fmsub
PPC_fmsubs = _idaapi.PPC_fmsubs
PPC_fmul = _idaapi.PPC_fmul
PPC_fmuls = _idaapi.PPC_fmuls
PPC_fnabs = _idaapi.PPC_fnabs
PPC_fneg = _idaapi.PPC_fneg
PPC_fnmadd = _idaapi.PPC_fnmadd
PPC_fnmadds = _idaapi.PPC_fnmadds
PPC_fnmsub = _idaapi.PPC_fnmsub
PPC_fnmsubs = _idaapi.PPC_fnmsubs
PPC_fres = _idaapi.PPC_fres
PPC_frsp = _idaapi.PPC_frsp
PPC_frsqrte = _idaapi.PPC_frsqrte
PPC_fsel = _idaapi.PPC_fsel
PPC_fsqrt = _idaapi.PPC_fsqrt
PPC_fsqrts = _idaapi.PPC_fsqrts
PPC_fsub = _idaapi.PPC_fsub
PPC_fsubs = _idaapi.PPC_fsubs
PPC_icbi = _idaapi.PPC_icbi
PPC_isync = _idaapi.PPC_isync
PPC_lbz = _idaapi.PPC_lbz
PPC_lbzu = _idaapi.PPC_lbzu
PPC_lbzux = _idaapi.PPC_lbzux
PPC_lbzx = _idaapi.PPC_lbzx
PPC_ld = _idaapi.PPC_ld
PPC_ldarx = _idaapi.PPC_ldarx
PPC_ldu = _idaapi.PPC_ldu
PPC_ldux = _idaapi.PPC_ldux
PPC_ldx = _idaapi.PPC_ldx
PPC_lfd = _idaapi.PPC_lfd
PPC_lfdu = _idaapi.PPC_lfdu
PPC_lfdux = _idaapi.PPC_lfdux
PPC_lfdx = _idaapi.PPC_lfdx
PPC_lfs = _idaapi.PPC_lfs
PPC_lfsu = _idaapi.PPC_lfsu
PPC_lfsux = _idaapi.PPC_lfsux
PPC_lfsx = _idaapi.PPC_lfsx
PPC_lha = _idaapi.PPC_lha
PPC_lhau = _idaapi.PPC_lhau
PPC_lhaux = _idaapi.PPC_lhaux
PPC_lhax = _idaapi.PPC_lhax
PPC_lhbrx = _idaapi.PPC_lhbrx
PPC_lhz = _idaapi.PPC_lhz
PPC_lhzu = _idaapi.PPC_lhzu
PPC_lhzux = _idaapi.PPC_lhzux
PPC_lhzx = _idaapi.PPC_lhzx
PPC_lmw = _idaapi.PPC_lmw
PPC_lswi = _idaapi.PPC_lswi
PPC_lswx = _idaapi.PPC_lswx
PPC_lwa = _idaapi.PPC_lwa
PPC_lwarx = _idaapi.PPC_lwarx
PPC_lwaux = _idaapi.PPC_lwaux
PPC_lwax = _idaapi.PPC_lwax
PPC_lwbrx = _idaapi.PPC_lwbrx
PPC_lwz = _idaapi.PPC_lwz
PPC_lwzu = _idaapi.PPC_lwzu
PPC_lwzux = _idaapi.PPC_lwzux
PPC_lwzx = _idaapi.PPC_lwzx
PPC_mcrf = _idaapi.PPC_mcrf
PPC_mcrfs = _idaapi.PPC_mcrfs
PPC_mcrxr = _idaapi.PPC_mcrxr
PPC_mfcr = _idaapi.PPC_mfcr
PPC_mffs = _idaapi.PPC_mffs
PPC_mfmsr = _idaapi.PPC_mfmsr
PPC_mfspr = _idaapi.PPC_mfspr
PPC_mfsr = _idaapi.PPC_mfsr
PPC_mfsrin = _idaapi.PPC_mfsrin
PPC_mftb = _idaapi.PPC_mftb
PPC_mtcrf = _idaapi.PPC_mtcrf
PPC_mtfsb0 = _idaapi.PPC_mtfsb0
PPC_mtfsb1 = _idaapi.PPC_mtfsb1
PPC_mtfsf = _idaapi.PPC_mtfsf
PPC_mtfsfi = _idaapi.PPC_mtfsfi
PPC_mtmsr = _idaapi.PPC_mtmsr
PPC_mtmsrd = _idaapi.PPC_mtmsrd
PPC_mtspr = _idaapi.PPC_mtspr
PPC_mtsr = _idaapi.PPC_mtsr
PPC_mtsrd = _idaapi.PPC_mtsrd
PPC_mtsrdin = _idaapi.PPC_mtsrdin
PPC_mtsrin = _idaapi.PPC_mtsrin
PPC_mulhd = _idaapi.PPC_mulhd
PPC_mulhdu = _idaapi.PPC_mulhdu
PPC_mulhw = _idaapi.PPC_mulhw
PPC_mulhwu = _idaapi.PPC_mulhwu
PPC_mulld = _idaapi.PPC_mulld
PPC_mulli = _idaapi.PPC_mulli
PPC_mullw = _idaapi.PPC_mullw
PPC_nand = _idaapi.PPC_nand
PPC_neg = _idaapi.PPC_neg
PPC_nor = _idaapi.PPC_nor
PPC_or = _idaapi.PPC_or
PPC_orc = _idaapi.PPC_orc
PPC_ori = _idaapi.PPC_ori
PPC_oris = _idaapi.PPC_oris
PPC_rfi = _idaapi.PPC_rfi
PPC_rfid = _idaapi.PPC_rfid
PPC_rldcl = _idaapi.PPC_rldcl
PPC_rldcr = _idaapi.PPC_rldcr
PPC_rldic = _idaapi.PPC_rldic
PPC_rldicl = _idaapi.PPC_rldicl
PPC_rldicr = _idaapi.PPC_rldicr
PPC_rldimi = _idaapi.PPC_rldimi
PPC_rlwimi = _idaapi.PPC_rlwimi
PPC_rlwinm = _idaapi.PPC_rlwinm
PPC_rlwnm = _idaapi.PPC_rlwnm
PPC_sc = _idaapi.PPC_sc
PPC_slbia = _idaapi.PPC_slbia
PPC_slbie = _idaapi.PPC_slbie
PPC_sld = _idaapi.PPC_sld
PPC_slw = _idaapi.PPC_slw
PPC_srad = _idaapi.PPC_srad
PPC_sradi = _idaapi.PPC_sradi
PPC_sraw = _idaapi.PPC_sraw
PPC_srawi = _idaapi.PPC_srawi
PPC_srd = _idaapi.PPC_srd
PPC_srw = _idaapi.PPC_srw
PPC_stb = _idaapi.PPC_stb
PPC_stbu = _idaapi.PPC_stbu
PPC_stbux = _idaapi.PPC_stbux
PPC_stbx = _idaapi.PPC_stbx
PPC_std = _idaapi.PPC_std
PPC_stdcx = _idaapi.PPC_stdcx
PPC_stdu = _idaapi.PPC_stdu
PPC_stdux = _idaapi.PPC_stdux
PPC_stdx = _idaapi.PPC_stdx
PPC_stfd = _idaapi.PPC_stfd
PPC_stfdu = _idaapi.PPC_stfdu
PPC_stfdux = _idaapi.PPC_stfdux
PPC_stfdx = _idaapi.PPC_stfdx
PPC_stfiwx = _idaapi.PPC_stfiwx
PPC_stfs = _idaapi.PPC_stfs
PPC_stfsu = _idaapi.PPC_stfsu
PPC_stfsux = _idaapi.PPC_stfsux
PPC_stfsx = _idaapi.PPC_stfsx
PPC_sth = _idaapi.PPC_sth
PPC_sthbrx = _idaapi.PPC_sthbrx
PPC_sthu = _idaapi.PPC_sthu
PPC_sthux = _idaapi.PPC_sthux
PPC_sthx = _idaapi.PPC_sthx
PPC_stmw = _idaapi.PPC_stmw
PPC_stswi = _idaapi.PPC_stswi
PPC_stswx = _idaapi.PPC_stswx
PPC_stw = _idaapi.PPC_stw
PPC_stwbrx = _idaapi.PPC_stwbrx
PPC_stwcx = _idaapi.PPC_stwcx
PPC_stwu = _idaapi.PPC_stwu
PPC_stwux = _idaapi.PPC_stwux
PPC_stwx = _idaapi.PPC_stwx
PPC_subf = _idaapi.PPC_subf
PPC_subfc = _idaapi.PPC_subfc
PPC_subfe = _idaapi.PPC_subfe
PPC_subfic = _idaapi.PPC_subfic
PPC_subfme = _idaapi.PPC_subfme
PPC_subfze = _idaapi.PPC_subfze
PPC_sync = _idaapi.PPC_sync
PPC_td = _idaapi.PPC_td
PPC_tdi = _idaapi.PPC_tdi
PPC_tlbia = _idaapi.PPC_tlbia
PPC_tlbie = _idaapi.PPC_tlbie
PPC_tlbsync = _idaapi.PPC_tlbsync
PPC_tw = _idaapi.PPC_tw
PPC_twi = _idaapi.PPC_twi
PPC_xor = _idaapi.PPC_xor
PPC_xori = _idaapi.PPC_xori
PPC_xoris = _idaapi.PPC_xoris
PPC_last_basic = _idaapi.PPC_last_basic
PPC_cmpwi = _idaapi.PPC_cmpwi
PPC_cmpw = _idaapi.PPC_cmpw
PPC_cmplwi = _idaapi.PPC_cmplwi
PPC_cmplw = _idaapi.PPC_cmplw
PPC_cmpdi = _idaapi.PPC_cmpdi
PPC_cmpd = _idaapi.PPC_cmpd
PPC_cmpldi = _idaapi.PPC_cmpldi
PPC_cmpld = _idaapi.PPC_cmpld
PPC_trap = _idaapi.PPC_trap
PPC_trapd = _idaapi.PPC_trapd
PPC_twlgt = _idaapi.PPC_twlgt
PPC_twllt = _idaapi.PPC_twllt
PPC_tweq = _idaapi.PPC_tweq
PPC_twlge = _idaapi.PPC_twlge
PPC_twlle = _idaapi.PPC_twlle
PPC_twgt = _idaapi.PPC_twgt
PPC_twge = _idaapi.PPC_twge
PPC_twlt = _idaapi.PPC_twlt
PPC_twle = _idaapi.PPC_twle
PPC_twne = _idaapi.PPC_twne
PPC_twlgti = _idaapi.PPC_twlgti
PPC_twllti = _idaapi.PPC_twllti
PPC_tweqi = _idaapi.PPC_tweqi
PPC_twlgei = _idaapi.PPC_twlgei
PPC_twllei = _idaapi.PPC_twllei
PPC_twgti = _idaapi.PPC_twgti
PPC_twgei = _idaapi.PPC_twgei
PPC_twlti = _idaapi.PPC_twlti
PPC_twlei = _idaapi.PPC_twlei
PPC_twnei = _idaapi.PPC_twnei
PPC_tdlgt = _idaapi.PPC_tdlgt
PPC_tdllt = _idaapi.PPC_tdllt
PPC_tdeq = _idaapi.PPC_tdeq
PPC_tdlge = _idaapi.PPC_tdlge
PPC_tdlle = _idaapi.PPC_tdlle
PPC_tdgt = _idaapi.PPC_tdgt
PPC_tdge = _idaapi.PPC_tdge
PPC_tdlt = _idaapi.PPC_tdlt
PPC_tdle = _idaapi.PPC_tdle
PPC_tdne = _idaapi.PPC_tdne
PPC_tdlgti = _idaapi.PPC_tdlgti
PPC_tdllti = _idaapi.PPC_tdllti
PPC_tdeqi = _idaapi.PPC_tdeqi
PPC_tdlgei = _idaapi.PPC_tdlgei
PPC_tdllei = _idaapi.PPC_tdllei
PPC_tdgti = _idaapi.PPC_tdgti
PPC_tdgei = _idaapi.PPC_tdgei
PPC_tdlti = _idaapi.PPC_tdlti
PPC_tdlei = _idaapi.PPC_tdlei
PPC_tdnei = _idaapi.PPC_tdnei
PPC_nop = _idaapi.PPC_nop
PPC_not = _idaapi.PPC_not
PPC_mr = _idaapi.PPC_mr
PPC_subi = _idaapi.PPC_subi
PPC_subic = _idaapi.PPC_subic
PPC_subis = _idaapi.PPC_subis
PPC_li = _idaapi.PPC_li
PPC_lis = _idaapi.PPC_lis
PPC_crset = _idaapi.PPC_crset
PPC_crnot = _idaapi.PPC_crnot
PPC_crmove = _idaapi.PPC_crmove
PPC_crclr = _idaapi.PPC_crclr
PPC_mtxer = _idaapi.PPC_mtxer
PPC_mtlr = _idaapi.PPC_mtlr
PPC_mtctr = _idaapi.PPC_mtctr
PPC_mtdsisr = _idaapi.PPC_mtdsisr
PPC_mtdar = _idaapi.PPC_mtdar
PPC_mtdec = _idaapi.PPC_mtdec
PPC_mtsrr0 = _idaapi.PPC_mtsrr0
PPC_mtsrr1 = _idaapi.PPC_mtsrr1
PPC_mtsprg0 = _idaapi.PPC_mtsprg0
PPC_mtsprg1 = _idaapi.PPC_mtsprg1
PPC_mtsprg2 = _idaapi.PPC_mtsprg2
PPC_mtsprg3 = _idaapi.PPC_mtsprg3
PPC_mttbl = _idaapi.PPC_mttbl
PPC_mttbu = _idaapi.PPC_mttbu
PPC_mfxer = _idaapi.PPC_mfxer
PPC_mflr = _idaapi.PPC_mflr
PPC_mfctr = _idaapi.PPC_mfctr
PPC_mfdsisr = _idaapi.PPC_mfdsisr
PPC_mfdar = _idaapi.PPC_mfdar
PPC_mfdec = _idaapi.PPC_mfdec
PPC_mfsrr0 = _idaapi.PPC_mfsrr0
PPC_mfsrr1 = _idaapi.PPC_mfsrr1
PPC_mfsprg0 = _idaapi.PPC_mfsprg0
PPC_mfsprg1 = _idaapi.PPC_mfsprg1
PPC_mfsprg2 = _idaapi.PPC_mfsprg2
PPC_mfsprg3 = _idaapi.PPC_mfsprg3
PPC_mftbl = _idaapi.PPC_mftbl
PPC_mftbu = _idaapi.PPC_mftbu
PPC_mfpvr = _idaapi.PPC_mfpvr
PPC_balways = _idaapi.PPC_balways
PPC_bt = _idaapi.PPC_bt
PPC_bf = _idaapi.PPC_bf
PPC_bdnz = _idaapi.PPC_bdnz
PPC_bdnzt = _idaapi.PPC_bdnzt
PPC_bdnzf = _idaapi.PPC_bdnzf
PPC_bdz = _idaapi.PPC_bdz
PPC_bdzt = _idaapi.PPC_bdzt
PPC_bdzf = _idaapi.PPC_bdzf
PPC_blt = _idaapi.PPC_blt
PPC_ble = _idaapi.PPC_ble
PPC_beq = _idaapi.PPC_beq
PPC_bge = _idaapi.PPC_bge
PPC_bgt = _idaapi.PPC_bgt
PPC_bne = _idaapi.PPC_bne
PPC_bso = _idaapi.PPC_bso
PPC_bns = _idaapi.PPC_bns
PPC_extlwi = _idaapi.PPC_extlwi
PPC_extrwi = _idaapi.PPC_extrwi
PPC_inslwi = _idaapi.PPC_inslwi
PPC_insrwi = _idaapi.PPC_insrwi
PPC_rotlwi = _idaapi.PPC_rotlwi
PPC_rotrwi = _idaapi.PPC_rotrwi
PPC_rotlw = _idaapi.PPC_rotlw
PPC_slwi = _idaapi.PPC_slwi
PPC_srwi = _idaapi.PPC_srwi
PPC_clrlwi = _idaapi.PPC_clrlwi
PPC_clrrwi = _idaapi.PPC_clrrwi
PPC_clrlslwi = _idaapi.PPC_clrlslwi
PPC_dccci = _idaapi.PPC_dccci
PPC_dcread = _idaapi.PPC_dcread
PPC_icbt = _idaapi.PPC_icbt
PPC_iccci = _idaapi.PPC_iccci
PPC_icread = _idaapi.PPC_icread
PPC_mfdcr = _idaapi.PPC_mfdcr
PPC_mtdcr = _idaapi.PPC_mtdcr
PPC_rfci = _idaapi.PPC_rfci
PPC_tlbre = _idaapi.PPC_tlbre
PPC_tlbsx = _idaapi.PPC_tlbsx
PPC_tlbwe = _idaapi.PPC_tlbwe
PPC_wrtee = _idaapi.PPC_wrtee
PPC_wrteei = _idaapi.PPC_wrteei
PPC_abs = _idaapi.PPC_abs
PPC_clcs = _idaapi.PPC_clcs
PPC_clf = _idaapi.PPC_clf
PPC_cli = _idaapi.PPC_cli
PPC_dclst = _idaapi.PPC_dclst
PPC_div = _idaapi.PPC_div
PPC_divs = _idaapi.PPC_divs
PPC_doz = _idaapi.PPC_doz
PPC_dozi = _idaapi.PPC_dozi
PPC_frsqrtes = _idaapi.PPC_frsqrtes
PPC_hrfid = _idaapi.PPC_hrfid
PPC_lscbx = _idaapi.PPC_lscbx
PPC_maskg = _idaapi.PPC_maskg
PPC_maskir = _idaapi.PPC_maskir
PPC_mfsri = _idaapi.PPC_mfsri
PPC_mul = _idaapi.PPC_mul
PPC_nabs = _idaapi.PPC_nabs
PPC_popcntb = _idaapi.PPC_popcntb
PPC_rac = _idaapi.PPC_rac
PPC_rfsvc = _idaapi.PPC_rfsvc
PPC_rlmi = _idaapi.PPC_rlmi
PPC_rrib = _idaapi.PPC_rrib
PPC_slbmfee = _idaapi.PPC_slbmfee
PPC_slbmfev = _idaapi.PPC_slbmfev
PPC_slbmte = _idaapi.PPC_slbmte
PPC_sle = _idaapi.PPC_sle
PPC_sleq = _idaapi.PPC_sleq
PPC_sliq = _idaapi.PPC_sliq
PPC_slliq = _idaapi.PPC_slliq
PPC_sllq = _idaapi.PPC_sllq
PPC_slq = _idaapi.PPC_slq
PPC_sraiq = _idaapi.PPC_sraiq
PPC_sraq = _idaapi.PPC_sraq
PPC_sre = _idaapi.PPC_sre
PPC_srea = _idaapi.PPC_srea
PPC_sreq = _idaapi.PPC_sreq
PPC_sriq = _idaapi.PPC_sriq
PPC_srliq = _idaapi.PPC_srliq
PPC_srlq = _idaapi.PPC_srlq
PPC_srq = _idaapi.PPC_srq
PPC_mtocrf = _idaapi.PPC_mtocrf
PPC_mfocrf = _idaapi.PPC_mfocrf
PPC_isel = _idaapi.PPC_isel
PPC_isellt = _idaapi.PPC_isellt
PPC_iselgt = _idaapi.PPC_iselgt
PPC_iseleq = _idaapi.PPC_iseleq
PPC_dcblc = _idaapi.PPC_dcblc
PPC_dcbtls = _idaapi.PPC_dcbtls
PPC_dcbtstls = _idaapi.PPC_dcbtstls
PPC_icblc = _idaapi.PPC_icblc
PPC_icbtls = _idaapi.PPC_icbtls
PPC_tlbivax = _idaapi.PPC_tlbivax
PPC_rfdi = _idaapi.PPC_rfdi
PPC_tlbld = _idaapi.PPC_tlbld
PPC_tlbli = _idaapi.PPC_tlbli
PPC_brinc = _idaapi.PPC_brinc
PPC_evabs = _idaapi.PPC_evabs
PPC_evaddiw = _idaapi.PPC_evaddiw
PPC_evaddsmiaaw = _idaapi.PPC_evaddsmiaaw
PPC_evaddssiaaw = _idaapi.PPC_evaddssiaaw
PPC_evaddumiaaw = _idaapi.PPC_evaddumiaaw
PPC_evaddusiaaw = _idaapi.PPC_evaddusiaaw
PPC_evaddw = _idaapi.PPC_evaddw
PPC_evand = _idaapi.PPC_evand
PPC_evandc = _idaapi.PPC_evandc
PPC_evcmpeq = _idaapi.PPC_evcmpeq
PPC_evcmpgts = _idaapi.PPC_evcmpgts
PPC_evcmpgtu = _idaapi.PPC_evcmpgtu
PPC_evcmplts = _idaapi.PPC_evcmplts
PPC_evcmpltu = _idaapi.PPC_evcmpltu
PPC_evcntlsw = _idaapi.PPC_evcntlsw
PPC_evcntlzw = _idaapi.PPC_evcntlzw
PPC_evdivws = _idaapi.PPC_evdivws
PPC_evdivwu = _idaapi.PPC_evdivwu
PPC_eveqv = _idaapi.PPC_eveqv
PPC_evextsb = _idaapi.PPC_evextsb
PPC_evextsh = _idaapi.PPC_evextsh
PPC_evldd = _idaapi.PPC_evldd
PPC_evlddx = _idaapi.PPC_evlddx
PPC_evldh = _idaapi.PPC_evldh
PPC_evldhx = _idaapi.PPC_evldhx
PPC_evldw = _idaapi.PPC_evldw
PPC_evldwx = _idaapi.PPC_evldwx
PPC_evlhhesplat = _idaapi.PPC_evlhhesplat
PPC_evlhhesplatx = _idaapi.PPC_evlhhesplatx
PPC_evlhhossplat = _idaapi.PPC_evlhhossplat
PPC_evlhhossplatx = _idaapi.PPC_evlhhossplatx
PPC_evlhhousplat = _idaapi.PPC_evlhhousplat
PPC_evlhhousplatx = _idaapi.PPC_evlhhousplatx
PPC_evlwhe = _idaapi.PPC_evlwhe
PPC_evlwhex = _idaapi.PPC_evlwhex
PPC_evlwhos = _idaapi.PPC_evlwhos
PPC_evlwhosx = _idaapi.PPC_evlwhosx
PPC_evlwhou = _idaapi.PPC_evlwhou
PPC_evlwhoux = _idaapi.PPC_evlwhoux
PPC_evlwhsplat = _idaapi.PPC_evlwhsplat
PPC_evlwhsplatx = _idaapi.PPC_evlwhsplatx
PPC_evlwwsplat = _idaapi.PPC_evlwwsplat
PPC_evlwwsplatx = _idaapi.PPC_evlwwsplatx
PPC_evmergehi = _idaapi.PPC_evmergehi
PPC_evmergehilo = _idaapi.PPC_evmergehilo
PPC_evmergelo = _idaapi.PPC_evmergelo
PPC_evmergelohi = _idaapi.PPC_evmergelohi
PPC_evmhegsmfaa = _idaapi.PPC_evmhegsmfaa
PPC_evmhegsmfan = _idaapi.PPC_evmhegsmfan
PPC_evmhegsmiaa = _idaapi.PPC_evmhegsmiaa
PPC_evmhegsmian = _idaapi.PPC_evmhegsmian
PPC_evmhegumiaa = _idaapi.PPC_evmhegumiaa
PPC_evmhegumian = _idaapi.PPC_evmhegumian
PPC_evmhesmf = _idaapi.PPC_evmhesmf
PPC_evmhesmfa = _idaapi.PPC_evmhesmfa
PPC_evmhesmfaaw = _idaapi.PPC_evmhesmfaaw
PPC_evmhesmfanw = _idaapi.PPC_evmhesmfanw
PPC_evmhesmi = _idaapi.PPC_evmhesmi
PPC_evmhesmia = _idaapi.PPC_evmhesmia
PPC_evmhesmiaaw = _idaapi.PPC_evmhesmiaaw
PPC_evmhesmianw = _idaapi.PPC_evmhesmianw
PPC_evmhessf = _idaapi.PPC_evmhessf
PPC_evmhessfa = _idaapi.PPC_evmhessfa
PPC_evmhessfaaw = _idaapi.PPC_evmhessfaaw
PPC_evmhessfanw = _idaapi.PPC_evmhessfanw
PPC_evmhessiaaw = _idaapi.PPC_evmhessiaaw
PPC_evmhessianw = _idaapi.PPC_evmhessianw
PPC_evmheumi = _idaapi.PPC_evmheumi
PPC_evmheumia = _idaapi.PPC_evmheumia
PPC_evmheumiaaw = _idaapi.PPC_evmheumiaaw
PPC_evmheumianw = _idaapi.PPC_evmheumianw
PPC_evmheusiaaw = _idaapi.PPC_evmheusiaaw
PPC_evmheusianw = _idaapi.PPC_evmheusianw
PPC_evmhogsmfaa = _idaapi.PPC_evmhogsmfaa
PPC_evmhogsmfan = _idaapi.PPC_evmhogsmfan
PPC_evmhogsmiaa = _idaapi.PPC_evmhogsmiaa
PPC_evmhogsmian = _idaapi.PPC_evmhogsmian
PPC_evmhogumiaa = _idaapi.PPC_evmhogumiaa
PPC_evmhogumian = _idaapi.PPC_evmhogumian
PPC_evmhosmf = _idaapi.PPC_evmhosmf
PPC_evmhosmfa = _idaapi.PPC_evmhosmfa
PPC_evmhosmfaaw = _idaapi.PPC_evmhosmfaaw
PPC_evmhosmfanw = _idaapi.PPC_evmhosmfanw
PPC_evmhosmi = _idaapi.PPC_evmhosmi
PPC_evmhosmia = _idaapi.PPC_evmhosmia
PPC_evmhosmiaaw = _idaapi.PPC_evmhosmiaaw
PPC_evmhosmianw = _idaapi.PPC_evmhosmianw
PPC_evmhossf = _idaapi.PPC_evmhossf
PPC_evmhossfa = _idaapi.PPC_evmhossfa
PPC_evmhossfaaw = _idaapi.PPC_evmhossfaaw
PPC_evmhossfanw = _idaapi.PPC_evmhossfanw
PPC_evmhossiaaw = _idaapi.PPC_evmhossiaaw
PPC_evmhossianw = _idaapi.PPC_evmhossianw
PPC_evmhoumi = _idaapi.PPC_evmhoumi
PPC_evmhoumia = _idaapi.PPC_evmhoumia
PPC_evmhoumiaaw = _idaapi.PPC_evmhoumiaaw
PPC_evmhoumianw = _idaapi.PPC_evmhoumianw
PPC_evmhousiaaw = _idaapi.PPC_evmhousiaaw
PPC_evmhousianw = _idaapi.PPC_evmhousianw
PPC_evmra = _idaapi.PPC_evmra
PPC_evmwhsmf = _idaapi.PPC_evmwhsmf
PPC_evmwhsmfa = _idaapi.PPC_evmwhsmfa
PPC_evmwhsmi = _idaapi.PPC_evmwhsmi
PPC_evmwhsmia = _idaapi.PPC_evmwhsmia
PPC_evmwhssf = _idaapi.PPC_evmwhssf
PPC_evmwhssfa = _idaapi.PPC_evmwhssfa
PPC_evmwhumi = _idaapi.PPC_evmwhumi
PPC_evmwhumia = _idaapi.PPC_evmwhumia
PPC_evmwlsmiaaw = _idaapi.PPC_evmwlsmiaaw
PPC_evmwlsmianw = _idaapi.PPC_evmwlsmianw
PPC_evmwlssiaaw = _idaapi.PPC_evmwlssiaaw
PPC_evmwlssianw = _idaapi.PPC_evmwlssianw
PPC_evmwlumi = _idaapi.PPC_evmwlumi
PPC_evmwlumia = _idaapi.PPC_evmwlumia
PPC_evmwlumiaaw = _idaapi.PPC_evmwlumiaaw
PPC_evmwlumianw = _idaapi.PPC_evmwlumianw
PPC_evmwlusiaaw = _idaapi.PPC_evmwlusiaaw
PPC_evmwlusianw = _idaapi.PPC_evmwlusianw
PPC_evmwsmf = _idaapi.PPC_evmwsmf
PPC_evmwsmfa = _idaapi.PPC_evmwsmfa
PPC_evmwsmfaa = _idaapi.PPC_evmwsmfaa
PPC_evmwsmfan = _idaapi.PPC_evmwsmfan
PPC_evmwsmi = _idaapi.PPC_evmwsmi
PPC_evmwsmia = _idaapi.PPC_evmwsmia
PPC_evmwsmiaa = _idaapi.PPC_evmwsmiaa
PPC_evmwsmian = _idaapi.PPC_evmwsmian
PPC_evmwssf = _idaapi.PPC_evmwssf
PPC_evmwssfa = _idaapi.PPC_evmwssfa
PPC_evmwssfaa = _idaapi.PPC_evmwssfaa
PPC_evmwssfan = _idaapi.PPC_evmwssfan
PPC_evmwumi = _idaapi.PPC_evmwumi
PPC_evmwumia = _idaapi.PPC_evmwumia
PPC_evmwumiaa = _idaapi.PPC_evmwumiaa
PPC_evmwumian = _idaapi.PPC_evmwumian
PPC_evnand = _idaapi.PPC_evnand
PPC_evneg = _idaapi.PPC_evneg
PPC_evnor = _idaapi.PPC_evnor
PPC_evor = _idaapi.PPC_evor
PPC_evorc = _idaapi.PPC_evorc
PPC_evrlw = _idaapi.PPC_evrlw
PPC_evrlwi = _idaapi.PPC_evrlwi
PPC_evrndw = _idaapi.PPC_evrndw
PPC_evsel = _idaapi.PPC_evsel
PPC_evslw = _idaapi.PPC_evslw
PPC_evslwi = _idaapi.PPC_evslwi
PPC_evsplatfi = _idaapi.PPC_evsplatfi
PPC_evsplati = _idaapi.PPC_evsplati
PPC_evsrwis = _idaapi.PPC_evsrwis
PPC_evsrwiu = _idaapi.PPC_evsrwiu
PPC_evsrws = _idaapi.PPC_evsrws
PPC_evsrwu = _idaapi.PPC_evsrwu
PPC_evstdd = _idaapi.PPC_evstdd
PPC_evstddx = _idaapi.PPC_evstddx
PPC_evstdh = _idaapi.PPC_evstdh
PPC_evstdhx = _idaapi.PPC_evstdhx
PPC_evstdw = _idaapi.PPC_evstdw
PPC_evstdwx = _idaapi.PPC_evstdwx
PPC_evstwhe = _idaapi.PPC_evstwhe
PPC_evstwhex = _idaapi.PPC_evstwhex
PPC_evstwho = _idaapi.PPC_evstwho
PPC_evstwhox = _idaapi.PPC_evstwhox
PPC_evstwwe = _idaapi.PPC_evstwwe
PPC_evstwwex = _idaapi.PPC_evstwwex
PPC_evstwwo = _idaapi.PPC_evstwwo
PPC_evstwwox = _idaapi.PPC_evstwwox
PPC_evsubfsmiaaw = _idaapi.PPC_evsubfsmiaaw
PPC_evsubfssiaaw = _idaapi.PPC_evsubfssiaaw
PPC_evsubfumiaaw = _idaapi.PPC_evsubfumiaaw
PPC_evsubfusiaaw = _idaapi.PPC_evsubfusiaaw
PPC_evsubfw = _idaapi.PPC_evsubfw
PPC_evsubifw = _idaapi.PPC_evsubifw
PPC_evxor = _idaapi.PPC_evxor
PPC_efdabs = _idaapi.PPC_efdabs
PPC_efdadd = _idaapi.PPC_efdadd
PPC_efdcfs = _idaapi.PPC_efdcfs
PPC_efdcfsf = _idaapi.PPC_efdcfsf
PPC_efdcfsi = _idaapi.PPC_efdcfsi
PPC_efdcfsid = _idaapi.PPC_efdcfsid
PPC_efdcfuf = _idaapi.PPC_efdcfuf
PPC_efdcfui = _idaapi.PPC_efdcfui
PPC_efdcfuid = _idaapi.PPC_efdcfuid
PPC_efdcmpeq = _idaapi.PPC_efdcmpeq
PPC_efdcmpgt = _idaapi.PPC_efdcmpgt
PPC_efdcmplt = _idaapi.PPC_efdcmplt
PPC_efdctsf = _idaapi.PPC_efdctsf
PPC_efdctsi = _idaapi.PPC_efdctsi
PPC_efdctsidz = _idaapi.PPC_efdctsidz
PPC_efdctsiz = _idaapi.PPC_efdctsiz
PPC_efdctuf = _idaapi.PPC_efdctuf
PPC_efdctui = _idaapi.PPC_efdctui
PPC_efdctuidz = _idaapi.PPC_efdctuidz
PPC_efdctuiz = _idaapi.PPC_efdctuiz
PPC_efddiv = _idaapi.PPC_efddiv
PPC_efdmul = _idaapi.PPC_efdmul
PPC_efdnabs = _idaapi.PPC_efdnabs
PPC_efdneg = _idaapi.PPC_efdneg
PPC_efdsub = _idaapi.PPC_efdsub
PPC_efdtsteq = _idaapi.PPC_efdtsteq
PPC_efdtstgt = _idaapi.PPC_efdtstgt
PPC_efdtstlt = _idaapi.PPC_efdtstlt
PPC_efscfd = _idaapi.PPC_efscfd
PPC_efsabs = _idaapi.PPC_efsabs
PPC_efsadd = _idaapi.PPC_efsadd
PPC_efscfsf = _idaapi.PPC_efscfsf
PPC_efscfsi = _idaapi.PPC_efscfsi
PPC_efscfuf = _idaapi.PPC_efscfuf
PPC_efscfui = _idaapi.PPC_efscfui
PPC_efscmpeq = _idaapi.PPC_efscmpeq
PPC_efscmpgt = _idaapi.PPC_efscmpgt
PPC_efscmplt = _idaapi.PPC_efscmplt
PPC_efsctsf = _idaapi.PPC_efsctsf
PPC_efsctsi = _idaapi.PPC_efsctsi
PPC_efsctsiz = _idaapi.PPC_efsctsiz
PPC_efsctuf = _idaapi.PPC_efsctuf
PPC_efsctui = _idaapi.PPC_efsctui
PPC_efsctuiz = _idaapi.PPC_efsctuiz
PPC_efsdiv = _idaapi.PPC_efsdiv
PPC_efsmul = _idaapi.PPC_efsmul
PPC_efsnabs = _idaapi.PPC_efsnabs
PPC_efsneg = _idaapi.PPC_efsneg
PPC_efssub = _idaapi.PPC_efssub
PPC_efststeq = _idaapi.PPC_efststeq
PPC_efststgt = _idaapi.PPC_efststgt
PPC_efststlt = _idaapi.PPC_efststlt
PPC_evfsabs = _idaapi.PPC_evfsabs
PPC_evfsadd = _idaapi.PPC_evfsadd
PPC_evfscfsf = _idaapi.PPC_evfscfsf
PPC_evfscfsi = _idaapi.PPC_evfscfsi
PPC_evfscfuf = _idaapi.PPC_evfscfuf
PPC_evfscfui = _idaapi.PPC_evfscfui
PPC_evfscmpeq = _idaapi.PPC_evfscmpeq
PPC_evfscmpgt = _idaapi.PPC_evfscmpgt
PPC_evfscmplt = _idaapi.PPC_evfscmplt
PPC_evfsctsf = _idaapi.PPC_evfsctsf
PPC_evfsctsi = _idaapi.PPC_evfsctsi
PPC_evfsctsiz = _idaapi.PPC_evfsctsiz
PPC_evfsctuf = _idaapi.PPC_evfsctuf
PPC_evfsctui = _idaapi.PPC_evfsctui
PPC_evfsctuiz = _idaapi.PPC_evfsctuiz
PPC_evfsdiv = _idaapi.PPC_evfsdiv
PPC_evfsmul = _idaapi.PPC_evfsmul
PPC_evfsnabs = _idaapi.PPC_evfsnabs
PPC_evfsneg = _idaapi.PPC_evfsneg
PPC_evfssub = _idaapi.PPC_evfssub
PPC_evfststeq = _idaapi.PPC_evfststeq
PPC_evfststgt = _idaapi.PPC_evfststgt
PPC_evfststlt = _idaapi.PPC_evfststlt
PPC_bpermd = _idaapi.PPC_bpermd
PPC_divde = _idaapi.PPC_divde
PPC_divdeu = _idaapi.PPC_divdeu
PPC_ldbrx = _idaapi.PPC_ldbrx
PPC_prtyd = _idaapi.PPC_prtyd
PPC_stdbrx = _idaapi.PPC_stdbrx
PPC_cmpb = _idaapi.PPC_cmpb
PPC_divwe = _idaapi.PPC_divwe
PPC_divweu = _idaapi.PPC_divweu
PPC_lbarx = _idaapi.PPC_lbarx
PPC_lharx = _idaapi.PPC_lharx
PPC_popcntd = _idaapi.PPC_popcntd
PPC_popcntw = _idaapi.PPC_popcntw
PPC_prtyw = _idaapi.PPC_prtyw
PPC_stbcx = _idaapi.PPC_stbcx
PPC_sthcx = _idaapi.PPC_sthcx
PPC_addg6s = _idaapi.PPC_addg6s
PPC_cbcdtd = _idaapi.PPC_cbcdtd
PPC_cdtbcd = _idaapi.PPC_cdtbcd
PPC_dadd = _idaapi.PPC_dadd
PPC_daddq = _idaapi.PPC_daddq
PPC_dcffix = _idaapi.PPC_dcffix
PPC_dcffixq = _idaapi.PPC_dcffixq
PPC_dcmpo = _idaapi.PPC_dcmpo
PPC_dcmpoq = _idaapi.PPC_dcmpoq
PPC_dcmpu = _idaapi.PPC_dcmpu
PPC_dcmpuq = _idaapi.PPC_dcmpuq
PPC_dctdp = _idaapi.PPC_dctdp
PPC_dctfix = _idaapi.PPC_dctfix
PPC_dctfixq = _idaapi.PPC_dctfixq
PPC_dctqpq = _idaapi.PPC_dctqpq
PPC_ddedpd = _idaapi.PPC_ddedpd
PPC_ddedpdq = _idaapi.PPC_ddedpdq
PPC_ddiv = _idaapi.PPC_ddiv
PPC_ddivq = _idaapi.PPC_ddivq
PPC_denbcd = _idaapi.PPC_denbcd
PPC_denbcdq = _idaapi.PPC_denbcdq
PPC_diex = _idaapi.PPC_diex
PPC_diexq = _idaapi.PPC_diexq
PPC_dmul = _idaapi.PPC_dmul
PPC_dmulq = _idaapi.PPC_dmulq
PPC_dqua = _idaapi.PPC_dqua
PPC_dquai = _idaapi.PPC_dquai
PPC_dquaiq = _idaapi.PPC_dquaiq
PPC_dquaq = _idaapi.PPC_dquaq
PPC_drdpq = _idaapi.PPC_drdpq
PPC_drintn = _idaapi.PPC_drintn
PPC_drintnq = _idaapi.PPC_drintnq
PPC_drintx = _idaapi.PPC_drintx
PPC_drintxq = _idaapi.PPC_drintxq
PPC_drrnd = _idaapi.PPC_drrnd
PPC_drrndq = _idaapi.PPC_drrndq
PPC_drsp = _idaapi.PPC_drsp
PPC_dscli = _idaapi.PPC_dscli
PPC_dscliq = _idaapi.PPC_dscliq
PPC_dscri = _idaapi.PPC_dscri
PPC_dscriq = _idaapi.PPC_dscriq
PPC_dsub = _idaapi.PPC_dsub
PPC_dsubq = _idaapi.PPC_dsubq
PPC_dtstdc = _idaapi.PPC_dtstdc
PPC_dtstdcq = _idaapi.PPC_dtstdcq
PPC_dtstdg = _idaapi.PPC_dtstdg
PPC_dtstdgq = _idaapi.PPC_dtstdgq
PPC_dtstex = _idaapi.PPC_dtstex
PPC_dtstexq = _idaapi.PPC_dtstexq
PPC_dtstsf = _idaapi.PPC_dtstsf
PPC_dtstsfq = _idaapi.PPC_dtstsfq
PPC_dxex = _idaapi.PPC_dxex
PPC_dxexq = _idaapi.PPC_dxexq
PPC_dsn = _idaapi.PPC_dsn
PPC_lbdx = _idaapi.PPC_lbdx
PPC_lddx = _idaapi.PPC_lddx
PPC_lfddx = _idaapi.PPC_lfddx
PPC_lhdx = _idaapi.PPC_lhdx
PPC_lwdx = _idaapi.PPC_lwdx
PPC_stbdx = _idaapi.PPC_stbdx
PPC_stddx = _idaapi.PPC_stddx
PPC_stfddx = _idaapi.PPC_stfddx
PPC_sthdx = _idaapi.PPC_sthdx
PPC_stwdx = _idaapi.PPC_stwdx
PPC_mbar = _idaapi.PPC_mbar
PPC_rfmci = _idaapi.PPC_rfmci
PPC_tlbilx = _idaapi.PPC_tlbilx
PPC_dci = _idaapi.PPC_dci
PPC_ici = _idaapi.PPC_ici
PPC_mfdcrux = _idaapi.PPC_mfdcrux
PPC_mfdcrx = _idaapi.PPC_mfdcrx
PPC_mtdcrux = _idaapi.PPC_mtdcrux
PPC_mtdcrx = _idaapi.PPC_mtdcrx
PPC_dnh = _idaapi.PPC_dnh
PPC_ehpriv = _idaapi.PPC_ehpriv
PPC_rfgi = _idaapi.PPC_rfgi
PPC_msgclr = _idaapi.PPC_msgclr
PPC_msgsnd = _idaapi.PPC_msgsnd
PPC_dcbfep = _idaapi.PPC_dcbfep
PPC_dcbstep = _idaapi.PPC_dcbstep
PPC_dcbtep = _idaapi.PPC_dcbtep
PPC_dcbtstep = _idaapi.PPC_dcbtstep
PPC_dcbzep = _idaapi.PPC_dcbzep
PPC_evlddepx = _idaapi.PPC_evlddepx
PPC_evstddepx = _idaapi.PPC_evstddepx
PPC_icbiep = _idaapi.PPC_icbiep
PPC_lbepx = _idaapi.PPC_lbepx
PPC_lfdepx = _idaapi.PPC_lfdepx
PPC_lhepx = _idaapi.PPC_lhepx
PPC_lvepx = _idaapi.PPC_lvepx
PPC_lvepxl = _idaapi.PPC_lvepxl
PPC_lwepx = _idaapi.PPC_lwepx
PPC_stbepx = _idaapi.PPC_stbepx
PPC_stfdepx = _idaapi.PPC_stfdepx
PPC_sthepx = _idaapi.PPC_sthepx
PPC_stvepx = _idaapi.PPC_stvepx
PPC_stvepxl = _idaapi.PPC_stvepxl
PPC_stwepx = _idaapi.PPC_stwepx
PPC_ldepx = _idaapi.PPC_ldepx
PPC_stdepx = _idaapi.PPC_stdepx
PPC_mfpmr = _idaapi.PPC_mfpmr
PPC_mtpmr = _idaapi.PPC_mtpmr
PPC_mftmr = _idaapi.PPC_mftmr
PPC_mttmr = _idaapi.PPC_mttmr
PPC_tlbsrx = _idaapi.PPC_tlbsrx
PPC_fcfids = _idaapi.PPC_fcfids
PPC_fcfidu = _idaapi.PPC_fcfidu
PPC_fcfidus = _idaapi.PPC_fcfidus
PPC_fctidu = _idaapi.PPC_fctidu
PPC_fctiduz = _idaapi.PPC_fctiduz
PPC_fctiwu = _idaapi.PPC_fctiwu
PPC_fctiwuz = _idaapi.PPC_fctiwuz
PPC_ftdiv = _idaapi.PPC_ftdiv
PPC_ftsqrt = _idaapi.PPC_ftsqrt
PPC_lfiwax = _idaapi.PPC_lfiwax
PPC_lfiwzx = _idaapi.PPC_lfiwzx
PPC_lfdp = _idaapi.PPC_lfdp
PPC_lfdpx = _idaapi.PPC_lfdpx
PPC_stfdp = _idaapi.PPC_stfdp
PPC_stfdpx = _idaapi.PPC_stfdpx
PPC_fcpsgn = _idaapi.PPC_fcpsgn
PPC_fre = _idaapi.PPC_fre
PPC_frim = _idaapi.PPC_frim
PPC_frin = _idaapi.PPC_frin
PPC_frip = _idaapi.PPC_frip
PPC_friz = _idaapi.PPC_friz
PPC_macchw = _idaapi.PPC_macchw
PPC_macchws = _idaapi.PPC_macchws
PPC_macchwsu = _idaapi.PPC_macchwsu
PPC_macchwu = _idaapi.PPC_macchwu
PPC_machhw = _idaapi.PPC_machhw
PPC_machhws = _idaapi.PPC_machhws
PPC_machhwsu = _idaapi.PPC_machhwsu
PPC_machhwu = _idaapi.PPC_machhwu
PPC_maclhw = _idaapi.PPC_maclhw
PPC_maclhws = _idaapi.PPC_maclhws
PPC_maclhwsu = _idaapi.PPC_maclhwsu
PPC_maclhwu = _idaapi.PPC_maclhwu
PPC_mulchw = _idaapi.PPC_mulchw
PPC_mulchwu = _idaapi.PPC_mulchwu
PPC_mulhhw = _idaapi.PPC_mulhhw
PPC_mulhhwu = _idaapi.PPC_mulhhwu
PPC_mullhw = _idaapi.PPC_mullhw
PPC_mullhwu = _idaapi.PPC_mullhwu
PPC_nmacchw = _idaapi.PPC_nmacchw
PPC_nmacchws = _idaapi.PPC_nmacchws
PPC_nmachhw = _idaapi.PPC_nmachhw
PPC_nmachhws = _idaapi.PPC_nmachhws
PPC_nmaclhw = _idaapi.PPC_nmaclhw
PPC_nmaclhws = _idaapi.PPC_nmaclhws
PPC_dlmzb = _idaapi.PPC_dlmzb
PPC_lq = _idaapi.PPC_lq
PPC_stq = _idaapi.PPC_stq
PPC_doze = _idaapi.PPC_doze
PPC_lbzcix = _idaapi.PPC_lbzcix
PPC_ldcix = _idaapi.PPC_ldcix
PPC_lhzcix = _idaapi.PPC_lhzcix
PPC_lwzcix = _idaapi.PPC_lwzcix
PPC_nap = _idaapi.PPC_nap
PPC_rvwinkle = _idaapi.PPC_rvwinkle
PPC_slbfee = _idaapi.PPC_slbfee
PPC_sleep = _idaapi.PPC_sleep
PPC_stbcix = _idaapi.PPC_stbcix
PPC_stdcix = _idaapi.PPC_stdcix
PPC_sthcix = _idaapi.PPC_sthcix
PPC_stwcix = _idaapi.PPC_stwcix
PPC_tlbiel = _idaapi.PPC_tlbiel
PPC_lvebx = _idaapi.PPC_lvebx
PPC_lvehx = _idaapi.PPC_lvehx
PPC_lvewx = _idaapi.PPC_lvewx
PPC_lvsl = _idaapi.PPC_lvsl
PPC_lvsr = _idaapi.PPC_lvsr
PPC_lvx = _idaapi.PPC_lvx
PPC_lvxl = _idaapi.PPC_lvxl
PPC_mfvscr = _idaapi.PPC_mfvscr
PPC_mtvscr = _idaapi.PPC_mtvscr
PPC_stvebx = _idaapi.PPC_stvebx
PPC_stvehx = _idaapi.PPC_stvehx
PPC_stvewx = _idaapi.PPC_stvewx
PPC_stvx = _idaapi.PPC_stvx
PPC_stvxl = _idaapi.PPC_stvxl
PPC_vaddcuw = _idaapi.PPC_vaddcuw
PPC_vaddfp = _idaapi.PPC_vaddfp
PPC_vaddsbs = _idaapi.PPC_vaddsbs
PPC_vaddshs = _idaapi.PPC_vaddshs
PPC_vaddsws = _idaapi.PPC_vaddsws
PPC_vaddubm = _idaapi.PPC_vaddubm
PPC_vaddubs = _idaapi.PPC_vaddubs
PPC_vadduhm = _idaapi.PPC_vadduhm
PPC_vadduhs = _idaapi.PPC_vadduhs
PPC_vadduwm = _idaapi.PPC_vadduwm
PPC_vadduws = _idaapi.PPC_vadduws
PPC_vand = _idaapi.PPC_vand
PPC_vandc = _idaapi.PPC_vandc
PPC_vavgsb = _idaapi.PPC_vavgsb
PPC_vavgsh = _idaapi.PPC_vavgsh
PPC_vavgsw = _idaapi.PPC_vavgsw
PPC_vavgub = _idaapi.PPC_vavgub
PPC_vavguh = _idaapi.PPC_vavguh
PPC_vavguw = _idaapi.PPC_vavguw
PPC_vcfsx = _idaapi.PPC_vcfsx
PPC_vcfux = _idaapi.PPC_vcfux
PPC_vcmpbfp = _idaapi.PPC_vcmpbfp
PPC_vcmpeqfp = _idaapi.PPC_vcmpeqfp
PPC_vcmpequb = _idaapi.PPC_vcmpequb
PPC_vcmpequh = _idaapi.PPC_vcmpequh
PPC_vcmpequw = _idaapi.PPC_vcmpequw
PPC_vcmpgefp = _idaapi.PPC_vcmpgefp
PPC_vcmpgtfp = _idaapi.PPC_vcmpgtfp
PPC_vcmpgtsb = _idaapi.PPC_vcmpgtsb
PPC_vcmpgtsh = _idaapi.PPC_vcmpgtsh
PPC_vcmpgtsw = _idaapi.PPC_vcmpgtsw
PPC_vcmpgtub = _idaapi.PPC_vcmpgtub
PPC_vcmpgtuh = _idaapi.PPC_vcmpgtuh
PPC_vcmpgtuw = _idaapi.PPC_vcmpgtuw
PPC_vctsxs = _idaapi.PPC_vctsxs
PPC_vctuxs = _idaapi.PPC_vctuxs
PPC_vexptefp = _idaapi.PPC_vexptefp
PPC_vlogefp = _idaapi.PPC_vlogefp
PPC_vmaddfp = _idaapi.PPC_vmaddfp
PPC_vmaxfp = _idaapi.PPC_vmaxfp
PPC_vmaxsb = _idaapi.PPC_vmaxsb
PPC_vmaxsh = _idaapi.PPC_vmaxsh
PPC_vmaxsw = _idaapi.PPC_vmaxsw
PPC_vmaxub = _idaapi.PPC_vmaxub
PPC_vmaxuh = _idaapi.PPC_vmaxuh
PPC_vmaxuw = _idaapi.PPC_vmaxuw
PPC_vmhaddshs = _idaapi.PPC_vmhaddshs
PPC_vmhraddshs = _idaapi.PPC_vmhraddshs
PPC_vminfp = _idaapi.PPC_vminfp
PPC_vminsb = _idaapi.PPC_vminsb
PPC_vminsh = _idaapi.PPC_vminsh
PPC_vminsw = _idaapi.PPC_vminsw
PPC_vminub = _idaapi.PPC_vminub
PPC_vminuh = _idaapi.PPC_vminuh
PPC_vminuw = _idaapi.PPC_vminuw
PPC_vmladduhm = _idaapi.PPC_vmladduhm
PPC_vmrghb = _idaapi.PPC_vmrghb
PPC_vmrghh = _idaapi.PPC_vmrghh
PPC_vmrghw = _idaapi.PPC_vmrghw
PPC_vmrglb = _idaapi.PPC_vmrglb
PPC_vmrglh = _idaapi.PPC_vmrglh
PPC_vmrglw = _idaapi.PPC_vmrglw
PPC_vmsummbm = _idaapi.PPC_vmsummbm
PPC_vmsumshm = _idaapi.PPC_vmsumshm
PPC_vmsumshs = _idaapi.PPC_vmsumshs
PPC_vmsumubm = _idaapi.PPC_vmsumubm
PPC_vmsumuhm = _idaapi.PPC_vmsumuhm
PPC_vmsumuhs = _idaapi.PPC_vmsumuhs
PPC_vmulesb = _idaapi.PPC_vmulesb
PPC_vmulesh = _idaapi.PPC_vmulesh
PPC_vmuleub = _idaapi.PPC_vmuleub
PPC_vmuleuh = _idaapi.PPC_vmuleuh
PPC_vmulosb = _idaapi.PPC_vmulosb
PPC_vmulosh = _idaapi.PPC_vmulosh
PPC_vmuloub = _idaapi.PPC_vmuloub
PPC_vmulouh = _idaapi.PPC_vmulouh
PPC_vnmsubfp = _idaapi.PPC_vnmsubfp
PPC_vnor = _idaapi.PPC_vnor
PPC_vor = _idaapi.PPC_vor
PPC_vperm = _idaapi.PPC_vperm
PPC_vpkpx = _idaapi.PPC_vpkpx
PPC_vpkshss = _idaapi.PPC_vpkshss
PPC_vpkshus = _idaapi.PPC_vpkshus
PPC_vpkswss = _idaapi.PPC_vpkswss
PPC_vpkswus = _idaapi.PPC_vpkswus
PPC_vpkuhum = _idaapi.PPC_vpkuhum
PPC_vpkuhus = _idaapi.PPC_vpkuhus
PPC_vpkuwum = _idaapi.PPC_vpkuwum
PPC_vpkuwus = _idaapi.PPC_vpkuwus
PPC_vrefp = _idaapi.PPC_vrefp
PPC_vrfim = _idaapi.PPC_vrfim
PPC_vrfin = _idaapi.PPC_vrfin
PPC_vrfip = _idaapi.PPC_vrfip
PPC_vrfiz = _idaapi.PPC_vrfiz
PPC_vrlb = _idaapi.PPC_vrlb
PPC_vrlh = _idaapi.PPC_vrlh
PPC_vrlw = _idaapi.PPC_vrlw
PPC_vrsqrtefp = _idaapi.PPC_vrsqrtefp
PPC_vsel = _idaapi.PPC_vsel
PPC_vsl = _idaapi.PPC_vsl
PPC_vslb = _idaapi.PPC_vslb
PPC_vsldoi = _idaapi.PPC_vsldoi
PPC_vslh = _idaapi.PPC_vslh
PPC_vslo = _idaapi.PPC_vslo
PPC_vslw = _idaapi.PPC_vslw
PPC_vspltb = _idaapi.PPC_vspltb
PPC_vsplth = _idaapi.PPC_vsplth
PPC_vspltisb = _idaapi.PPC_vspltisb
PPC_vspltish = _idaapi.PPC_vspltish
PPC_vspltisw = _idaapi.PPC_vspltisw
PPC_vspltw = _idaapi.PPC_vspltw
PPC_vsr = _idaapi.PPC_vsr
PPC_vsrab = _idaapi.PPC_vsrab
PPC_vsrah = _idaapi.PPC_vsrah
PPC_vsraw = _idaapi.PPC_vsraw
PPC_vsrb = _idaapi.PPC_vsrb
PPC_vsrh = _idaapi.PPC_vsrh
PPC_vsro = _idaapi.PPC_vsro
PPC_vsrw = _idaapi.PPC_vsrw
PPC_vsubcuw = _idaapi.PPC_vsubcuw
PPC_vsubfp = _idaapi.PPC_vsubfp
PPC_vsubsbs = _idaapi.PPC_vsubsbs
PPC_vsubshs = _idaapi.PPC_vsubshs
PPC_vsubsws = _idaapi.PPC_vsubsws
PPC_vsububm = _idaapi.PPC_vsububm
PPC_vsububs = _idaapi.PPC_vsububs
PPC_vsubuhm = _idaapi.PPC_vsubuhm
PPC_vsubuhs = _idaapi.PPC_vsubuhs
PPC_vsubuwm = _idaapi.PPC_vsubuwm
PPC_vsubuws = _idaapi.PPC_vsubuws
PPC_vsum2sws = _idaapi.PPC_vsum2sws
PPC_vsum4sbs = _idaapi.PPC_vsum4sbs
PPC_vsum4shs = _idaapi.PPC_vsum4shs
PPC_vsum4ubs = _idaapi.PPC_vsum4ubs
PPC_vsumsws = _idaapi.PPC_vsumsws
PPC_vupkhpx = _idaapi.PPC_vupkhpx
PPC_vupkhsb = _idaapi.PPC_vupkhsb
PPC_vupkhsh = _idaapi.PPC_vupkhsh
PPC_vupklpx = _idaapi.PPC_vupklpx
PPC_vupklsb = _idaapi.PPC_vupklsb
PPC_vupklsh = _idaapi.PPC_vupklsh
PPC_vxor = _idaapi.PPC_vxor
PPC_lxsdx = _idaapi.PPC_lxsdx
PPC_lxvd2x = _idaapi.PPC_lxvd2x
PPC_lxvdsx = _idaapi.PPC_lxvdsx
PPC_lxvw4x = _idaapi.PPC_lxvw4x
PPC_stxsdx = _idaapi.PPC_stxsdx
PPC_stxvd2x = _idaapi.PPC_stxvd2x
PPC_stxvw4x = _idaapi.PPC_stxvw4x
PPC_xsabsdp = _idaapi.PPC_xsabsdp
PPC_xsadddp = _idaapi.PPC_xsadddp
PPC_xscmpodp = _idaapi.PPC_xscmpodp
PPC_xscmpudp = _idaapi.PPC_xscmpudp
PPC_xscpsgndp = _idaapi.PPC_xscpsgndp
PPC_xscvdpsp = _idaapi.PPC_xscvdpsp
PPC_xscvdpsxds = _idaapi.PPC_xscvdpsxds
PPC_xscvdpsxws = _idaapi.PPC_xscvdpsxws
PPC_xscvdpuxds = _idaapi.PPC_xscvdpuxds
PPC_xscvdpuxws = _idaapi.PPC_xscvdpuxws
PPC_xscvspdp = _idaapi.PPC_xscvspdp
PPC_xscvsxddp = _idaapi.PPC_xscvsxddp
PPC_xscvuxddp = _idaapi.PPC_xscvuxddp
PPC_xsdivdp = _idaapi.PPC_xsdivdp
PPC_xsmaddadp = _idaapi.PPC_xsmaddadp
PPC_xsmaddmdp = _idaapi.PPC_xsmaddmdp
PPC_xsmaxdp = _idaapi.PPC_xsmaxdp
PPC_xsmindp = _idaapi.PPC_xsmindp
PPC_xsmsubadp = _idaapi.PPC_xsmsubadp
PPC_xsmsubmdp = _idaapi.PPC_xsmsubmdp
PPC_xsmuldp = _idaapi.PPC_xsmuldp
PPC_xsnabsdp = _idaapi.PPC_xsnabsdp
PPC_xsnegdp = _idaapi.PPC_xsnegdp
PPC_xsnmaddadp = _idaapi.PPC_xsnmaddadp
PPC_xsnmaddmdp = _idaapi.PPC_xsnmaddmdp
PPC_xsnmsubadp = _idaapi.PPC_xsnmsubadp
PPC_xsnmsubmdp = _idaapi.PPC_xsnmsubmdp
PPC_xsrdpi = _idaapi.PPC_xsrdpi
PPC_xsrdpic = _idaapi.PPC_xsrdpic
PPC_xsrdpim = _idaapi.PPC_xsrdpim
PPC_xsrdpip = _idaapi.PPC_xsrdpip
PPC_xsrdpiz = _idaapi.PPC_xsrdpiz
PPC_xsredp = _idaapi.PPC_xsredp
PPC_xsrsqrtedp = _idaapi.PPC_xsrsqrtedp
PPC_xssqrtdp = _idaapi.PPC_xssqrtdp
PPC_xssubdp = _idaapi.PPC_xssubdp
PPC_xstdivdp = _idaapi.PPC_xstdivdp
PPC_xstsqrtdp = _idaapi.PPC_xstsqrtdp
PPC_xvabsdp = _idaapi.PPC_xvabsdp
PPC_xvabssp = _idaapi.PPC_xvabssp
PPC_xvadddp = _idaapi.PPC_xvadddp
PPC_xvaddsp = _idaapi.PPC_xvaddsp
PPC_xvcmpeqdp = _idaapi.PPC_xvcmpeqdp
PPC_xvcmpeqsp = _idaapi.PPC_xvcmpeqsp
PPC_xvcmpgedp = _idaapi.PPC_xvcmpgedp
PPC_xvcmpgesp = _idaapi.PPC_xvcmpgesp
PPC_xvcmpgtdp = _idaapi.PPC_xvcmpgtdp
PPC_xvcmpgtsp = _idaapi.PPC_xvcmpgtsp
PPC_xvcpsgndp = _idaapi.PPC_xvcpsgndp
PPC_xvcpsgnsp = _idaapi.PPC_xvcpsgnsp
PPC_xvcvdpsp = _idaapi.PPC_xvcvdpsp
PPC_xvcvdpsxds = _idaapi.PPC_xvcvdpsxds
PPC_xvcvdpsxws = _idaapi.PPC_xvcvdpsxws
PPC_xvcvdpuxds = _idaapi.PPC_xvcvdpuxds
PPC_xvcvdpuxws = _idaapi.PPC_xvcvdpuxws
PPC_xvcvspdp = _idaapi.PPC_xvcvspdp
PPC_xvcvspsxds = _idaapi.PPC_xvcvspsxds
PPC_xvcvspsxws = _idaapi.PPC_xvcvspsxws
PPC_xvcvspuxds = _idaapi.PPC_xvcvspuxds
PPC_xvcvspuxws = _idaapi.PPC_xvcvspuxws
PPC_xvcvsxddp = _idaapi.PPC_xvcvsxddp
PPC_xvcvsxdsp = _idaapi.PPC_xvcvsxdsp
PPC_xvcvsxwdp = _idaapi.PPC_xvcvsxwdp
PPC_xvcvsxwsp = _idaapi.PPC_xvcvsxwsp
PPC_xvcvuxddp = _idaapi.PPC_xvcvuxddp
PPC_xvcvuxdsp = _idaapi.PPC_xvcvuxdsp
PPC_xvcvuxwdp = _idaapi.PPC_xvcvuxwdp
PPC_xvcvuxwsp = _idaapi.PPC_xvcvuxwsp
PPC_xvdivdp = _idaapi.PPC_xvdivdp
PPC_xvdivsp = _idaapi.PPC_xvdivsp
PPC_xvmaddadp = _idaapi.PPC_xvmaddadp
PPC_xvmaddasp = _idaapi.PPC_xvmaddasp
PPC_xvmaddmdp = _idaapi.PPC_xvmaddmdp
PPC_xvmaddmsp = _idaapi.PPC_xvmaddmsp
PPC_xvmaxdp = _idaapi.PPC_xvmaxdp
PPC_xvmaxsp = _idaapi.PPC_xvmaxsp
PPC_xvmindp = _idaapi.PPC_xvmindp
PPC_xvminsp = _idaapi.PPC_xvminsp
PPC_xvmsubadp = _idaapi.PPC_xvmsubadp
PPC_xvmsubasp = _idaapi.PPC_xvmsubasp
PPC_xvmsubmdp = _idaapi.PPC_xvmsubmdp
PPC_xvmsubmsp = _idaapi.PPC_xvmsubmsp
PPC_xvmuldp = _idaapi.PPC_xvmuldp
PPC_xvmulsp = _idaapi.PPC_xvmulsp
PPC_xvnabsdp = _idaapi.PPC_xvnabsdp
PPC_xvnabssp = _idaapi.PPC_xvnabssp
PPC_xvnegdp = _idaapi.PPC_xvnegdp
PPC_xvnegsp = _idaapi.PPC_xvnegsp
PPC_xvnmaddadp = _idaapi.PPC_xvnmaddadp
PPC_xvnmaddasp = _idaapi.PPC_xvnmaddasp
PPC_xvnmaddmdp = _idaapi.PPC_xvnmaddmdp
PPC_xvnmaddmsp = _idaapi.PPC_xvnmaddmsp
PPC_xvnmsubadp = _idaapi.PPC_xvnmsubadp
PPC_xvnmsubasp = _idaapi.PPC_xvnmsubasp
PPC_xvnmsubmdp = _idaapi.PPC_xvnmsubmdp
PPC_xvnmsubmsp = _idaapi.PPC_xvnmsubmsp
PPC_xvrdpi = _idaapi.PPC_xvrdpi
PPC_xvrdpic = _idaapi.PPC_xvrdpic
PPC_xvrdpim = _idaapi.PPC_xvrdpim
PPC_xvrdpip = _idaapi.PPC_xvrdpip
PPC_xvrdpiz = _idaapi.PPC_xvrdpiz
PPC_xvredp = _idaapi.PPC_xvredp
PPC_xvresp = _idaapi.PPC_xvresp
PPC_xvrspi = _idaapi.PPC_xvrspi
PPC_xvrspic = _idaapi.PPC_xvrspic
PPC_xvrspim = _idaapi.PPC_xvrspim
PPC_xvrspip = _idaapi.PPC_xvrspip
PPC_xvrspiz = _idaapi.PPC_xvrspiz
PPC_xvrsqrtedp = _idaapi.PPC_xvrsqrtedp
PPC_xvrsqrtesp = _idaapi.PPC_xvrsqrtesp
PPC_xvsqrtdp = _idaapi.PPC_xvsqrtdp
PPC_xvsqrtsp = _idaapi.PPC_xvsqrtsp
PPC_xvsubdp = _idaapi.PPC_xvsubdp
PPC_xvsubsp = _idaapi.PPC_xvsubsp
PPC_xvtdivdp = _idaapi.PPC_xvtdivdp
PPC_xvtdivsp = _idaapi.PPC_xvtdivsp
PPC_xvtsqrtdp = _idaapi.PPC_xvtsqrtdp
PPC_xvtsqrtsp = _idaapi.PPC_xvtsqrtsp
PPC_xxland = _idaapi.PPC_xxland
PPC_xxlandc = _idaapi.PPC_xxlandc
PPC_xxlnor = _idaapi.PPC_xxlnor
PPC_xxlor = _idaapi.PPC_xxlor
PPC_xxlxor = _idaapi.PPC_xxlxor
PPC_xxmrghw = _idaapi.PPC_xxmrghw
PPC_xxmrglw = _idaapi.PPC_xxmrglw
PPC_xxpermdi = _idaapi.PPC_xxpermdi
PPC_xxsel = _idaapi.PPC_xxsel
PPC_xxsldwi = _idaapi.PPC_xxsldwi
PPC_xxspltw = _idaapi.PPC_xxspltw
PPC_wait = _idaapi.PPC_wait
PPC_dss = _idaapi.PPC_dss
PPC_dssall = _idaapi.PPC_dssall
PPC_dst = _idaapi.PPC_dst
PPC_dstt = _idaapi.PPC_dstt
PPC_dstst = _idaapi.PPC_dstst
PPC_dststt = _idaapi.PPC_dststt
PPC_lvlx = _idaapi.PPC_lvlx
PPC_lvlxl = _idaapi.PPC_lvlxl
PPC_lvrx = _idaapi.PPC_lvrx
PPC_lvrxl = _idaapi.PPC_lvrxl
PPC_stvlx = _idaapi.PPC_stvlx
PPC_stvlxl = _idaapi.PPC_stvlxl
PPC_stvrx = _idaapi.PPC_stvrx
PPC_stvrxl = _idaapi.PPC_stvrxl
PPC_add16i = _idaapi.PPC_add16i
PPC_add2i = _idaapi.PPC_add2i
PPC_add2is = _idaapi.PPC_add2is
PPC_and2i = _idaapi.PPC_and2i
PPC_and2is = _idaapi.PPC_and2is
PPC_cmp16i = _idaapi.PPC_cmp16i
PPC_cmph = _idaapi.PPC_cmph
PPC_cmph16i = _idaapi.PPC_cmph16i
PPC_cmphl = _idaapi.PPC_cmphl
PPC_cmphl16i = _idaapi.PPC_cmphl16i
PPC_cmpl16i = _idaapi.PPC_cmpl16i
PPC_mull2i = _idaapi.PPC_mull2i
PPC_or2i = _idaapi.PPC_or2i
PPC_or2is = _idaapi.PPC_or2is
PPC_rlw = _idaapi.PPC_rlw
PPC_rlwi = _idaapi.PPC_rlwi
PPC_bclri = _idaapi.PPC_bclri
PPC_bgeni = _idaapi.PPC_bgeni
PPC_bmaski = _idaapi.PPC_bmaski
PPC_bseti = _idaapi.PPC_bseti
PPC_btsti = _idaapi.PPC_btsti
PPC_extzb = _idaapi.PPC_extzb
PPC_extzh = _idaapi.PPC_extzh
PPC_illegal = _idaapi.PPC_illegal
PPC_mfar = _idaapi.PPC_mfar
PPC_mtar = _idaapi.PPC_mtar
PPC_sub = _idaapi.PPC_sub
PPC_sub16i = _idaapi.PPC_sub16i
PPC_sub2i = _idaapi.PPC_sub2i
PPC_sub2is = _idaapi.PPC_sub2is
PPC_extldi = _idaapi.PPC_extldi
PPC_extrdi = _idaapi.PPC_extrdi
PPC_insrdi = _idaapi.PPC_insrdi
PPC_rotldi = _idaapi.PPC_rotldi
PPC_rotrdi = _idaapi.PPC_rotrdi
PPC_rotld = _idaapi.PPC_rotld
PPC_sldi = _idaapi.PPC_sldi
PPC_srdi = _idaapi.PPC_srdi
PPC_clrldi = _idaapi.PPC_clrldi
PPC_clrrdi = _idaapi.PPC_clrrdi
PPC_clrlsldi = _idaapi.PPC_clrlsldi
PPC_xnop = _idaapi.PPC_xnop
PPC_hnop = _idaapi.PPC_hnop
PPC_dcbfl = _idaapi.PPC_dcbfl
PPC_dcbflp = _idaapi.PPC_dcbflp
PPC_dcbtt = _idaapi.PPC_dcbtt
PPC_dcbtstt = _idaapi.PPC_dcbtstt
PPC_lwsync = _idaapi.PPC_lwsync
PPC_ptesync = _idaapi.PPC_ptesync
PPC_waitrsv = _idaapi.PPC_waitrsv
PPC_waitimpl = _idaapi.PPC_waitimpl
PPC_evmr = _idaapi.PPC_evmr
PPC_evnot = _idaapi.PPC_evnot
PPC_mtcr = _idaapi.PPC_mtcr
PPC_xvmovdp = _idaapi.PPC_xvmovdp
PPC_xvmovsp = _idaapi.PPC_xvmovsp
PPC_xxspltd = _idaapi.PPC_xxspltd
PPC_xxmrghd = _idaapi.PPC_xxmrghd
PPC_xxmrgld = _idaapi.PPC_xxmrgld
PPC_xxswapd = _idaapi.PPC_xxswapd
PPC_dcbz128 = _idaapi.PPC_dcbz128
PPC_mtmsree = _idaapi.PPC_mtmsree
PPC_vcfpsxws = _idaapi.PPC_vcfpsxws
PPC_vcfpuxws = _idaapi.PPC_vcfpuxws
PPC_vcsxwfp = _idaapi.PPC_vcsxwfp
PPC_vcuxwfp = _idaapi.PPC_vcuxwfp
PPC_vmaddcfp = _idaapi.PPC_vmaddcfp
PPC_vmsum3fp = _idaapi.PPC_vmsum3fp
PPC_vmsum4fp = _idaapi.PPC_vmsum4fp
PPC_vmulfp = _idaapi.PPC_vmulfp
PPC_vpermwi = _idaapi.PPC_vpermwi
PPC_vpkd3d = _idaapi.PPC_vpkd3d
PPC_vrlimi = _idaapi.PPC_vrlimi
PPC_vupkd3d = _idaapi.PPC_vupkd3d
PPC_ps_cmpu0 = _idaapi.PPC_ps_cmpu0
PPC_psq_lx = _idaapi.PPC_psq_lx
PPC_psq_stx = _idaapi.PPC_psq_stx
PPC_ps_sum0 = _idaapi.PPC_ps_sum0
PPC_ps_sum1 = _idaapi.PPC_ps_sum1
PPC_ps_muls0 = _idaapi.PPC_ps_muls0
PPC_ps_muls1 = _idaapi.PPC_ps_muls1
PPC_ps_madds0 = _idaapi.PPC_ps_madds0
PPC_ps_madds1 = _idaapi.PPC_ps_madds1
PPC_ps_div = _idaapi.PPC_ps_div
PPC_ps_sub = _idaapi.PPC_ps_sub
PPC_ps_add = _idaapi.PPC_ps_add
PPC_ps_sel = _idaapi.PPC_ps_sel
PPC_ps_res = _idaapi.PPC_ps_res
PPC_ps_mul = _idaapi.PPC_ps_mul
PPC_ps_rsqrte = _idaapi.PPC_ps_rsqrte
PPC_ps_msub = _idaapi.PPC_ps_msub
PPC_ps_madd = _idaapi.PPC_ps_madd
PPC_ps_nmsub = _idaapi.PPC_ps_nmsub
PPC_ps_nmadd = _idaapi.PPC_ps_nmadd
PPC_ps_cmpo0 = _idaapi.PPC_ps_cmpo0
PPC_psq_lux = _idaapi.PPC_psq_lux
PPC_psq_stux = _idaapi.PPC_psq_stux
PPC_ps_neg = _idaapi.PPC_ps_neg
PPC_ps_cmpu1 = _idaapi.PPC_ps_cmpu1
PPC_ps_mr = _idaapi.PPC_ps_mr
PPC_ps_cmpo1 = _idaapi.PPC_ps_cmpo1
PPC_ps_nabs = _idaapi.PPC_ps_nabs
PPC_ps_abs = _idaapi.PPC_ps_abs
PPC_ps_merge00 = _idaapi.PPC_ps_merge00
PPC_ps_merge01 = _idaapi.PPC_ps_merge01
PPC_ps_merge10 = _idaapi.PPC_ps_merge10
PPC_ps_merge11 = _idaapi.PPC_ps_merge11
PPC_dcbz_l = _idaapi.PPC_dcbz_l
PPC_psq_l = _idaapi.PPC_psq_l
PPC_psq_lu = _idaapi.PPC_psq_lu
PPC_psq_st = _idaapi.PPC_psq_st
PPC_psq_stu = _idaapi.PPC_psq_stu
PPC_evfsmadd = _idaapi.PPC_evfsmadd
PPC_evfsmsub = _idaapi.PPC_evfsmsub
PPC_evfssqrt = _idaapi.PPC_evfssqrt
PPC_evfsnmadd = _idaapi.PPC_evfsnmadd
PPC_evfsnmsub = _idaapi.PPC_evfsnmsub
PPC_evfsmax = _idaapi.PPC_evfsmax
PPC_evfsmin = _idaapi.PPC_evfsmin
PPC_evfsaddsub = _idaapi.PPC_evfsaddsub
PPC_evfssubadd = _idaapi.PPC_evfssubadd
PPC_evfssum = _idaapi.PPC_evfssum
PPC_evfsdiff = _idaapi.PPC_evfsdiff
PPC_evfssumdiff = _idaapi.PPC_evfssumdiff
PPC_evfsdiffsum = _idaapi.PPC_evfsdiffsum
PPC_evfsaddx = _idaapi.PPC_evfsaddx
PPC_evfssubx = _idaapi.PPC_evfssubx
PPC_evfsaddsubx = _idaapi.PPC_evfsaddsubx
PPC_evfssubaddx = _idaapi.PPC_evfssubaddx
PPC_evfsmulx = _idaapi.PPC_evfsmulx
PPC_evfsmule = _idaapi.PPC_evfsmule
PPC_evfsmulo = _idaapi.PPC_evfsmulo
PPC_evfscfh = _idaapi.PPC_evfscfh
PPC_evfscth = _idaapi.PPC_evfscth
PPC_efsmax = _idaapi.PPC_efsmax
PPC_efsmin = _idaapi.PPC_efsmin
PPC_efsmadd = _idaapi.PPC_efsmadd
PPC_efsmsub = _idaapi.PPC_efsmsub
PPC_efssqrt = _idaapi.PPC_efssqrt
PPC_efsnmadd = _idaapi.PPC_efsnmadd
PPC_efsnmsub = _idaapi.PPC_efsnmsub
PPC_efscfh = _idaapi.PPC_efscfh
PPC_efscth = _idaapi.PPC_efscth
PPC_lmvgprw = _idaapi.PPC_lmvgprw
PPC_stmvgprw = _idaapi.PPC_stmvgprw
PPC_lmvsprw = _idaapi.PPC_lmvsprw
PPC_stmvsprw = _idaapi.PPC_stmvsprw
PPC_lmvsrrw = _idaapi.PPC_lmvsrrw
PPC_stmvsrrw = _idaapi.PPC_stmvsrrw
PPC_lmvcsrrw = _idaapi.PPC_lmvcsrrw
PPC_stmvcsrrw = _idaapi.PPC_stmvcsrrw
PPC_lmvdsrrw = _idaapi.PPC_lmvdsrrw
PPC_stmvdsrrw = _idaapi.PPC_stmvdsrrw
PPC_lmvmcsrrw = _idaapi.PPC_lmvmcsrrw
PPC_stmvmcsrrw = _idaapi.PPC_stmvmcsrrw
PPC_evdotpwcssi = _idaapi.PPC_evdotpwcssi
PPC_evdotpwcsmi = _idaapi.PPC_evdotpwcsmi
PPC_evdotpwcssfr = _idaapi.PPC_evdotpwcssfr
PPC_evdotpwcssf = _idaapi.PPC_evdotpwcssf
PPC_evdotpwgasmf = _idaapi.PPC_evdotpwgasmf
PPC_evdotpwxgasmf = _idaapi.PPC_evdotpwxgasmf
PPC_evdotpwgasmfr = _idaapi.PPC_evdotpwgasmfr
PPC_evdotpwxgasmfr = _idaapi.PPC_evdotpwxgasmfr
PPC_evdotpwgssmf = _idaapi.PPC_evdotpwgssmf
PPC_evdotpwxgssmf = _idaapi.PPC_evdotpwxgssmf
PPC_evdotpwgssmfr = _idaapi.PPC_evdotpwgssmfr
PPC_evdotpwxgssmfr = _idaapi.PPC_evdotpwxgssmfr
PPC_evdotpwcssiaaw3 = _idaapi.PPC_evdotpwcssiaaw3
PPC_evdotpwcsmiaaw3 = _idaapi.PPC_evdotpwcsmiaaw3
PPC_evdotpwcssfraaw3 = _idaapi.PPC_evdotpwcssfraaw3
PPC_evdotpwcssfaaw3 = _idaapi.PPC_evdotpwcssfaaw3
PPC_evdotpwgasmfaa3 = _idaapi.PPC_evdotpwgasmfaa3
PPC_evdotpwxgasmfaa3 = _idaapi.PPC_evdotpwxgasmfaa3
PPC_evdotpwgasmfraa3 = _idaapi.PPC_evdotpwgasmfraa3
PPC_evdotpwxgasmfraa3 = _idaapi.PPC_evdotpwxgasmfraa3
PPC_evdotpwgssmfaa3 = _idaapi.PPC_evdotpwgssmfaa3
PPC_evdotpwxgssmfaa3 = _idaapi.PPC_evdotpwxgssmfaa3
PPC_evdotpwgssmfraa3 = _idaapi.PPC_evdotpwgssmfraa3
PPC_evdotpwxgssmfraa3 = _idaapi.PPC_evdotpwxgssmfraa3
PPC_evdotpwcssia = _idaapi.PPC_evdotpwcssia
PPC_evdotpwcsmia = _idaapi.PPC_evdotpwcsmia
PPC_evdotpwcssfra = _idaapi.PPC_evdotpwcssfra
PPC_evdotpwcssfa = _idaapi.PPC_evdotpwcssfa
PPC_evdotpwgasmfa = _idaapi.PPC_evdotpwgasmfa
PPC_evdotpwxgasmfa = _idaapi.PPC_evdotpwxgasmfa
PPC_evdotpwgasmfra = _idaapi.PPC_evdotpwgasmfra
PPC_evdotpwxgasmfra = _idaapi.PPC_evdotpwxgasmfra
PPC_evdotpwgssmfa = _idaapi.PPC_evdotpwgssmfa
PPC_evdotpwxgssmfa = _idaapi.PPC_evdotpwxgssmfa
PPC_evdotpwgssmfra = _idaapi.PPC_evdotpwgssmfra
PPC_evdotpwxgssmfra = _idaapi.PPC_evdotpwxgssmfra
PPC_evdotpwcssiaaw = _idaapi.PPC_evdotpwcssiaaw
PPC_evdotpwcsmiaaw = _idaapi.PPC_evdotpwcsmiaaw
PPC_evdotpwcssfraaw = _idaapi.PPC_evdotpwcssfraaw
PPC_evdotpwcssfaaw = _idaapi.PPC_evdotpwcssfaaw
PPC_evdotpwgasmfaa = _idaapi.PPC_evdotpwgasmfaa
PPC_evdotpwxgasmfaa = _idaapi.PPC_evdotpwxgasmfaa
PPC_evdotpwgasmfraa = _idaapi.PPC_evdotpwgasmfraa
PPC_evdotpwxgasmfraa = _idaapi.PPC_evdotpwxgasmfraa
PPC_evdotpwgssmfaa = _idaapi.PPC_evdotpwgssmfaa
PPC_evdotpwxgssmfaa = _idaapi.PPC_evdotpwxgssmfaa
PPC_evdotpwgssmfraa = _idaapi.PPC_evdotpwgssmfraa
PPC_evdotpwxgssmfraa = _idaapi.PPC_evdotpwxgssmfraa
PPC_evdotphihcssi = _idaapi.PPC_evdotphihcssi
PPC_evdotplohcssi = _idaapi.PPC_evdotplohcssi
PPC_evdotphihcssf = _idaapi.PPC_evdotphihcssf
PPC_evdotplohcssf = _idaapi.PPC_evdotplohcssf
PPC_evdotphihcsmi = _idaapi.PPC_evdotphihcsmi
PPC_evdotplohcsmi = _idaapi.PPC_evdotplohcsmi
PPC_evdotphihcssfr = _idaapi.PPC_evdotphihcssfr
PPC_evdotplohcssfr = _idaapi.PPC_evdotplohcssfr
PPC_evdotphihcssiaaw3 = _idaapi.PPC_evdotphihcssiaaw3
PPC_evdotplohcssiaaw3 = _idaapi.PPC_evdotplohcssiaaw3
PPC_evdotphihcssfaaw3 = _idaapi.PPC_evdotphihcssfaaw3
PPC_evdotplohcssfaaw3 = _idaapi.PPC_evdotplohcssfaaw3
PPC_evdotphihcsmiaaw3 = _idaapi.PPC_evdotphihcsmiaaw3
PPC_evdotplohcsmiaaw3 = _idaapi.PPC_evdotplohcsmiaaw3
PPC_evdotphihcssfraaw3 = _idaapi.PPC_evdotphihcssfraaw3
PPC_evdotplohcssfraaw3 = _idaapi.PPC_evdotplohcssfraaw3
PPC_evdotphihcssia = _idaapi.PPC_evdotphihcssia
PPC_evdotplohcssia = _idaapi.PPC_evdotplohcssia
PPC_evdotphihcssfa = _idaapi.PPC_evdotphihcssfa
PPC_evdotplohcssfa = _idaapi.PPC_evdotplohcssfa
PPC_evdotphihcsmia = _idaapi.PPC_evdotphihcsmia
PPC_evdotplohcsmia = _idaapi.PPC_evdotplohcsmia
PPC_evdotphihcssfra = _idaapi.PPC_evdotphihcssfra
PPC_evdotplohcssfra = _idaapi.PPC_evdotplohcssfra
PPC_evdotphihcssiaaw = _idaapi.PPC_evdotphihcssiaaw
PPC_evdotplohcssiaaw = _idaapi.PPC_evdotplohcssiaaw
PPC_evdotphihcssfaaw = _idaapi.PPC_evdotphihcssfaaw
PPC_evdotplohcssfaaw = _idaapi.PPC_evdotplohcssfaaw
PPC_evdotphihcsmiaaw = _idaapi.PPC_evdotphihcsmiaaw
PPC_evdotplohcsmiaaw = _idaapi.PPC_evdotplohcsmiaaw
PPC_evdotphihcssfraaw = _idaapi.PPC_evdotphihcssfraaw
PPC_evdotplohcssfraaw = _idaapi.PPC_evdotplohcssfraaw
PPC_evdotphausi = _idaapi.PPC_evdotphausi
PPC_evdotphassi = _idaapi.PPC_evdotphassi
PPC_evdotphasusi = _idaapi.PPC_evdotphasusi
PPC_evdotphassf = _idaapi.PPC_evdotphassf
PPC_evdotphsssf = _idaapi.PPC_evdotphsssf
PPC_evdotphaumi = _idaapi.PPC_evdotphaumi
PPC_evdotphasmi = _idaapi.PPC_evdotphasmi
PPC_evdotphasumi = _idaapi.PPC_evdotphasumi
PPC_evdotphassfr = _idaapi.PPC_evdotphassfr
PPC_evdotphssmi = _idaapi.PPC_evdotphssmi
PPC_evdotphsssfr = _idaapi.PPC_evdotphsssfr
PPC_evdotphausiaaw3 = _idaapi.PPC_evdotphausiaaw3
PPC_evdotphassiaaw3 = _idaapi.PPC_evdotphassiaaw3
PPC_evdotphasusiaaw3 = _idaapi.PPC_evdotphasusiaaw3
PPC_evdotphassfaaw3 = _idaapi.PPC_evdotphassfaaw3
PPC_evdotphsssiaaw3 = _idaapi.PPC_evdotphsssiaaw3
PPC_evdotphsssfaaw3 = _idaapi.PPC_evdotphsssfaaw3
PPC_evdotphaumiaaw3 = _idaapi.PPC_evdotphaumiaaw3
PPC_evdotphasmiaaw3 = _idaapi.PPC_evdotphasmiaaw3
PPC_evdotphasumiaaw3 = _idaapi.PPC_evdotphasumiaaw3
PPC_evdotphassfraaw3 = _idaapi.PPC_evdotphassfraaw3
PPC_evdotphssmiaaw3 = _idaapi.PPC_evdotphssmiaaw3
PPC_evdotphsssfraaw3 = _idaapi.PPC_evdotphsssfraaw3
PPC_evdotphausia = _idaapi.PPC_evdotphausia
PPC_evdotphassia = _idaapi.PPC_evdotphassia
PPC_evdotphasusia = _idaapi.PPC_evdotphasusia
PPC_evdotphassfa = _idaapi.PPC_evdotphassfa
PPC_evdotphsssfa = _idaapi.PPC_evdotphsssfa
PPC_evdotphaumia = _idaapi.PPC_evdotphaumia
PPC_evdotphasmia = _idaapi.PPC_evdotphasmia
PPC_evdotphasumia = _idaapi.PPC_evdotphasumia
PPC_evdotphassfra = _idaapi.PPC_evdotphassfra
PPC_evdotphssmia = _idaapi.PPC_evdotphssmia
PPC_evdotphsssfra = _idaapi.PPC_evdotphsssfra
PPC_evdotphausiaaw = _idaapi.PPC_evdotphausiaaw
PPC_evdotphassiaaw = _idaapi.PPC_evdotphassiaaw
PPC_evdotphasusiaaw = _idaapi.PPC_evdotphasusiaaw
PPC_evdotphassfaaw = _idaapi.PPC_evdotphassfaaw
PPC_evdotphsssiaaw = _idaapi.PPC_evdotphsssiaaw
PPC_evdotphsssfaaw = _idaapi.PPC_evdotphsssfaaw
PPC_evdotphaumiaaw = _idaapi.PPC_evdotphaumiaaw
PPC_evdotphasmiaaw = _idaapi.PPC_evdotphasmiaaw
PPC_evdotphasumiaaw = _idaapi.PPC_evdotphasumiaaw
PPC_evdotphassfraaw = _idaapi.PPC_evdotphassfraaw
PPC_evdotphssmiaaw = _idaapi.PPC_evdotphssmiaaw
PPC_evdotphsssfraaw = _idaapi.PPC_evdotphsssfraaw
PPC_evdotp4hgaumi = _idaapi.PPC_evdotp4hgaumi
PPC_evdotp4hgasmi = _idaapi.PPC_evdotp4hgasmi
PPC_evdotp4hgasumi = _idaapi.PPC_evdotp4hgasumi
PPC_evdotp4hgasmf = _idaapi.PPC_evdotp4hgasmf
PPC_evdotp4hgssmi = _idaapi.PPC_evdotp4hgssmi
PPC_evdotp4hgssmf = _idaapi.PPC_evdotp4hgssmf
PPC_evdotp4hxgasmi = _idaapi.PPC_evdotp4hxgasmi
PPC_evdotp4hxgasmf = _idaapi.PPC_evdotp4hxgasmf
PPC_evdotpbaumi = _idaapi.PPC_evdotpbaumi
PPC_evdotpbasmi = _idaapi.PPC_evdotpbasmi
PPC_evdotpbasumi = _idaapi.PPC_evdotpbasumi
PPC_evdotp4hxgssmi = _idaapi.PPC_evdotp4hxgssmi
PPC_evdotp4hxgssmf = _idaapi.PPC_evdotp4hxgssmf
PPC_evdotp4hgaumiaa3 = _idaapi.PPC_evdotp4hgaumiaa3
PPC_evdotp4hgasmiaa3 = _idaapi.PPC_evdotp4hgasmiaa3
PPC_evdotp4hgasumiaa3 = _idaapi.PPC_evdotp4hgasumiaa3
PPC_evdotp4hgasmfaa3 = _idaapi.PPC_evdotp4hgasmfaa3
PPC_evdotp4hgssmiaa3 = _idaapi.PPC_evdotp4hgssmiaa3
PPC_evdotp4hgssmfaa3 = _idaapi.PPC_evdotp4hgssmfaa3
PPC_evdotp4hxgasmiaa3 = _idaapi.PPC_evdotp4hxgasmiaa3
PPC_evdotp4hxgasmfaa3 = _idaapi.PPC_evdotp4hxgasmfaa3
PPC_evdotpbaumiaaw3 = _idaapi.PPC_evdotpbaumiaaw3
PPC_evdotpbasmiaaw3 = _idaapi.PPC_evdotpbasmiaaw3
PPC_evdotpbasumiaaw3 = _idaapi.PPC_evdotpbasumiaaw3
PPC_evdotp4hxgssmiaa3 = _idaapi.PPC_evdotp4hxgssmiaa3
PPC_evdotp4hxgssmfaa3 = _idaapi.PPC_evdotp4hxgssmfaa3
PPC_evdotp4hgaumia = _idaapi.PPC_evdotp4hgaumia
PPC_evdotp4hgasmia = _idaapi.PPC_evdotp4hgasmia
PPC_evdotp4hgasumia = _idaapi.PPC_evdotp4hgasumia
PPC_evdotp4hgasmfa = _idaapi.PPC_evdotp4hgasmfa
PPC_evdotp4hgssmia = _idaapi.PPC_evdotp4hgssmia
PPC_evdotp4hgssmfa = _idaapi.PPC_evdotp4hgssmfa
PPC_evdotp4hxgasmia = _idaapi.PPC_evdotp4hxgasmia
PPC_evdotp4hxgasmfa = _idaapi.PPC_evdotp4hxgasmfa
PPC_evdotpbaumia = _idaapi.PPC_evdotpbaumia
PPC_evdotpbasmia = _idaapi.PPC_evdotpbasmia
PPC_evdotpbasumia = _idaapi.PPC_evdotpbasumia
PPC_evdotp4hxgssmia = _idaapi.PPC_evdotp4hxgssmia
PPC_evdotp4hxgssmfa = _idaapi.PPC_evdotp4hxgssmfa
PPC_evdotp4hgaumiaa = _idaapi.PPC_evdotp4hgaumiaa
PPC_evdotp4hgasmiaa = _idaapi.PPC_evdotp4hgasmiaa
PPC_evdotp4hgasumiaa = _idaapi.PPC_evdotp4hgasumiaa
PPC_evdotp4hgasmfaa = _idaapi.PPC_evdotp4hgasmfaa
PPC_evdotp4hgssmiaa = _idaapi.PPC_evdotp4hgssmiaa
PPC_evdotp4hgssmfaa = _idaapi.PPC_evdotp4hgssmfaa
PPC_evdotp4hxgasmiaa = _idaapi.PPC_evdotp4hxgasmiaa
PPC_evdotp4hxgasmfaa = _idaapi.PPC_evdotp4hxgasmfaa
PPC_evdotpbaumiaaw = _idaapi.PPC_evdotpbaumiaaw
PPC_evdotpbasmiaaw = _idaapi.PPC_evdotpbasmiaaw
PPC_evdotpbasumiaaw = _idaapi.PPC_evdotpbasumiaaw
PPC_evdotp4hxgssmiaa = _idaapi.PPC_evdotp4hxgssmiaa
PPC_evdotp4hxgssmfaa = _idaapi.PPC_evdotp4hxgssmfaa
PPC_evdotpwausi = _idaapi.PPC_evdotpwausi
PPC_evdotpwassi = _idaapi.PPC_evdotpwassi
PPC_evdotpwasusi = _idaapi.PPC_evdotpwasusi
PPC_evdotpwaumi = _idaapi.PPC_evdotpwaumi
PPC_evdotpwasmi = _idaapi.PPC_evdotpwasmi
PPC_evdotpwasumi = _idaapi.PPC_evdotpwasumi
PPC_evdotpwssmi = _idaapi.PPC_evdotpwssmi
PPC_evdotpwausiaa3 = _idaapi.PPC_evdotpwausiaa3
PPC_evdotpwassiaa3 = _idaapi.PPC_evdotpwassiaa3
PPC_evdotpwasusiaa3 = _idaapi.PPC_evdotpwasusiaa3
PPC_evdotpwsssiaa3 = _idaapi.PPC_evdotpwsssiaa3
PPC_evdotpwaumiaa3 = _idaapi.PPC_evdotpwaumiaa3
PPC_evdotpwasmiaa3 = _idaapi.PPC_evdotpwasmiaa3
PPC_evdotpwasumiaa3 = _idaapi.PPC_evdotpwasumiaa3
PPC_evdotpwssmiaa3 = _idaapi.PPC_evdotpwssmiaa3
PPC_evdotpwausia = _idaapi.PPC_evdotpwausia
PPC_evdotpwassia = _idaapi.PPC_evdotpwassia
PPC_evdotpwasusia = _idaapi.PPC_evdotpwasusia
PPC_evdotpwaumia = _idaapi.PPC_evdotpwaumia
PPC_evdotpwasmia = _idaapi.PPC_evdotpwasmia
PPC_evdotpwasumia = _idaapi.PPC_evdotpwasumia
PPC_evdotpwssmia = _idaapi.PPC_evdotpwssmia
PPC_evdotpwausiaa = _idaapi.PPC_evdotpwausiaa
PPC_evdotpwassiaa = _idaapi.PPC_evdotpwassiaa
PPC_evdotpwasusiaa = _idaapi.PPC_evdotpwasusiaa
PPC_evdotpwsssiaa = _idaapi.PPC_evdotpwsssiaa
PPC_evdotpwaumiaa = _idaapi.PPC_evdotpwaumiaa
PPC_evdotpwasmiaa = _idaapi.PPC_evdotpwasmiaa
PPC_evdotpwasumiaa = _idaapi.PPC_evdotpwasumiaa
PPC_evdotpwssmiaa = _idaapi.PPC_evdotpwssmiaa
PPC_evaddih = _idaapi.PPC_evaddih
PPC_evaddib = _idaapi.PPC_evaddib
PPC_evsubifh = _idaapi.PPC_evsubifh
PPC_evsubifb = _idaapi.PPC_evsubifb
PPC_evabsb = _idaapi.PPC_evabsb
PPC_evabsh = _idaapi.PPC_evabsh
PPC_evabsd = _idaapi.PPC_evabsd
PPC_evabss = _idaapi.PPC_evabss
PPC_evabsbs = _idaapi.PPC_evabsbs
PPC_evabshs = _idaapi.PPC_evabshs
PPC_evabsds = _idaapi.PPC_evabsds
PPC_evnegwo = _idaapi.PPC_evnegwo
PPC_evnegb = _idaapi.PPC_evnegb
PPC_evnegbo = _idaapi.PPC_evnegbo
PPC_evnegh = _idaapi.PPC_evnegh
PPC_evnegho = _idaapi.PPC_evnegho
PPC_evnegd = _idaapi.PPC_evnegd
PPC_evnegs = _idaapi.PPC_evnegs
PPC_evnegwos = _idaapi.PPC_evnegwos
PPC_evnegbs = _idaapi.PPC_evnegbs
PPC_evnegbos = _idaapi.PPC_evnegbos
PPC_evneghs = _idaapi.PPC_evneghs
PPC_evneghos = _idaapi.PPC_evneghos
PPC_evnegds = _idaapi.PPC_evnegds
PPC_evextzb = _idaapi.PPC_evextzb
PPC_evextsbh = _idaapi.PPC_evextsbh
PPC_evextsw = _idaapi.PPC_evextsw
PPC_evrndhb = _idaapi.PPC_evrndhb
PPC_evrnddw = _idaapi.PPC_evrnddw
PPC_evrndwhus = _idaapi.PPC_evrndwhus
PPC_evrndwhss = _idaapi.PPC_evrndwhss
PPC_evrndhbus = _idaapi.PPC_evrndhbus
PPC_evrndhbss = _idaapi.PPC_evrndhbss
PPC_evrnddwus = _idaapi.PPC_evrnddwus
PPC_evrnddwss = _idaapi.PPC_evrnddwss
PPC_evrndwnh = _idaapi.PPC_evrndwnh
PPC_evrndhnb = _idaapi.PPC_evrndhnb
PPC_evrnddnw = _idaapi.PPC_evrnddnw
PPC_evrndwnhus = _idaapi.PPC_evrndwnhus
PPC_evrndwnhss = _idaapi.PPC_evrndwnhss
PPC_evrndhnbus = _idaapi.PPC_evrndhnbus
PPC_evrndhnbss = _idaapi.PPC_evrndhnbss
PPC_evrnddnwus = _idaapi.PPC_evrnddnwus
PPC_evrnddnwss = _idaapi.PPC_evrnddnwss
PPC_evcntlzh = _idaapi.PPC_evcntlzh
PPC_evcntlsh = _idaapi.PPC_evcntlsh
PPC_evpopcntb = _idaapi.PPC_evpopcntb
PPC_circinc = _idaapi.PPC_circinc
PPC_evunpkhibui = _idaapi.PPC_evunpkhibui
PPC_evunpkhibsi = _idaapi.PPC_evunpkhibsi
PPC_evunpkhihui = _idaapi.PPC_evunpkhihui
PPC_evunpkhihsi = _idaapi.PPC_evunpkhihsi
PPC_evunpklobui = _idaapi.PPC_evunpklobui
PPC_evunpklobsi = _idaapi.PPC_evunpklobsi
PPC_evunpklohui = _idaapi.PPC_evunpklohui
PPC_evunpklohsi = _idaapi.PPC_evunpklohsi
PPC_evunpklohf = _idaapi.PPC_evunpklohf
PPC_evunpkhihf = _idaapi.PPC_evunpkhihf
PPC_evunpklowgsf = _idaapi.PPC_evunpklowgsf
PPC_evunpkhiwgsf = _idaapi.PPC_evunpkhiwgsf
PPC_evsatsduw = _idaapi.PPC_evsatsduw
PPC_evsatsdsw = _idaapi.PPC_evsatsdsw
PPC_evsatshub = _idaapi.PPC_evsatshub
PPC_evsatshsb = _idaapi.PPC_evsatshsb
PPC_evsatuwuh = _idaapi.PPC_evsatuwuh
PPC_evsatswsh = _idaapi.PPC_evsatswsh
PPC_evsatswuh = _idaapi.PPC_evsatswuh
PPC_evsatuhub = _idaapi.PPC_evsatuhub
PPC_evsatuduw = _idaapi.PPC_evsatuduw
PPC_evsatuwsw = _idaapi.PPC_evsatuwsw
PPC_evsatshuh = _idaapi.PPC_evsatshuh
PPC_evsatuhsh = _idaapi.PPC_evsatuhsh
PPC_evsatswuw = _idaapi.PPC_evsatswuw
PPC_evsatswgsdf = _idaapi.PPC_evsatswgsdf
PPC_evsatsbub = _idaapi.PPC_evsatsbub
PPC_evsatubsb = _idaapi.PPC_evsatubsb
PPC_evmaxhpuw = _idaapi.PPC_evmaxhpuw
PPC_evmaxhpsw = _idaapi.PPC_evmaxhpsw
PPC_evmaxbpuh = _idaapi.PPC_evmaxbpuh
PPC_evmaxbpsh = _idaapi.PPC_evmaxbpsh
PPC_evmaxwpud = _idaapi.PPC_evmaxwpud
PPC_evmaxwpsd = _idaapi.PPC_evmaxwpsd
PPC_evminhpuw = _idaapi.PPC_evminhpuw
PPC_evminhpsw = _idaapi.PPC_evminhpsw
PPC_evminbpuh = _idaapi.PPC_evminbpuh
PPC_evminbpsh = _idaapi.PPC_evminbpsh
PPC_evminwpud = _idaapi.PPC_evminwpud
PPC_evminwpsd = _idaapi.PPC_evminwpsd
PPC_evmaxmagws = _idaapi.PPC_evmaxmagws
PPC_evsl = _idaapi.PPC_evsl
PPC_evsli = _idaapi.PPC_evsli
PPC_evsplatie = _idaapi.PPC_evsplatie
PPC_evsplatib = _idaapi.PPC_evsplatib
PPC_evsplatibe = _idaapi.PPC_evsplatibe
PPC_evsplatih = _idaapi.PPC_evsplatih
PPC_evsplatihe = _idaapi.PPC_evsplatihe
PPC_evsplatid = _idaapi.PPC_evsplatid
PPC_evsplatia = _idaapi.PPC_evsplatia
PPC_evsplatiea = _idaapi.PPC_evsplatiea
PPC_evsplatiba = _idaapi.PPC_evsplatiba
PPC_evsplatibea = _idaapi.PPC_evsplatibea
PPC_evsplatiha = _idaapi.PPC_evsplatiha
PPC_evsplatihea = _idaapi.PPC_evsplatihea
PPC_evsplatida = _idaapi.PPC_evsplatida
PPC_evsplatfio = _idaapi.PPC_evsplatfio
PPC_evsplatfib = _idaapi.PPC_evsplatfib
PPC_evsplatfibo = _idaapi.PPC_evsplatfibo
PPC_evsplatfih = _idaapi.PPC_evsplatfih
PPC_evsplatfiho = _idaapi.PPC_evsplatfiho
PPC_evsplatfid = _idaapi.PPC_evsplatfid
PPC_evsplatfia = _idaapi.PPC_evsplatfia
PPC_evsplatfioa = _idaapi.PPC_evsplatfioa
PPC_evsplatfiba = _idaapi.PPC_evsplatfiba
PPC_evsplatfiboa = _idaapi.PPC_evsplatfiboa
PPC_evsplatfiha = _idaapi.PPC_evsplatfiha
PPC_evsplatfihoa = _idaapi.PPC_evsplatfihoa
PPC_evsplatfida = _idaapi.PPC_evsplatfida
PPC_evcmpgtdu = _idaapi.PPC_evcmpgtdu
PPC_evcmpgtds = _idaapi.PPC_evcmpgtds
PPC_evcmpltdu = _idaapi.PPC_evcmpltdu
PPC_evcmpltds = _idaapi.PPC_evcmpltds
PPC_evcmpeqd = _idaapi.PPC_evcmpeqd
PPC_evswapbhilo = _idaapi.PPC_evswapbhilo
PPC_evswapblohi = _idaapi.PPC_evswapblohi
PPC_evswaphhilo = _idaapi.PPC_evswaphhilo
PPC_evswaphlohi = _idaapi.PPC_evswaphlohi
PPC_evswaphe = _idaapi.PPC_evswaphe
PPC_evswaphhi = _idaapi.PPC_evswaphhi
PPC_evswaphlo = _idaapi.PPC_evswaphlo
PPC_evswapho = _idaapi.PPC_evswapho
PPC_evinsb = _idaapi.PPC_evinsb
PPC_evxtrb = _idaapi.PPC_evxtrb
PPC_evsplath = _idaapi.PPC_evsplath
PPC_evsplatb = _idaapi.PPC_evsplatb
PPC_evinsh = _idaapi.PPC_evinsh
PPC_evclrbe = _idaapi.PPC_evclrbe
PPC_evclrbo = _idaapi.PPC_evclrbo
PPC_evxtrh = _idaapi.PPC_evxtrh
PPC_evclrh = _idaapi.PPC_evclrh
PPC_evselbitm0 = _idaapi.PPC_evselbitm0
PPC_evselbitm1 = _idaapi.PPC_evselbitm1
PPC_evselbit = _idaapi.PPC_evselbit
PPC_evperm = _idaapi.PPC_evperm
PPC_evperm2 = _idaapi.PPC_evperm2
PPC_evperm3 = _idaapi.PPC_evperm3
PPC_evxtrd = _idaapi.PPC_evxtrd
PPC_evsrbu = _idaapi.PPC_evsrbu
PPC_evsrbs = _idaapi.PPC_evsrbs
PPC_evsrbiu = _idaapi.PPC_evsrbiu
PPC_evsrbis = _idaapi.PPC_evsrbis
PPC_evslb = _idaapi.PPC_evslb
PPC_evrlb = _idaapi.PPC_evrlb
PPC_evslbi = _idaapi.PPC_evslbi
PPC_evrlbi = _idaapi.PPC_evrlbi
PPC_evsrhu = _idaapi.PPC_evsrhu
PPC_evsrhs = _idaapi.PPC_evsrhs
PPC_evsrhiu = _idaapi.PPC_evsrhiu
PPC_evsrhis = _idaapi.PPC_evsrhis
PPC_evslh = _idaapi.PPC_evslh
PPC_evrlh = _idaapi.PPC_evrlh
PPC_evslhi = _idaapi.PPC_evslhi
PPC_evrlhi = _idaapi.PPC_evrlhi
PPC_evsru = _idaapi.PPC_evsru
PPC_evsrs = _idaapi.PPC_evsrs
PPC_evsriu = _idaapi.PPC_evsriu
PPC_evsris = _idaapi.PPC_evsris
PPC_evlvsl = _idaapi.PPC_evlvsl
PPC_evlvsr = _idaapi.PPC_evlvsr
PPC_evsroiu = _idaapi.PPC_evsroiu
PPC_evsloi = _idaapi.PPC_evsloi
PPC_evsrois = _idaapi.PPC_evsrois
PPC_evldbx = _idaapi.PPC_evldbx
PPC_evldb = _idaapi.PPC_evldb
PPC_evlhhsplathx = _idaapi.PPC_evlhhsplathx
PPC_evlhhsplath = _idaapi.PPC_evlhhsplath
PPC_evlwbsplatwx = _idaapi.PPC_evlwbsplatwx
PPC_evlwbsplatw = _idaapi.PPC_evlwbsplatw
PPC_evlwhsplatwx = _idaapi.PPC_evlwhsplatwx
PPC_evlwhsplatw = _idaapi.PPC_evlwhsplatw
PPC_evlbbsplatbx = _idaapi.PPC_evlbbsplatbx
PPC_evlbbsplatb = _idaapi.PPC_evlbbsplatb
PPC_evstdbx = _idaapi.PPC_evstdbx
PPC_evstdb = _idaapi.PPC_evstdb
PPC_evlwbex = _idaapi.PPC_evlwbex
PPC_evlwbe = _idaapi.PPC_evlwbe
PPC_evlwboux = _idaapi.PPC_evlwboux
PPC_evlwbou = _idaapi.PPC_evlwbou
PPC_evlwbosx = _idaapi.PPC_evlwbosx
PPC_evlwbos = _idaapi.PPC_evlwbos
PPC_evstwbex = _idaapi.PPC_evstwbex
PPC_evstwbe = _idaapi.PPC_evstwbe
PPC_evstwbox = _idaapi.PPC_evstwbox
PPC_evstwbo = _idaapi.PPC_evstwbo
PPC_evstwbx = _idaapi.PPC_evstwbx
PPC_evstwb = _idaapi.PPC_evstwb
PPC_evsthbx = _idaapi.PPC_evsthbx
PPC_evsthb = _idaapi.PPC_evsthb
PPC_evlddmx = _idaapi.PPC_evlddmx
PPC_evlddu = _idaapi.PPC_evlddu
PPC_evldwmx = _idaapi.PPC_evldwmx
PPC_evldwu = _idaapi.PPC_evldwu
PPC_evldhmx = _idaapi.PPC_evldhmx
PPC_evldhu = _idaapi.PPC_evldhu
PPC_evldbmx = _idaapi.PPC_evldbmx
PPC_evldbu = _idaapi.PPC_evldbu
PPC_evlhhesplatmx = _idaapi.PPC_evlhhesplatmx
PPC_evlhhesplatu = _idaapi.PPC_evlhhesplatu
PPC_evlhhsplathmx = _idaapi.PPC_evlhhsplathmx
PPC_evlhhsplathu = _idaapi.PPC_evlhhsplathu
PPC_evlhhousplatmx = _idaapi.PPC_evlhhousplatmx
PPC_evlhhousplatu = _idaapi.PPC_evlhhousplatu
PPC_evlhhossplatmx = _idaapi.PPC_evlhhossplatmx
PPC_evlhhossplatu = _idaapi.PPC_evlhhossplatu
PPC_evlwhemx = _idaapi.PPC_evlwhemx
PPC_evlwheu = _idaapi.PPC_evlwheu
PPC_evlwbsplatwmx = _idaapi.PPC_evlwbsplatwmx
PPC_evlwbsplatwu = _idaapi.PPC_evlwbsplatwu
PPC_evlwhoumx = _idaapi.PPC_evlwhoumx
PPC_evlwhouu = _idaapi.PPC_evlwhouu
PPC_evlwhosmx = _idaapi.PPC_evlwhosmx
PPC_evlwhosu = _idaapi.PPC_evlwhosu
PPC_evlwwsplatmx = _idaapi.PPC_evlwwsplatmx
PPC_evlwwsplatu = _idaapi.PPC_evlwwsplatu
PPC_evlwhsplatwmx = _idaapi.PPC_evlwhsplatwmx
PPC_evlwhsplatwu = _idaapi.PPC_evlwhsplatwu
PPC_evlwhsplatmx = _idaapi.PPC_evlwhsplatmx
PPC_evlwhsplatu = _idaapi.PPC_evlwhsplatu
PPC_evlbbsplatbmx = _idaapi.PPC_evlbbsplatbmx
PPC_evlbbsplatbu = _idaapi.PPC_evlbbsplatbu
PPC_evstddmx = _idaapi.PPC_evstddmx
PPC_evstddu = _idaapi.PPC_evstddu
PPC_evstdwmx = _idaapi.PPC_evstdwmx
PPC_evstdwu = _idaapi.PPC_evstdwu
PPC_evstdhmx = _idaapi.PPC_evstdhmx
PPC_evstdhu = _idaapi.PPC_evstdhu
PPC_evstdbmx = _idaapi.PPC_evstdbmx
PPC_evstdbu = _idaapi.PPC_evstdbu
PPC_evlwbemx = _idaapi.PPC_evlwbemx
PPC_evlwbeu = _idaapi.PPC_evlwbeu
PPC_evlwboumx = _idaapi.PPC_evlwboumx
PPC_evlwbouu = _idaapi.PPC_evlwbouu
PPC_evlwbosmx = _idaapi.PPC_evlwbosmx
PPC_evlwbosu = _idaapi.PPC_evlwbosu
PPC_evstwhemx = _idaapi.PPC_evstwhemx
PPC_evstwheu = _idaapi.PPC_evstwheu
PPC_evstwbemx = _idaapi.PPC_evstwbemx
PPC_evstwbeu = _idaapi.PPC_evstwbeu
PPC_evstwhomx = _idaapi.PPC_evstwhomx
PPC_evstwhou = _idaapi.PPC_evstwhou
PPC_evstwbomx = _idaapi.PPC_evstwbomx
PPC_evstwbou = _idaapi.PPC_evstwbou
PPC_evstwwemx = _idaapi.PPC_evstwwemx
PPC_evstwweu = _idaapi.PPC_evstwweu
PPC_evstwbmx = _idaapi.PPC_evstwbmx
PPC_evstwbu = _idaapi.PPC_evstwbu
PPC_evstwwomx = _idaapi.PPC_evstwwomx
PPC_evstwwou = _idaapi.PPC_evstwwou
PPC_evsthbmx = _idaapi.PPC_evsthbmx
PPC_evsthbu = _idaapi.PPC_evsthbu
PPC_evmhusi = _idaapi.PPC_evmhusi
PPC_evmhssi = _idaapi.PPC_evmhssi
PPC_evmhsusi = _idaapi.PPC_evmhsusi
PPC_evmhssf = _idaapi.PPC_evmhssf
PPC_evmhumi = _idaapi.PPC_evmhumi
PPC_evmhssfr = _idaapi.PPC_evmhssfr
PPC_evmhesumi = _idaapi.PPC_evmhesumi
PPC_evmhosumi = _idaapi.PPC_evmhosumi
PPC_evmbeumi = _idaapi.PPC_evmbeumi
PPC_evmbesmi = _idaapi.PPC_evmbesmi
PPC_evmbesumi = _idaapi.PPC_evmbesumi
PPC_evmboumi = _idaapi.PPC_evmboumi
PPC_evmbosmi = _idaapi.PPC_evmbosmi
PPC_evmbosumi = _idaapi.PPC_evmbosumi
PPC_evmhesumia = _idaapi.PPC_evmhesumia
PPC_evmhosumia = _idaapi.PPC_evmhosumia
PPC_evmbeumia = _idaapi.PPC_evmbeumia
PPC_evmbesmia = _idaapi.PPC_evmbesmia
PPC_evmbesumia = _idaapi.PPC_evmbesumia
PPC_evmboumia = _idaapi.PPC_evmboumia
PPC_evmbosmia = _idaapi.PPC_evmbosmia
PPC_evmbosumia = _idaapi.PPC_evmbosumia
PPC_evmwusiw = _idaapi.PPC_evmwusiw
PPC_evmwssiw = _idaapi.PPC_evmwssiw
PPC_evmwhssfr = _idaapi.PPC_evmwhssfr
PPC_evmwehgsmfr = _idaapi.PPC_evmwehgsmfr
PPC_evmwehgsmf = _idaapi.PPC_evmwehgsmf
PPC_evmwohgsmfr = _idaapi.PPC_evmwohgsmfr
PPC_evmwohgsmf = _idaapi.PPC_evmwohgsmf
PPC_evmwhssfra = _idaapi.PPC_evmwhssfra
PPC_evmwehgsmfra = _idaapi.PPC_evmwehgsmfra
PPC_evmwehgsmfa = _idaapi.PPC_evmwehgsmfa
PPC_evmwohgsmfra = _idaapi.PPC_evmwohgsmfra
PPC_evmwohgsmfa = _idaapi.PPC_evmwohgsmfa
PPC_evaddusiaa = _idaapi.PPC_evaddusiaa
PPC_evaddssiaa = _idaapi.PPC_evaddssiaa
PPC_evsubfusiaa = _idaapi.PPC_evsubfusiaa
PPC_evsubfssiaa = _idaapi.PPC_evsubfssiaa
PPC_evaddsmiaa = _idaapi.PPC_evaddsmiaa
PPC_evsubfsmiaa = _idaapi.PPC_evsubfsmiaa
PPC_evaddh = _idaapi.PPC_evaddh
PPC_evaddhss = _idaapi.PPC_evaddhss
PPC_evsubfh = _idaapi.PPC_evsubfh
PPC_evsubfhss = _idaapi.PPC_evsubfhss
PPC_evaddhx = _idaapi.PPC_evaddhx
PPC_evaddhxss = _idaapi.PPC_evaddhxss
PPC_evsubfhx = _idaapi.PPC_evsubfhx
PPC_evsubfhxss = _idaapi.PPC_evsubfhxss
PPC_evaddd = _idaapi.PPC_evaddd
PPC_evadddss = _idaapi.PPC_evadddss
PPC_evsubfd = _idaapi.PPC_evsubfd
PPC_evsubfdss = _idaapi.PPC_evsubfdss
PPC_evaddb = _idaapi.PPC_evaddb
PPC_evaddbss = _idaapi.PPC_evaddbss
PPC_evsubfb = _idaapi.PPC_evsubfb
PPC_evsubfbss = _idaapi.PPC_evsubfbss
PPC_evaddsubfh = _idaapi.PPC_evaddsubfh
PPC_evaddsubfhss = _idaapi.PPC_evaddsubfhss
PPC_evsubfaddh = _idaapi.PPC_evsubfaddh
PPC_evsubfaddhss = _idaapi.PPC_evsubfaddhss
PPC_evaddsubfhx = _idaapi.PPC_evaddsubfhx
PPC_evaddsubfhxss = _idaapi.PPC_evaddsubfhxss
PPC_evsubfaddhx = _idaapi.PPC_evsubfaddhx
PPC_evsubfaddhxss = _idaapi.PPC_evsubfaddhxss
PPC_evadddus = _idaapi.PPC_evadddus
PPC_evaddbus = _idaapi.PPC_evaddbus
PPC_evsubfdus = _idaapi.PPC_evsubfdus
PPC_evsubfbus = _idaapi.PPC_evsubfbus
PPC_evaddwus = _idaapi.PPC_evaddwus
PPC_evaddwxus = _idaapi.PPC_evaddwxus
PPC_evsubfwus = _idaapi.PPC_evsubfwus
PPC_evsubfwxus = _idaapi.PPC_evsubfwxus
PPC_evadd2subf2h = _idaapi.PPC_evadd2subf2h
PPC_evadd2subf2hss = _idaapi.PPC_evadd2subf2hss
PPC_evsubf2add2h = _idaapi.PPC_evsubf2add2h
PPC_evsubf2add2hss = _idaapi.PPC_evsubf2add2hss
PPC_evaddhus = _idaapi.PPC_evaddhus
PPC_evaddhxus = _idaapi.PPC_evaddhxus
PPC_evsubfhus = _idaapi.PPC_evsubfhus
PPC_evsubfhxus = _idaapi.PPC_evsubfhxus
PPC_evaddwss = _idaapi.PPC_evaddwss
PPC_evsubfwss = _idaapi.PPC_evsubfwss
PPC_evaddwx = _idaapi.PPC_evaddwx
PPC_evaddwxss = _idaapi.PPC_evaddwxss
PPC_evsubfwx = _idaapi.PPC_evsubfwx
PPC_evsubfwxss = _idaapi.PPC_evsubfwxss
PPC_evaddsubfw = _idaapi.PPC_evaddsubfw
PPC_evaddsubfwss = _idaapi.PPC_evaddsubfwss
PPC_evsubfaddw = _idaapi.PPC_evsubfaddw
PPC_evsubfaddwss = _idaapi.PPC_evsubfaddwss
PPC_evaddsubfwx = _idaapi.PPC_evaddsubfwx
PPC_evaddsubfwxss = _idaapi.PPC_evaddsubfwxss
PPC_evsubfaddwx = _idaapi.PPC_evsubfaddwx
PPC_evsubfaddwxss = _idaapi.PPC_evsubfaddwxss
PPC_evmar = _idaapi.PPC_evmar
PPC_evsumwu = _idaapi.PPC_evsumwu
PPC_evsumws = _idaapi.PPC_evsumws
PPC_evsum4bu = _idaapi.PPC_evsum4bu
PPC_evsum4bs = _idaapi.PPC_evsum4bs
PPC_evsum2hu = _idaapi.PPC_evsum2hu
PPC_evsum2hs = _idaapi.PPC_evsum2hs
PPC_evdiff2his = _idaapi.PPC_evdiff2his
PPC_evsum2his = _idaapi.PPC_evsum2his
PPC_evsumwua = _idaapi.PPC_evsumwua
PPC_evsumwsa = _idaapi.PPC_evsumwsa
PPC_evsum4bua = _idaapi.PPC_evsum4bua
PPC_evsum4bsa = _idaapi.PPC_evsum4bsa
PPC_evsum2hua = _idaapi.PPC_evsum2hua
PPC_evsum2hsa = _idaapi.PPC_evsum2hsa
PPC_evdiff2hisa = _idaapi.PPC_evdiff2hisa
PPC_evsum2hisa = _idaapi.PPC_evsum2hisa
PPC_evsumwuaa = _idaapi.PPC_evsumwuaa
PPC_evsumwsaa = _idaapi.PPC_evsumwsaa
PPC_evsum4buaaw = _idaapi.PPC_evsum4buaaw
PPC_evsum4bsaaw = _idaapi.PPC_evsum4bsaaw
PPC_evsum2huaaw = _idaapi.PPC_evsum2huaaw
PPC_evsum2hsaaw = _idaapi.PPC_evsum2hsaaw
PPC_evdiff2hisaaw = _idaapi.PPC_evdiff2hisaaw
PPC_evsum2hisaaw = _idaapi.PPC_evsum2hisaaw
PPC_evdivwsf = _idaapi.PPC_evdivwsf
PPC_evdivwuf = _idaapi.PPC_evdivwuf
PPC_evdivs = _idaapi.PPC_evdivs
PPC_evdivu = _idaapi.PPC_evdivu
PPC_evaddwegsi = _idaapi.PPC_evaddwegsi
PPC_evaddwegsf = _idaapi.PPC_evaddwegsf
PPC_evsubfwegsi = _idaapi.PPC_evsubfwegsi
PPC_evsubfwegsf = _idaapi.PPC_evsubfwegsf
PPC_evaddwogsi = _idaapi.PPC_evaddwogsi
PPC_evaddwogsf = _idaapi.PPC_evaddwogsf
PPC_evsubfwogsi = _idaapi.PPC_evsubfwogsi
PPC_evsubfwogsf = _idaapi.PPC_evsubfwogsf
PPC_evaddhhiuw = _idaapi.PPC_evaddhhiuw
PPC_evaddhhisw = _idaapi.PPC_evaddhhisw
PPC_evsubfhhiuw = _idaapi.PPC_evsubfhhiuw
PPC_evsubfhhisw = _idaapi.PPC_evsubfhhisw
PPC_evaddhlouw = _idaapi.PPC_evaddhlouw
PPC_evaddhlosw = _idaapi.PPC_evaddhlosw
PPC_evsubfhlouw = _idaapi.PPC_evsubfhlouw
PPC_evsubfhlosw = _idaapi.PPC_evsubfhlosw
PPC_evmhesusiaaw = _idaapi.PPC_evmhesusiaaw
PPC_evmhosusiaaw = _idaapi.PPC_evmhosusiaaw
PPC_evmhesumiaaw = _idaapi.PPC_evmhesumiaaw
PPC_evmhosumiaaw = _idaapi.PPC_evmhosumiaaw
PPC_evmbeusiaah = _idaapi.PPC_evmbeusiaah
PPC_evmbessiaah = _idaapi.PPC_evmbessiaah
PPC_evmbesusiaah = _idaapi.PPC_evmbesusiaah
PPC_evmbousiaah = _idaapi.PPC_evmbousiaah
PPC_evmbossiaah = _idaapi.PPC_evmbossiaah
PPC_evmbosusiaah = _idaapi.PPC_evmbosusiaah
PPC_evmbeumiaah = _idaapi.PPC_evmbeumiaah
PPC_evmbesmiaah = _idaapi.PPC_evmbesmiaah
PPC_evmbesumiaah = _idaapi.PPC_evmbesumiaah
PPC_evmboumiaah = _idaapi.PPC_evmboumiaah
PPC_evmbosmiaah = _idaapi.PPC_evmbosmiaah
PPC_evmbosumiaah = _idaapi.PPC_evmbosumiaah
PPC_evmwlusiaaw3 = _idaapi.PPC_evmwlusiaaw3
PPC_evmwlssiaaw3 = _idaapi.PPC_evmwlssiaaw3
PPC_evmwhssfraaw3 = _idaapi.PPC_evmwhssfraaw3
PPC_evmwhssfaaw3 = _idaapi.PPC_evmwhssfaaw3
PPC_evmwhssfraaw = _idaapi.PPC_evmwhssfraaw
PPC_evmwhssfaaw = _idaapi.PPC_evmwhssfaaw
PPC_evmwlumiaaw3 = _idaapi.PPC_evmwlumiaaw3
PPC_evmwlsmiaaw3 = _idaapi.PPC_evmwlsmiaaw3
PPC_evmwusiaa = _idaapi.PPC_evmwusiaa
PPC_evmwssiaa = _idaapi.PPC_evmwssiaa
PPC_evmwehgsmfraa = _idaapi.PPC_evmwehgsmfraa
PPC_evmwehgsmfaa = _idaapi.PPC_evmwehgsmfaa
PPC_evmwohgsmfraa = _idaapi.PPC_evmwohgsmfraa
PPC_evmwohgsmfaa = _idaapi.PPC_evmwohgsmfaa
PPC_evmhesusianw = _idaapi.PPC_evmhesusianw
PPC_evmhosusianw = _idaapi.PPC_evmhosusianw
PPC_evmhesumianw = _idaapi.PPC_evmhesumianw
PPC_evmhosumianw = _idaapi.PPC_evmhosumianw
PPC_evmbeusianh = _idaapi.PPC_evmbeusianh
PPC_evmbessianh = _idaapi.PPC_evmbessianh
PPC_evmbesusianh = _idaapi.PPC_evmbesusianh
PPC_evmbousianh = _idaapi.PPC_evmbousianh
PPC_evmbossianh = _idaapi.PPC_evmbossianh
PPC_evmbosusianh = _idaapi.PPC_evmbosusianh
PPC_evmbeumianh = _idaapi.PPC_evmbeumianh
PPC_evmbesmianh = _idaapi.PPC_evmbesmianh
PPC_evmbesumianh = _idaapi.PPC_evmbesumianh
PPC_evmboumianh = _idaapi.PPC_evmboumianh
PPC_evmbosmianh = _idaapi.PPC_evmbosmianh
PPC_evmbosumianh = _idaapi.PPC_evmbosumianh
PPC_evmwlusianw3 = _idaapi.PPC_evmwlusianw3
PPC_evmwlssianw3 = _idaapi.PPC_evmwlssianw3
PPC_evmwhssfranw3 = _idaapi.PPC_evmwhssfranw3
PPC_evmwhssfanw3 = _idaapi.PPC_evmwhssfanw3
PPC_evmwhssfranw = _idaapi.PPC_evmwhssfranw
PPC_evmwhssfanw = _idaapi.PPC_evmwhssfanw
PPC_evmwlumianw3 = _idaapi.PPC_evmwlumianw3
PPC_evmwlsmianw3 = _idaapi.PPC_evmwlsmianw3
PPC_evmwusian = _idaapi.PPC_evmwusian
PPC_evmwssian = _idaapi.PPC_evmwssian
PPC_evmwehgsmfran = _idaapi.PPC_evmwehgsmfran
PPC_evmwehgsmfan = _idaapi.PPC_evmwehgsmfan
PPC_evmwohgsmfran = _idaapi.PPC_evmwohgsmfran
PPC_evmwohgsmfan = _idaapi.PPC_evmwohgsmfan
PPC_evseteqb = _idaapi.PPC_evseteqb
PPC_evseteqh = _idaapi.PPC_evseteqh
PPC_evseteqw = _idaapi.PPC_evseteqw
PPC_evsetgthu = _idaapi.PPC_evsetgthu
PPC_evsetgths = _idaapi.PPC_evsetgths
PPC_evsetgtwu = _idaapi.PPC_evsetgtwu
PPC_evsetgtws = _idaapi.PPC_evsetgtws
PPC_evsetgtbu = _idaapi.PPC_evsetgtbu
PPC_evsetgtbs = _idaapi.PPC_evsetgtbs
PPC_evsetltbu = _idaapi.PPC_evsetltbu
PPC_evsetltbs = _idaapi.PPC_evsetltbs
PPC_evsetlthu = _idaapi.PPC_evsetlthu
PPC_evsetlths = _idaapi.PPC_evsetlths
PPC_evsetltwu = _idaapi.PPC_evsetltwu
PPC_evsetltws = _idaapi.PPC_evsetltws
PPC_evsaduw = _idaapi.PPC_evsaduw
PPC_evsadsw = _idaapi.PPC_evsadsw
PPC_evsad4ub = _idaapi.PPC_evsad4ub
PPC_evsad4sb = _idaapi.PPC_evsad4sb
PPC_evsad2uh = _idaapi.PPC_evsad2uh
PPC_evsad2sh = _idaapi.PPC_evsad2sh
PPC_evsaduwa = _idaapi.PPC_evsaduwa
PPC_evsadswa = _idaapi.PPC_evsadswa
PPC_evsad4uba = _idaapi.PPC_evsad4uba
PPC_evsad4sba = _idaapi.PPC_evsad4sba
PPC_evsad2uha = _idaapi.PPC_evsad2uha
PPC_evsad2sha = _idaapi.PPC_evsad2sha
PPC_evabsdifuw = _idaapi.PPC_evabsdifuw
PPC_evabsdifsw = _idaapi.PPC_evabsdifsw
PPC_evabsdifub = _idaapi.PPC_evabsdifub
PPC_evabsdifsb = _idaapi.PPC_evabsdifsb
PPC_evabsdifuh = _idaapi.PPC_evabsdifuh
PPC_evabsdifsh = _idaapi.PPC_evabsdifsh
PPC_evsaduwaa = _idaapi.PPC_evsaduwaa
PPC_evsadswaa = _idaapi.PPC_evsadswaa
PPC_evsad4ubaaw = _idaapi.PPC_evsad4ubaaw
PPC_evsad4sbaaw = _idaapi.PPC_evsad4sbaaw
PPC_evsad2uhaaw = _idaapi.PPC_evsad2uhaaw
PPC_evsad2shaaw = _idaapi.PPC_evsad2shaaw
PPC_evpkshubs = _idaapi.PPC_evpkshubs
PPC_evpkshsbs = _idaapi.PPC_evpkshsbs
PPC_evpkswuhs = _idaapi.PPC_evpkswuhs
PPC_evpkswshs = _idaapi.PPC_evpkswshs
PPC_evpkuhubs = _idaapi.PPC_evpkuhubs
PPC_evpkuwuhs = _idaapi.PPC_evpkuwuhs
PPC_evpkswshilvs = _idaapi.PPC_evpkswshilvs
PPC_evpkswgshefrs = _idaapi.PPC_evpkswgshefrs
PPC_evpkswshfrs = _idaapi.PPC_evpkswshfrs
PPC_evpkswshilvfrs = _idaapi.PPC_evpkswshilvfrs
PPC_evpksdswfrs = _idaapi.PPC_evpksdswfrs
PPC_evpksdshefrs = _idaapi.PPC_evpksdshefrs
PPC_evpkuduws = _idaapi.PPC_evpkuduws
PPC_evpksdsws = _idaapi.PPC_evpksdsws
PPC_evpkswgswfrs = _idaapi.PPC_evpkswgswfrs
PPC_evilveh = _idaapi.PPC_evilveh
PPC_evilveoh = _idaapi.PPC_evilveoh
PPC_evilvhih = _idaapi.PPC_evilvhih
PPC_evilvhiloh = _idaapi.PPC_evilvhiloh
PPC_evilvloh = _idaapi.PPC_evilvloh
PPC_evilvlohih = _idaapi.PPC_evilvlohih
PPC_evilvoeh = _idaapi.PPC_evilvoeh
PPC_evilvoh = _idaapi.PPC_evilvoh
PPC_evdlveb = _idaapi.PPC_evdlveb
PPC_evdlveh = _idaapi.PPC_evdlveh
PPC_evdlveob = _idaapi.PPC_evdlveob
PPC_evdlveoh = _idaapi.PPC_evdlveoh
PPC_evdlvob = _idaapi.PPC_evdlvob
PPC_evdlvoh = _idaapi.PPC_evdlvoh
PPC_evdlvoeb = _idaapi.PPC_evdlvoeb
PPC_evdlvoeh = _idaapi.PPC_evdlvoeh
PPC_evmaxbu = _idaapi.PPC_evmaxbu
PPC_evmaxbs = _idaapi.PPC_evmaxbs
PPC_evmaxhu = _idaapi.PPC_evmaxhu
PPC_evmaxhs = _idaapi.PPC_evmaxhs
PPC_evmaxwu = _idaapi.PPC_evmaxwu
PPC_evmaxws = _idaapi.PPC_evmaxws
PPC_evmaxdu = _idaapi.PPC_evmaxdu
PPC_evmaxds = _idaapi.PPC_evmaxds
PPC_evminbu = _idaapi.PPC_evminbu
PPC_evminbs = _idaapi.PPC_evminbs
PPC_evminhu = _idaapi.PPC_evminhu
PPC_evminhs = _idaapi.PPC_evminhs
PPC_evminwu = _idaapi.PPC_evminwu
PPC_evminws = _idaapi.PPC_evminws
PPC_evmindu = _idaapi.PPC_evmindu
PPC_evminds = _idaapi.PPC_evminds
PPC_evavgwu = _idaapi.PPC_evavgwu
PPC_evavgws = _idaapi.PPC_evavgws
PPC_evavgbu = _idaapi.PPC_evavgbu
PPC_evavgbs = _idaapi.PPC_evavgbs
PPC_evavghu = _idaapi.PPC_evavghu
PPC_evavghs = _idaapi.PPC_evavghs
PPC_evavgdu = _idaapi.PPC_evavgdu
PPC_evavgds = _idaapi.PPC_evavgds
PPC_evavgwur = _idaapi.PPC_evavgwur
PPC_evavgwsr = _idaapi.PPC_evavgwsr
PPC_evavgbur = _idaapi.PPC_evavgbur
PPC_evavgbsr = _idaapi.PPC_evavgbsr
PPC_evavghur = _idaapi.PPC_evavghur
PPC_evavghsr = _idaapi.PPC_evavghsr
PPC_evavgdur = _idaapi.PPC_evavgdur
PPC_evavgdsr = _idaapi.PPC_evavgdsr
PPC_tdui = _idaapi.PPC_tdui
PPC_tdu = _idaapi.PPC_tdu
PPC_twui = _idaapi.PPC_twui
PPC_twu = _idaapi.PPC_twu
PPC_bctar = _idaapi.PPC_bctar
PPC_clrbhrb = _idaapi.PPC_clrbhrb
PPC_mfbhrbe = _idaapi.PPC_mfbhrbe
PPC_mtsle = _idaapi.PPC_mtsle
PPC_mfvsrd = _idaapi.PPC_mfvsrd
PPC_mfvsrwz = _idaapi.PPC_mfvsrwz
PPC_mtvsrd = _idaapi.PPC_mtvsrd
PPC_mtvsrwa = _idaapi.PPC_mtvsrwa
PPC_mtvsrwz = _idaapi.PPC_mtvsrwz
PPC_fmrgew = _idaapi.PPC_fmrgew
PPC_fmrgow = _idaapi.PPC_fmrgow
PPC_vpksdss = _idaapi.PPC_vpksdss
PPC_vpksdus = _idaapi.PPC_vpksdus
PPC_vpkudus = _idaapi.PPC_vpkudus
PPC_vpkudum = _idaapi.PPC_vpkudum
PPC_vupkhsw = _idaapi.PPC_vupkhsw
PPC_vupklsw = _idaapi.PPC_vupklsw
PPC_vmrgew = _idaapi.PPC_vmrgew
PPC_vmrgow = _idaapi.PPC_vmrgow
PPC_vaddudm = _idaapi.PPC_vaddudm
PPC_vadduqm = _idaapi.PPC_vadduqm
PPC_vaddeuqm = _idaapi.PPC_vaddeuqm
PPC_vaddcuq = _idaapi.PPC_vaddcuq
PPC_vaddecuq = _idaapi.PPC_vaddecuq
PPC_vsubudm = _idaapi.PPC_vsubudm
PPC_vsubuqm = _idaapi.PPC_vsubuqm
PPC_vsubeuqm = _idaapi.PPC_vsubeuqm
PPC_vsubcuq = _idaapi.PPC_vsubcuq
PPC_vsubecuq = _idaapi.PPC_vsubecuq
PPC_vmulesw = _idaapi.PPC_vmulesw
PPC_vmuleuw = _idaapi.PPC_vmuleuw
PPC_vmulosw = _idaapi.PPC_vmulosw
PPC_vmulouw = _idaapi.PPC_vmulouw
PPC_vmuluwm = _idaapi.PPC_vmuluwm
PPC_vmaxsd = _idaapi.PPC_vmaxsd
PPC_vmaxud = _idaapi.PPC_vmaxud
PPC_vminsd = _idaapi.PPC_vminsd
PPC_vminud = _idaapi.PPC_vminud
PPC_vcmpequd = _idaapi.PPC_vcmpequd
PPC_vcmpgtsd = _idaapi.PPC_vcmpgtsd
PPC_vcmpgtud = _idaapi.PPC_vcmpgtud
PPC_veqv = _idaapi.PPC_veqv
PPC_vnand = _idaapi.PPC_vnand
PPC_vorc = _idaapi.PPC_vorc
PPC_vrld = _idaapi.PPC_vrld
PPC_vsld = _idaapi.PPC_vsld
PPC_vsrd = _idaapi.PPC_vsrd
PPC_vsrad = _idaapi.PPC_vsrad
PPC_vcipher = _idaapi.PPC_vcipher
PPC_vcipherlast = _idaapi.PPC_vcipherlast
PPC_vncipher = _idaapi.PPC_vncipher
PPC_vncipherlast = _idaapi.PPC_vncipherlast
PPC_vsbox = _idaapi.PPC_vsbox
PPC_vshasigmad = _idaapi.PPC_vshasigmad
PPC_vshasigmaw = _idaapi.PPC_vshasigmaw
PPC_vpmsumb = _idaapi.PPC_vpmsumb
PPC_vpmsumd = _idaapi.PPC_vpmsumd
PPC_vpmsumh = _idaapi.PPC_vpmsumh
PPC_vpmsumw = _idaapi.PPC_vpmsumw
PPC_vpermxor = _idaapi.PPC_vpermxor
PPC_vgbbd = _idaapi.PPC_vgbbd
PPC_vclzb = _idaapi.PPC_vclzb
PPC_vclzh = _idaapi.PPC_vclzh
PPC_vclzw = _idaapi.PPC_vclzw
PPC_vclzd = _idaapi.PPC_vclzd
PPC_vpopcntb = _idaapi.PPC_vpopcntb
PPC_vpopcntd = _idaapi.PPC_vpopcntd
PPC_vpopcnth = _idaapi.PPC_vpopcnth
PPC_vpopcntw = _idaapi.PPC_vpopcntw
PPC_vbpermq = _idaapi.PPC_vbpermq
PPC_bcdadd = _idaapi.PPC_bcdadd
PPC_bcdsub = _idaapi.PPC_bcdsub
PPC_lxsiwax = _idaapi.PPC_lxsiwax
PPC_lxsspx = _idaapi.PPC_lxsspx
PPC_lxsiwzx = _idaapi.PPC_lxsiwzx
PPC_stxsiwx = _idaapi.PPC_stxsiwx
PPC_stxsspx = _idaapi.PPC_stxsspx
PPC_xsaddsp = _idaapi.PPC_xsaddsp
PPC_xscvdpspn = _idaapi.PPC_xscvdpspn
PPC_xscvspdpn = _idaapi.PPC_xscvspdpn
PPC_xscvsxdsp = _idaapi.PPC_xscvsxdsp
PPC_xscvuxdsp = _idaapi.PPC_xscvuxdsp
PPC_xsdivsp = _idaapi.PPC_xsdivsp
PPC_xsmaddasp = _idaapi.PPC_xsmaddasp
PPC_xsmaddmsp = _idaapi.PPC_xsmaddmsp
PPC_xsmsubasp = _idaapi.PPC_xsmsubasp
PPC_xsmsubmsp = _idaapi.PPC_xsmsubmsp
PPC_xsmulsp = _idaapi.PPC_xsmulsp
PPC_xsnmaddasp = _idaapi.PPC_xsnmaddasp
PPC_xsnmaddmsp = _idaapi.PPC_xsnmaddmsp
PPC_xsnmsubasp = _idaapi.PPC_xsnmsubasp
PPC_xsnmsubmsp = _idaapi.PPC_xsnmsubmsp
PPC_xsresp = _idaapi.PPC_xsresp
PPC_xsrsp = _idaapi.PPC_xsrsp
PPC_xsrsqrtesp = _idaapi.PPC_xsrsqrtesp
PPC_xssqrtsp = _idaapi.PPC_xssqrtsp
PPC_xssubsp = _idaapi.PPC_xssubsp
PPC_xxleqv = _idaapi.PPC_xxleqv
PPC_xxlnand = _idaapi.PPC_xxlnand
PPC_xxlorc = _idaapi.PPC_xxlorc
PPC_lqarx = _idaapi.PPC_lqarx
PPC_stqcx = _idaapi.PPC_stqcx
PPC_tbegin = _idaapi.PPC_tbegin
PPC_tend = _idaapi.PPC_tend
PPC_tabort = _idaapi.PPC_tabort
PPC_tabortwc = _idaapi.PPC_tabortwc
PPC_tabortwci = _idaapi.PPC_tabortwci
PPC_tabortdc = _idaapi.PPC_tabortdc
PPC_tabortdci = _idaapi.PPC_tabortdci
PPC_tsr = _idaapi.PPC_tsr
PPC_tcheck = _idaapi.PPC_tcheck
PPC_rfebb = _idaapi.PPC_rfebb
PPC_treclaim = _idaapi.PPC_treclaim
PPC_trechkpt = _idaapi.PPC_trechkpt
PPC_msgsndp = _idaapi.PPC_msgsndp
PPC_msgclrp = _idaapi.PPC_msgclrp
PPC_dcblq = _idaapi.PPC_dcblq
PPC_icblq = _idaapi.PPC_icblq
PPC_vmr = _idaapi.PPC_vmr
PPC_vnot = _idaapi.PPC_vnot
PPC_tendall = _idaapi.PPC_tendall
PPC_tsuspend = _idaapi.PPC_tsuspend
PPC_tresume = _idaapi.PPC_tresume
PPC_mtppr = _idaapi.PPC_mtppr
PPC_mfppr = _idaapi.PPC_mfppr
PPC_mtppr32 = _idaapi.PPC_mtppr32
PPC_mfppr32 = _idaapi.PPC_mfppr32
PPC_mtic = _idaapi.PPC_mtic
PPC_mfic = _idaapi.PPC_mfic
PPC_mtvtb = _idaapi.PPC_mtvtb
PPC_mfvtb = _idaapi.PPC_mfvtb
PPC_miso = _idaapi.PPC_miso
PPC_mdoio = _idaapi.PPC_mdoio
PPC_mdoom = _idaapi.PPC_mdoom
PPC_last = _idaapi.PPC_last
NEC850_NULL = _idaapi.NEC850_NULL
NEC850_BREAKPOINT = _idaapi.NEC850_BREAKPOINT
NEC850_XORI = _idaapi.NEC850_XORI
NEC850_XOR = _idaapi.NEC850_XOR
NEC850_TST1 = _idaapi.NEC850_TST1
NEC850_TST = _idaapi.NEC850_TST
NEC850_TRAP = _idaapi.NEC850_TRAP
NEC850_SUBR = _idaapi.NEC850_SUBR
NEC850_SUB = _idaapi.NEC850_SUB
NEC850_STSR = _idaapi.NEC850_STSR
NEC850_ST_B = _idaapi.NEC850_ST_B
NEC850_ST_H = _idaapi.NEC850_ST_H
NEC850_ST_W = _idaapi.NEC850_ST_W
NEC850_SST_B = _idaapi.NEC850_SST_B
NEC850_SST_H = _idaapi.NEC850_SST_H
NEC850_SST_W = _idaapi.NEC850_SST_W
NEC850_SLD_B = _idaapi.NEC850_SLD_B
NEC850_SLD_H = _idaapi.NEC850_SLD_H
NEC850_SLD_W = _idaapi.NEC850_SLD_W
NEC850_SHR = _idaapi.NEC850_SHR
NEC850_SHL = _idaapi.NEC850_SHL
NEC850_SET1 = _idaapi.NEC850_SET1
NEC850_SETFV = _idaapi.NEC850_SETFV
NEC850_SETFL = _idaapi.NEC850_SETFL
NEC850_SETFZ = _idaapi.NEC850_SETFZ
NEC850_SETFNH = _idaapi.NEC850_SETFNH
NEC850_SETFN = _idaapi.NEC850_SETFN
NEC850_SETFT = _idaapi.NEC850_SETFT
NEC850_SETFLT = _idaapi.NEC850_SETFLT
NEC850_SETFLE = _idaapi.NEC850_SETFLE
NEC850_SETFNV = _idaapi.NEC850_SETFNV
NEC850_SETFNC = _idaapi.NEC850_SETFNC
NEC850_SETFNZ = _idaapi.NEC850_SETFNZ
NEC850_SETFH = _idaapi.NEC850_SETFH
NEC850_SETFP = _idaapi.NEC850_SETFP
NEC850_SETFSA = _idaapi.NEC850_SETFSA
NEC850_SETFGE = _idaapi.NEC850_SETFGE
NEC850_SETFGT = _idaapi.NEC850_SETFGT
NEC850_SATSUBR = _idaapi.NEC850_SATSUBR
NEC850_SATSUBI = _idaapi.NEC850_SATSUBI
NEC850_SATSUB = _idaapi.NEC850_SATSUB
NEC850_SATADD = _idaapi.NEC850_SATADD
NEC850_SAR = _idaapi.NEC850_SAR
NEC850_RETI = _idaapi.NEC850_RETI
NEC850_ORI = _idaapi.NEC850_ORI
NEC850_OR = _idaapi.NEC850_OR
NEC850_NOT1 = _idaapi.NEC850_NOT1
NEC850_NOT = _idaapi.NEC850_NOT
NEC850_NOP = _idaapi.NEC850_NOP
NEC850_MULHI = _idaapi.NEC850_MULHI
NEC850_MULH = _idaapi.NEC850_MULH
NEC850_MOVHI = _idaapi.NEC850_MOVHI
NEC850_MOVEA = _idaapi.NEC850_MOVEA
NEC850_MOV = _idaapi.NEC850_MOV
NEC850_LDSR = _idaapi.NEC850_LDSR
NEC850_LD_B = _idaapi.NEC850_LD_B
NEC850_LD_H = _idaapi.NEC850_LD_H
NEC850_LD_W = _idaapi.NEC850_LD_W
NEC850_JR = _idaapi.NEC850_JR
NEC850_JMP = _idaapi.NEC850_JMP
NEC850_JARL = _idaapi.NEC850_JARL
NEC850_HALT = _idaapi.NEC850_HALT
NEC850_EI = _idaapi.NEC850_EI
NEC850_DIVH = _idaapi.NEC850_DIVH
NEC850_DI = _idaapi.NEC850_DI
NEC850_CMP = _idaapi.NEC850_CMP
NEC850_CLR1 = _idaapi.NEC850_CLR1
NEC850_BV = _idaapi.NEC850_BV
NEC850_BL = _idaapi.NEC850_BL
NEC850_BZ = _idaapi.NEC850_BZ
NEC850_BNH = _idaapi.NEC850_BNH
NEC850_BN = _idaapi.NEC850_BN
NEC850_BR = _idaapi.NEC850_BR
NEC850_BLT = _idaapi.NEC850_BLT
NEC850_BLE = _idaapi.NEC850_BLE
NEC850_BNV = _idaapi.NEC850_BNV
NEC850_BNC = _idaapi.NEC850_BNC
NEC850_BNZ = _idaapi.NEC850_BNZ
NEC850_BH = _idaapi.NEC850_BH
NEC850_BP = _idaapi.NEC850_BP
NEC850_BSA = _idaapi.NEC850_BSA
NEC850_BGE = _idaapi.NEC850_BGE
NEC850_BGT = _idaapi.NEC850_BGT
NEC850_ANDI = _idaapi.NEC850_ANDI
NEC850_AND = _idaapi.NEC850_AND
NEC850_ADDI = _idaapi.NEC850_ADDI
NEC850_ADD = _idaapi.NEC850_ADD
NEC850_SWITCH = _idaapi.NEC850_SWITCH
NEC850_ZXB = _idaapi.NEC850_ZXB
NEC850_SXB = _idaapi.NEC850_SXB
NEC850_ZXH = _idaapi.NEC850_ZXH
NEC850_SXH = _idaapi.NEC850_SXH
NEC850_DISPOSE_r0 = _idaapi.NEC850_DISPOSE_r0
NEC850_DISPOSE_r = _idaapi.NEC850_DISPOSE_r
NEC850_CALLT = _idaapi.NEC850_CALLT
NEC850_DBTRAP = _idaapi.NEC850_DBTRAP
NEC850_DBRET = _idaapi.NEC850_DBRET
NEC850_CTRET = _idaapi.NEC850_CTRET
NEC850_SASFV = _idaapi.NEC850_SASFV
NEC850_SASFL = _idaapi.NEC850_SASFL
NEC850_SASFZ = _idaapi.NEC850_SASFZ
NEC850_SASFNH = _idaapi.NEC850_SASFNH
NEC850_SASFN = _idaapi.NEC850_SASFN
NEC850_SASFT = _idaapi.NEC850_SASFT
NEC850_SASFLT = _idaapi.NEC850_SASFLT
NEC850_SASFLE = _idaapi.NEC850_SASFLE
NEC850_SASFNV = _idaapi.NEC850_SASFNV
NEC850_SASFNC = _idaapi.NEC850_SASFNC
NEC850_SASFNZ = _idaapi.NEC850_SASFNZ
NEC850_SASFH = _idaapi.NEC850_SASFH
NEC850_SASFP = _idaapi.NEC850_SASFP
NEC850_SASFSA = _idaapi.NEC850_SASFSA
NEC850_SASFGE = _idaapi.NEC850_SASFGE
NEC850_SASFGT = _idaapi.NEC850_SASFGT
NEC850_PREPARE_sp = _idaapi.NEC850_PREPARE_sp
NEC850_PREPARE_i = _idaapi.NEC850_PREPARE_i
NEC850_MUL = _idaapi.NEC850_MUL
NEC850_MULU = _idaapi.NEC850_MULU
NEC850_DIVH_r3 = _idaapi.NEC850_DIVH_r3
NEC850_DIVHU = _idaapi.NEC850_DIVHU
NEC850_DIV = _idaapi.NEC850_DIV
NEC850_DIVU = _idaapi.NEC850_DIVU
NEC850_BSW = _idaapi.NEC850_BSW
NEC850_BSH = _idaapi.NEC850_BSH
NEC850_HSW = _idaapi.NEC850_HSW
NEC850_CMOVV = _idaapi.NEC850_CMOVV
NEC850_CMOVL = _idaapi.NEC850_CMOVL
NEC850_CMOVZ = _idaapi.NEC850_CMOVZ
NEC850_CMOVNH = _idaapi.NEC850_CMOVNH
NEC850_CMOVN = _idaapi.NEC850_CMOVN
NEC850_CMOV = _idaapi.NEC850_CMOV
NEC850_CMOVLT = _idaapi.NEC850_CMOVLT
NEC850_CMOVLE = _idaapi.NEC850_CMOVLE
NEC850_CMOVNV = _idaapi.NEC850_CMOVNV
NEC850_CMOVNC = _idaapi.NEC850_CMOVNC
NEC850_CMOVNZ = _idaapi.NEC850_CMOVNZ
NEC850_CMOVH = _idaapi.NEC850_CMOVH
NEC850_CMOVP = _idaapi.NEC850_CMOVP
NEC850_CMOVSA = _idaapi.NEC850_CMOVSA
NEC850_CMOVGE = _idaapi.NEC850_CMOVGE
NEC850_CMOVGT = _idaapi.NEC850_CMOVGT
NEC850_SLD_BU = _idaapi.NEC850_SLD_BU
NEC850_SLD_HU = _idaapi.NEC850_SLD_HU
NEC850_LD_BU = _idaapi.NEC850_LD_BU
NEC850_LD_HU = _idaapi.NEC850_LD_HU
NEC850_LAST_INSTRUCTION = _idaapi.NEC850_LAST_INSTRUCTION
TRICORE_null = _idaapi.TRICORE_null
TRICORE_abs = _idaapi.TRICORE_abs
TRICORE_abs_b = _idaapi.TRICORE_abs_b
TRICORE_abs_h = _idaapi.TRICORE_abs_h
TRICORE_absdif = _idaapi.TRICORE_absdif
TRICORE_absdif_b = _idaapi.TRICORE_absdif_b
TRICORE_absdif_h = _idaapi.TRICORE_absdif_h
TRICORE_absdifs = _idaapi.TRICORE_absdifs
TRICORE_absdifs_h = _idaapi.TRICORE_absdifs_h
TRICORE_abss = _idaapi.TRICORE_abss
TRICORE_abss_h = _idaapi.TRICORE_abss_h
TRICORE_add_b = _idaapi.TRICORE_add_b
TRICORE_add_f = _idaapi.TRICORE_add_f
TRICORE_add_h = _idaapi.TRICORE_add_h
TRICORE_add16 = _idaapi.TRICORE_add16
TRICORE_add16_a = _idaapi.TRICORE_add16_a
TRICORE_add32 = _idaapi.TRICORE_add32
TRICORE_add32_a = _idaapi.TRICORE_add32_a
TRICORE_addc = _idaapi.TRICORE_addc
TRICORE_addi = _idaapi.TRICORE_addi
TRICORE_addih = _idaapi.TRICORE_addih
TRICORE_addih_a = _idaapi.TRICORE_addih_a
TRICORE_adds = _idaapi.TRICORE_adds
TRICORE_adds_h = _idaapi.TRICORE_adds_h
TRICORE_adds_hu = _idaapi.TRICORE_adds_hu
TRICORE_adds_u = _idaapi.TRICORE_adds_u
TRICORE_adds16 = _idaapi.TRICORE_adds16
TRICORE_addsc_at = _idaapi.TRICORE_addsc_at
TRICORE_addsc16_a = _idaapi.TRICORE_addsc16_a
TRICORE_addsc32_a = _idaapi.TRICORE_addsc32_a
TRICORE_addx = _idaapi.TRICORE_addx
TRICORE_and_and_t = _idaapi.TRICORE_and_and_t
TRICORE_and_andn_t = _idaapi.TRICORE_and_andn_t
TRICORE_and_eq = _idaapi.TRICORE_and_eq
TRICORE_and_ge = _idaapi.TRICORE_and_ge
TRICORE_and_ge_u = _idaapi.TRICORE_and_ge_u
TRICORE_and_lt = _idaapi.TRICORE_and_lt
TRICORE_and_lt_u = _idaapi.TRICORE_and_lt_u
TRICORE_and_ne = _idaapi.TRICORE_and_ne
TRICORE_and_nor_t = _idaapi.TRICORE_and_nor_t
TRICORE_and_or_t = _idaapi.TRICORE_and_or_t
TRICORE_and_t = _idaapi.TRICORE_and_t
TRICORE_and16 = _idaapi.TRICORE_and16
TRICORE_and32 = _idaapi.TRICORE_and32
TRICORE_andn = _idaapi.TRICORE_andn
TRICORE_andn_t = _idaapi.TRICORE_andn_t
TRICORE_bisr16 = _idaapi.TRICORE_bisr16
TRICORE_bisr32 = _idaapi.TRICORE_bisr32
TRICORE_bmerge = _idaapi.TRICORE_bmerge
TRICORE_bsplit = _idaapi.TRICORE_bsplit
TRICORE_cachea_i = _idaapi.TRICORE_cachea_i
TRICORE_cachea_w = _idaapi.TRICORE_cachea_w
TRICORE_cachea_wi = _idaapi.TRICORE_cachea_wi
TRICORE_cadd16 = _idaapi.TRICORE_cadd16
TRICORE_cadd32 = _idaapi.TRICORE_cadd32
TRICORE_caddn16 = _idaapi.TRICORE_caddn16
TRICORE_caddn32 = _idaapi.TRICORE_caddn32
TRICORE_call16 = _idaapi.TRICORE_call16
TRICORE_call32 = _idaapi.TRICORE_call32
TRICORE_calla = _idaapi.TRICORE_calla
TRICORE_calli = _idaapi.TRICORE_calli
TRICORE_clo = _idaapi.TRICORE_clo
TRICORE_clo_h = _idaapi.TRICORE_clo_h
TRICORE_cls = _idaapi.TRICORE_cls
TRICORE_cls_h = _idaapi.TRICORE_cls_h
TRICORE_clz = _idaapi.TRICORE_clz
TRICORE_clz_h = _idaapi.TRICORE_clz_h
TRICORE_cmov16 = _idaapi.TRICORE_cmov16
TRICORE_cmovn16 = _idaapi.TRICORE_cmovn16
TRICORE_cmp_f = _idaapi.TRICORE_cmp_f
TRICORE_csub = _idaapi.TRICORE_csub
TRICORE_csubn = _idaapi.TRICORE_csubn
TRICORE_debug16 = _idaapi.TRICORE_debug16
TRICORE_debug32 = _idaapi.TRICORE_debug32
TRICORE_dextr = _idaapi.TRICORE_dextr
TRICORE_disable = _idaapi.TRICORE_disable
TRICORE_div_f = _idaapi.TRICORE_div_f
TRICORE_dsync = _idaapi.TRICORE_dsync
TRICORE_dvadj = _idaapi.TRICORE_dvadj
TRICORE_dvinit = _idaapi.TRICORE_dvinit
TRICORE_dvinit_b = _idaapi.TRICORE_dvinit_b
TRICORE_dvinit_bu = _idaapi.TRICORE_dvinit_bu
TRICORE_dvinit_h = _idaapi.TRICORE_dvinit_h
TRICORE_dvinit_hu = _idaapi.TRICORE_dvinit_hu
TRICORE_dvinit_u = _idaapi.TRICORE_dvinit_u
TRICORE_dvstep = _idaapi.TRICORE_dvstep
TRICORE_dvstep_u = _idaapi.TRICORE_dvstep_u
TRICORE_enable = _idaapi.TRICORE_enable
TRICORE_eq_a = _idaapi.TRICORE_eq_a
TRICORE_eq_b = _idaapi.TRICORE_eq_b
TRICORE_eq_h = _idaapi.TRICORE_eq_h
TRICORE_eq_w = _idaapi.TRICORE_eq_w
TRICORE_eq16 = _idaapi.TRICORE_eq16
TRICORE_eq32 = _idaapi.TRICORE_eq32
TRICORE_eqany_b = _idaapi.TRICORE_eqany_b
TRICORE_eqany_h = _idaapi.TRICORE_eqany_h
TRICORE_eqz_a = _idaapi.TRICORE_eqz_a
TRICORE_extr = _idaapi.TRICORE_extr
TRICORE_extr_u = _idaapi.TRICORE_extr_u
TRICORE_ftoi = _idaapi.TRICORE_ftoi
TRICORE_ftoq31 = _idaapi.TRICORE_ftoq31
TRICORE_ftou = _idaapi.TRICORE_ftou
TRICORE_ge = _idaapi.TRICORE_ge
TRICORE_ge_a = _idaapi.TRICORE_ge_a
TRICORE_ge_u = _idaapi.TRICORE_ge_u
TRICORE_imask = _idaapi.TRICORE_imask
TRICORE_ins_t = _idaapi.TRICORE_ins_t
TRICORE_insert = _idaapi.TRICORE_insert
TRICORE_insn_t = _idaapi.TRICORE_insn_t
TRICORE_isync = _idaapi.TRICORE_isync
TRICORE_itof = _idaapi.TRICORE_itof
TRICORE_ixmax = _idaapi.TRICORE_ixmax
TRICORE_ixmax_u = _idaapi.TRICORE_ixmax_u
TRICORE_ixmin = _idaapi.TRICORE_ixmin
TRICORE_ixmin_u = _idaapi.TRICORE_ixmin_u
TRICORE_j16 = _idaapi.TRICORE_j16
TRICORE_j32 = _idaapi.TRICORE_j32
TRICORE_ja = _idaapi.TRICORE_ja
TRICORE_jeq_a = _idaapi.TRICORE_jeq_a
TRICORE_jeq16 = _idaapi.TRICORE_jeq16
TRICORE_jeq32 = _idaapi.TRICORE_jeq32
TRICORE_jge = _idaapi.TRICORE_jge
TRICORE_jge_u = _idaapi.TRICORE_jge_u
TRICORE_jgez16 = _idaapi.TRICORE_jgez16
TRICORE_jgtz16 = _idaapi.TRICORE_jgtz16
TRICORE_ji16 = _idaapi.TRICORE_ji16
TRICORE_ji32 = _idaapi.TRICORE_ji32
TRICORE_jl = _idaapi.TRICORE_jl
TRICORE_jla = _idaapi.TRICORE_jla
TRICORE_jlez16 = _idaapi.TRICORE_jlez16
TRICORE_jli = _idaapi.TRICORE_jli
TRICORE_jlt = _idaapi.TRICORE_jlt
TRICORE_jlt_u = _idaapi.TRICORE_jlt_u
TRICORE_jltz16 = _idaapi.TRICORE_jltz16
TRICORE_jne_a = _idaapi.TRICORE_jne_a
TRICORE_jne16 = _idaapi.TRICORE_jne16
TRICORE_jne32 = _idaapi.TRICORE_jne32
TRICORE_jned = _idaapi.TRICORE_jned
TRICORE_jnei = _idaapi.TRICORE_jnei
TRICORE_jnz16 = _idaapi.TRICORE_jnz16
TRICORE_jnz16_a = _idaapi.TRICORE_jnz16_a
TRICORE_jnz16_t = _idaapi.TRICORE_jnz16_t
TRICORE_jnz32_a = _idaapi.TRICORE_jnz32_a
TRICORE_jnz32_t = _idaapi.TRICORE_jnz32_t
TRICORE_jz16 = _idaapi.TRICORE_jz16
TRICORE_jz16_a = _idaapi.TRICORE_jz16_a
TRICORE_jz16_t = _idaapi.TRICORE_jz16_t
TRICORE_jz32_a = _idaapi.TRICORE_jz32_a
TRICORE_jz32_t = _idaapi.TRICORE_jz32_t
TRICORE_ld_b = _idaapi.TRICORE_ld_b
TRICORE_ld_d = _idaapi.TRICORE_ld_d
TRICORE_ld_da = _idaapi.TRICORE_ld_da
TRICORE_ld_hu = _idaapi.TRICORE_ld_hu
TRICORE_ld_q = _idaapi.TRICORE_ld_q
TRICORE_ld16_a = _idaapi.TRICORE_ld16_a
TRICORE_ld16_bu = _idaapi.TRICORE_ld16_bu
TRICORE_ld16_h = _idaapi.TRICORE_ld16_h
TRICORE_ld16_w = _idaapi.TRICORE_ld16_w
TRICORE_ld32_a = _idaapi.TRICORE_ld32_a
TRICORE_ld32_bu = _idaapi.TRICORE_ld32_bu
TRICORE_ld32_h = _idaapi.TRICORE_ld32_h
TRICORE_ld32_w = _idaapi.TRICORE_ld32_w
TRICORE_ldlcx = _idaapi.TRICORE_ldlcx
TRICORE_ldmst = _idaapi.TRICORE_ldmst
TRICORE_lducx = _idaapi.TRICORE_lducx
TRICORE_lea = _idaapi.TRICORE_lea
TRICORE_loop16 = _idaapi.TRICORE_loop16
TRICORE_loop32 = _idaapi.TRICORE_loop32
TRICORE_loopu = _idaapi.TRICORE_loopu
TRICORE_lt_a = _idaapi.TRICORE_lt_a
TRICORE_lt_b = _idaapi.TRICORE_lt_b
TRICORE_lt_bu = _idaapi.TRICORE_lt_bu
TRICORE_lt_h = _idaapi.TRICORE_lt_h
TRICORE_lt_hu = _idaapi.TRICORE_lt_hu
TRICORE_lt_u = _idaapi.TRICORE_lt_u
TRICORE_lt_w = _idaapi.TRICORE_lt_w
TRICORE_lt_wu = _idaapi.TRICORE_lt_wu
TRICORE_lt16 = _idaapi.TRICORE_lt16
TRICORE_lt32 = _idaapi.TRICORE_lt32
TRICORE_madd = _idaapi.TRICORE_madd
TRICORE_madd_f = _idaapi.TRICORE_madd_f
TRICORE_madd_h = _idaapi.TRICORE_madd_h
TRICORE_madd_q = _idaapi.TRICORE_madd_q
TRICORE_madd_u = _idaapi.TRICORE_madd_u
TRICORE_maddm_h = _idaapi.TRICORE_maddm_h
TRICORE_maddms_h = _idaapi.TRICORE_maddms_h
TRICORE_maddr_h = _idaapi.TRICORE_maddr_h
TRICORE_maddr_q = _idaapi.TRICORE_maddr_q
TRICORE_maddrs_h = _idaapi.TRICORE_maddrs_h
TRICORE_maddrs_q = _idaapi.TRICORE_maddrs_q
TRICORE_madds = _idaapi.TRICORE_madds
TRICORE_madds_h = _idaapi.TRICORE_madds_h
TRICORE_madds_q = _idaapi.TRICORE_madds_q
TRICORE_madds_u = _idaapi.TRICORE_madds_u
TRICORE_maddsu_h = _idaapi.TRICORE_maddsu_h
TRICORE_maddsum_h = _idaapi.TRICORE_maddsum_h
TRICORE_maddsums_h = _idaapi.TRICORE_maddsums_h
TRICORE_maddsur_h = _idaapi.TRICORE_maddsur_h
TRICORE_maddsurs_h = _idaapi.TRICORE_maddsurs_h
TRICORE_maddsus_h = _idaapi.TRICORE_maddsus_h
TRICORE_max = _idaapi.TRICORE_max
TRICORE_max_b = _idaapi.TRICORE_max_b
TRICORE_max_bu = _idaapi.TRICORE_max_bu
TRICORE_max_h = _idaapi.TRICORE_max_h
TRICORE_max_hu = _idaapi.TRICORE_max_hu
TRICORE_max_u = _idaapi.TRICORE_max_u
TRICORE_mfcr = _idaapi.TRICORE_mfcr
TRICORE_min = _idaapi.TRICORE_min
TRICORE_min_b = _idaapi.TRICORE_min_b
TRICORE_min_bu = _idaapi.TRICORE_min_bu
TRICORE_min_h = _idaapi.TRICORE_min_h
TRICORE_min_hu = _idaapi.TRICORE_min_hu
TRICORE_min_u = _idaapi.TRICORE_min_u
TRICORE_mov_u = _idaapi.TRICORE_mov_u
TRICORE_mov16 = _idaapi.TRICORE_mov16
TRICORE_mov16_a = _idaapi.TRICORE_mov16_a
TRICORE_mov16_aa = _idaapi.TRICORE_mov16_aa
TRICORE_mov16_d = _idaapi.TRICORE_mov16_d
TRICORE_mov32 = _idaapi.TRICORE_mov32
TRICORE_mov32_a = _idaapi.TRICORE_mov32_a
TRICORE_mov32_aa = _idaapi.TRICORE_mov32_aa
TRICORE_mov32_d = _idaapi.TRICORE_mov32_d
TRICORE_movh = _idaapi.TRICORE_movh
TRICORE_movh_a = _idaapi.TRICORE_movh_a
TRICORE_msub = _idaapi.TRICORE_msub
TRICORE_msub_f = _idaapi.TRICORE_msub_f
TRICORE_msub_h = _idaapi.TRICORE_msub_h
TRICORE_msub_q = _idaapi.TRICORE_msub_q
TRICORE_msub_u = _idaapi.TRICORE_msub_u
TRICORE_msubad_h = _idaapi.TRICORE_msubad_h
TRICORE_msubadm_h = _idaapi.TRICORE_msubadm_h
TRICORE_msubadms_h = _idaapi.TRICORE_msubadms_h
TRICORE_msubadr_h = _idaapi.TRICORE_msubadr_h
TRICORE_msubadrs_h = _idaapi.TRICORE_msubadrs_h
TRICORE_msubads_h = _idaapi.TRICORE_msubads_h
TRICORE_msubm_h = _idaapi.TRICORE_msubm_h
TRICORE_msubms_h = _idaapi.TRICORE_msubms_h
TRICORE_msubr_h = _idaapi.TRICORE_msubr_h
TRICORE_msubr_q = _idaapi.TRICORE_msubr_q
TRICORE_msubrs_h = _idaapi.TRICORE_msubrs_h
TRICORE_msubrs_q = _idaapi.TRICORE_msubrs_q
TRICORE_msubs = _idaapi.TRICORE_msubs
TRICORE_msubs_h = _idaapi.TRICORE_msubs_h
TRICORE_msubs_q = _idaapi.TRICORE_msubs_q
TRICORE_msubs_u = _idaapi.TRICORE_msubs_u
TRICORE_mtcr = _idaapi.TRICORE_mtcr
TRICORE_mul_f = _idaapi.TRICORE_mul_f
TRICORE_mul_h = _idaapi.TRICORE_mul_h
TRICORE_mul_q = _idaapi.TRICORE_mul_q
TRICORE_mul_u = _idaapi.TRICORE_mul_u
TRICORE_mul16 = _idaapi.TRICORE_mul16
TRICORE_mul32 = _idaapi.TRICORE_mul32
TRICORE_mulm_h = _idaapi.TRICORE_mulm_h
TRICORE_mulms_h = _idaapi.TRICORE_mulms_h
TRICORE_mulr_h = _idaapi.TRICORE_mulr_h
TRICORE_mulr_q = _idaapi.TRICORE_mulr_q
TRICORE_muls = _idaapi.TRICORE_muls
TRICORE_muls_u = _idaapi.TRICORE_muls_u
TRICORE_nand = _idaapi.TRICORE_nand
TRICORE_nand_t = _idaapi.TRICORE_nand_t
TRICORE_ne = _idaapi.TRICORE_ne
TRICORE_ne_a = _idaapi.TRICORE_ne_a
TRICORE_nez_a = _idaapi.TRICORE_nez_a
TRICORE_nop16 = _idaapi.TRICORE_nop16
TRICORE_nop32 = _idaapi.TRICORE_nop32
TRICORE_nor_t = _idaapi.TRICORE_nor_t
TRICORE_nor16 = _idaapi.TRICORE_nor16
TRICORE_nor32 = _idaapi.TRICORE_nor32
TRICORE_or_and_t = _idaapi.TRICORE_or_and_t
TRICORE_or_andn_t = _idaapi.TRICORE_or_andn_t
TRICORE_or_eq = _idaapi.TRICORE_or_eq
TRICORE_or_ge = _idaapi.TRICORE_or_ge
TRICORE_or_ge_u = _idaapi.TRICORE_or_ge_u
TRICORE_or_lt = _idaapi.TRICORE_or_lt
TRICORE_or_lt_u = _idaapi.TRICORE_or_lt_u
TRICORE_or_ne = _idaapi.TRICORE_or_ne
TRICORE_or_nor_t = _idaapi.TRICORE_or_nor_t
TRICORE_or_or_t = _idaapi.TRICORE_or_or_t
TRICORE_or_t = _idaapi.TRICORE_or_t
TRICORE_or16 = _idaapi.TRICORE_or16
TRICORE_or32 = _idaapi.TRICORE_or32
TRICORE_orn = _idaapi.TRICORE_orn
TRICORE_orn_t = _idaapi.TRICORE_orn_t
TRICORE_pack = _idaapi.TRICORE_pack
TRICORE_parity = _idaapi.TRICORE_parity
TRICORE_q31tof = _idaapi.TRICORE_q31tof
TRICORE_qseed_f = _idaapi.TRICORE_qseed_f
TRICORE_ret16 = _idaapi.TRICORE_ret16
TRICORE_ret32 = _idaapi.TRICORE_ret32
TRICORE_rfe16 = _idaapi.TRICORE_rfe16
TRICORE_rfe32 = _idaapi.TRICORE_rfe32
TRICORE_rfm = _idaapi.TRICORE_rfm
TRICORE_rslcx = _idaapi.TRICORE_rslcx
TRICORE_rstv = _idaapi.TRICORE_rstv
TRICORE_rsub16 = _idaapi.TRICORE_rsub16
TRICORE_rsub32 = _idaapi.TRICORE_rsub32
TRICORE_rsubs = _idaapi.TRICORE_rsubs
TRICORE_rsubs_u = _idaapi.TRICORE_rsubs_u
TRICORE_sat16_b = _idaapi.TRICORE_sat16_b
TRICORE_sat16_bu = _idaapi.TRICORE_sat16_bu
TRICORE_sat16_h = _idaapi.TRICORE_sat16_h
TRICORE_sat16_hu = _idaapi.TRICORE_sat16_hu
TRICORE_sat32_b = _idaapi.TRICORE_sat32_b
TRICORE_sat32_bu = _idaapi.TRICORE_sat32_bu
TRICORE_sat32_h = _idaapi.TRICORE_sat32_h
TRICORE_sat32_hu = _idaapi.TRICORE_sat32_hu
TRICORE_sel = _idaapi.TRICORE_sel
TRICORE_seln = _idaapi.TRICORE_seln
TRICORE_sh_and_t = _idaapi.TRICORE_sh_and_t
TRICORE_sh_andn_t = _idaapi.TRICORE_sh_andn_t
TRICORE_sh_eq = _idaapi.TRICORE_sh_eq
TRICORE_sh_ge = _idaapi.TRICORE_sh_ge
TRICORE_sh_ge_u = _idaapi.TRICORE_sh_ge_u
TRICORE_sh_h = _idaapi.TRICORE_sh_h
TRICORE_sh_lt = _idaapi.TRICORE_sh_lt
TRICORE_sh_lt_u = _idaapi.TRICORE_sh_lt_u
TRICORE_sh_nand_t = _idaapi.TRICORE_sh_nand_t
TRICORE_sh_ne = _idaapi.TRICORE_sh_ne
TRICORE_sh_nor_t = _idaapi.TRICORE_sh_nor_t
TRICORE_sh_or_t = _idaapi.TRICORE_sh_or_t
TRICORE_sh_orn_t = _idaapi.TRICORE_sh_orn_t
TRICORE_sh_xnor_t = _idaapi.TRICORE_sh_xnor_t
TRICORE_sh_xor_t = _idaapi.TRICORE_sh_xor_t
TRICORE_sh16 = _idaapi.TRICORE_sh16
TRICORE_sh32 = _idaapi.TRICORE_sh32
TRICORE_sha_h = _idaapi.TRICORE_sha_h
TRICORE_sha16 = _idaapi.TRICORE_sha16
TRICORE_sha32 = _idaapi.TRICORE_sha32
TRICORE_shas = _idaapi.TRICORE_shas
TRICORE_st_d = _idaapi.TRICORE_st_d
TRICORE_st_da = _idaapi.TRICORE_st_da
TRICORE_st_q = _idaapi.TRICORE_st_q
TRICORE_st_t = _idaapi.TRICORE_st_t
TRICORE_st16_a = _idaapi.TRICORE_st16_a
TRICORE_st16_b = _idaapi.TRICORE_st16_b
TRICORE_st16_h = _idaapi.TRICORE_st16_h
TRICORE_st16_w = _idaapi.TRICORE_st16_w
TRICORE_st32_a = _idaapi.TRICORE_st32_a
TRICORE_st32_b = _idaapi.TRICORE_st32_b
TRICORE_st32_h = _idaapi.TRICORE_st32_h
TRICORE_st32_w = _idaapi.TRICORE_st32_w
TRICORE_stlcx = _idaapi.TRICORE_stlcx
TRICORE_stucx = _idaapi.TRICORE_stucx
TRICORE_sub_b = _idaapi.TRICORE_sub_b
TRICORE_sub_f = _idaapi.TRICORE_sub_f
TRICORE_sub_h = _idaapi.TRICORE_sub_h
TRICORE_sub16 = _idaapi.TRICORE_sub16
TRICORE_sub16_a = _idaapi.TRICORE_sub16_a
TRICORE_sub32 = _idaapi.TRICORE_sub32
TRICORE_sub32_a = _idaapi.TRICORE_sub32_a
TRICORE_subc = _idaapi.TRICORE_subc
TRICORE_subs_h = _idaapi.TRICORE_subs_h
TRICORE_subs_hu = _idaapi.TRICORE_subs_hu
TRICORE_subs_u = _idaapi.TRICORE_subs_u
TRICORE_subs16 = _idaapi.TRICORE_subs16
TRICORE_subs32 = _idaapi.TRICORE_subs32
TRICORE_subx = _idaapi.TRICORE_subx
TRICORE_svlcx = _idaapi.TRICORE_svlcx
TRICORE_swap_w = _idaapi.TRICORE_swap_w
TRICORE_syscall = _idaapi.TRICORE_syscall
TRICORE_tlbdemap = _idaapi.TRICORE_tlbdemap
TRICORE_tlbflush_a = _idaapi.TRICORE_tlbflush_a
TRICORE_tlbflush_b = _idaapi.TRICORE_tlbflush_b
TRICORE_tlbmap = _idaapi.TRICORE_tlbmap
TRICORE_tlbprobe_a = _idaapi.TRICORE_tlbprobe_a
TRICORE_tlbprobe_i = _idaapi.TRICORE_tlbprobe_i
TRICORE_trapsv = _idaapi.TRICORE_trapsv
TRICORE_trapv = _idaapi.TRICORE_trapv
TRICORE_unpack = _idaapi.TRICORE_unpack
TRICORE_updfl = _idaapi.TRICORE_updfl
TRICORE_utof = _idaapi.TRICORE_utof
TRICORE_xnor = _idaapi.TRICORE_xnor
TRICORE_xnor_t = _idaapi.TRICORE_xnor_t
TRICORE_xor_eq = _idaapi.TRICORE_xor_eq
TRICORE_xor_ge = _idaapi.TRICORE_xor_ge
TRICORE_xor_ge_u = _idaapi.TRICORE_xor_ge_u
TRICORE_xor_lt = _idaapi.TRICORE_xor_lt
TRICORE_xor_lt_u = _idaapi.TRICORE_xor_lt_u
TRICORE_xor_ne = _idaapi.TRICORE_xor_ne
TRICORE_xor_t = _idaapi.TRICORE_xor_t
TRICORE_xor16 = _idaapi.TRICORE_xor16
TRICORE_xor32 = _idaapi.TRICORE_xor32
TRICORE_cachei_i = _idaapi.TRICORE_cachei_i
TRICORE_cachei_w = _idaapi.TRICORE_cachei_w
TRICORE_cachei_wi = _idaapi.TRICORE_cachei_wi
TRICORE_div = _idaapi.TRICORE_div
TRICORE_div_u = _idaapi.TRICORE_div_u
TRICORE_fcall = _idaapi.TRICORE_fcall
TRICORE_fcalla = _idaapi.TRICORE_fcalla
TRICORE_fcalli = _idaapi.TRICORE_fcalli
TRICORE_fret16 = _idaapi.TRICORE_fret16
TRICORE_fret32 = _idaapi.TRICORE_fret32
TRICORE_ftoiz = _idaapi.TRICORE_ftoiz
TRICORE_ftoq31z = _idaapi.TRICORE_ftoq31z
TRICORE_ftouz = _idaapi.TRICORE_ftouz
TRICORE_restore = _idaapi.TRICORE_restore
TRICORE_last = _idaapi.TRICORE_last
ARC_null = _idaapi.ARC_null
ARC_ld = _idaapi.ARC_ld
ARC_lr = _idaapi.ARC_lr
ARC_st = _idaapi.ARC_st
ARC_sr = _idaapi.ARC_sr
ARC_store_instructions = _idaapi.ARC_store_instructions
ARC_flag = _idaapi.ARC_flag
ARC_asr = _idaapi.ARC_asr
ARC_lsr = _idaapi.ARC_lsr
ARC_sexb = _idaapi.ARC_sexb
ARC_sexw = _idaapi.ARC_sexw
ARC_extb = _idaapi.ARC_extb
ARC_extw = _idaapi.ARC_extw
ARC_ror = _idaapi.ARC_ror
ARC_rrc = _idaapi.ARC_rrc
ARC_b = _idaapi.ARC_b
ARC_bl = _idaapi.ARC_bl
ARC_lp = _idaapi.ARC_lp
ARC_j = _idaapi.ARC_j
ARC_jl = _idaapi.ARC_jl
ARC_add = _idaapi.ARC_add
ARC_adc = _idaapi.ARC_adc
ARC_sub = _idaapi.ARC_sub
ARC_sbc = _idaapi.ARC_sbc
ARC_and = _idaapi.ARC_and
ARC_or = _idaapi.ARC_or
ARC_bic = _idaapi.ARC_bic
ARC_xor = _idaapi.ARC_xor
ARC_mov = _idaapi.ARC_mov
ARC_nop = _idaapi.ARC_nop
ARC_lsl = _idaapi.ARC_lsl
ARC_rlc = _idaapi.ARC_rlc
ARC_brk = _idaapi.ARC_brk
ARC_sleep = _idaapi.ARC_sleep
ARC_swi = _idaapi.ARC_swi
ARC_asl = _idaapi.ARC_asl
ARC_mul64 = _idaapi.ARC_mul64
ARC_mulu64 = _idaapi.ARC_mulu64
ARC_max = _idaapi.ARC_max
ARC_min = _idaapi.ARC_min
ARC_swap = _idaapi.ARC_swap
ARC_norm = _idaapi.ARC_norm
ARC_bbit0 = _idaapi.ARC_bbit0
ARC_bbit1 = _idaapi.ARC_bbit1
ARC_br = _idaapi.ARC_br
ARC_pop = _idaapi.ARC_pop
ARC_push = _idaapi.ARC_push
ARC_abs = _idaapi.ARC_abs
ARC_add1 = _idaapi.ARC_add1
ARC_add2 = _idaapi.ARC_add2
ARC_add3 = _idaapi.ARC_add3
ARC_bclr = _idaapi.ARC_bclr
ARC_bmsk = _idaapi.ARC_bmsk
ARC_bset = _idaapi.ARC_bset
ARC_btst = _idaapi.ARC_btst
ARC_bxor = _idaapi.ARC_bxor
ARC_cmp = _idaapi.ARC_cmp
ARC_ex = _idaapi.ARC_ex
ARC_mpy = _idaapi.ARC_mpy
ARC_mpyh = _idaapi.ARC_mpyh
ARC_mpyhu = _idaapi.ARC_mpyhu
ARC_mpyu = _idaapi.ARC_mpyu
ARC_neg = _idaapi.ARC_neg
ARC_not = _idaapi.ARC_not
ARC_rcmp = _idaapi.ARC_rcmp
ARC_rsub = _idaapi.ARC_rsub
ARC_rtie = _idaapi.ARC_rtie
ARC_sub1 = _idaapi.ARC_sub1
ARC_sub2 = _idaapi.ARC_sub2
ARC_sub3 = _idaapi.ARC_sub3
ARC_sync = _idaapi.ARC_sync
ARC_trap = _idaapi.ARC_trap
ARC_tst = _idaapi.ARC_tst
ARC_unimp = _idaapi.ARC_unimp
ARC_abss = _idaapi.ARC_abss
ARC_abssw = _idaapi.ARC_abssw
ARC_adds = _idaapi.ARC_adds
ARC_addsdw = _idaapi.ARC_addsdw
ARC_asls = _idaapi.ARC_asls
ARC_asrs = _idaapi.ARC_asrs
ARC_divaw = _idaapi.ARC_divaw
ARC_negs = _idaapi.ARC_negs
ARC_negsw = _idaapi.ARC_negsw
ARC_normw = _idaapi.ARC_normw
ARC_rnd16 = _idaapi.ARC_rnd16
ARC_sat16 = _idaapi.ARC_sat16
ARC_subs = _idaapi.ARC_subs
ARC_subsdw = _idaapi.ARC_subsdw
ARC_muldw = _idaapi.ARC_muldw
ARC_muludw = _idaapi.ARC_muludw
ARC_mulrdw = _idaapi.ARC_mulrdw
ARC_macdw = _idaapi.ARC_macdw
ARC_macudw = _idaapi.ARC_macudw
ARC_macrdw = _idaapi.ARC_macrdw
ARC_msubdw = _idaapi.ARC_msubdw
ARC_mululw = _idaapi.ARC_mululw
ARC_mullw = _idaapi.ARC_mullw
ARC_mulflw = _idaapi.ARC_mulflw
ARC_maclw = _idaapi.ARC_maclw
ARC_macflw = _idaapi.ARC_macflw
ARC_machulw = _idaapi.ARC_machulw
ARC_machlw = _idaapi.ARC_machlw
ARC_machflw = _idaapi.ARC_machflw
ARC_mulhlw = _idaapi.ARC_mulhlw
ARC_mulhflw = _idaapi.ARC_mulhflw
ARC_last = _idaapi.ARC_last
TMS28_null = _idaapi.TMS28_null
TMS28_aborti = _idaapi.TMS28_aborti
TMS28_abs = _idaapi.TMS28_abs
TMS28_abstc = _idaapi.TMS28_abstc
TMS28_add = _idaapi.TMS28_add
TMS28_addb = _idaapi.TMS28_addb
TMS28_addcl = _idaapi.TMS28_addcl
TMS28_addcu = _idaapi.TMS28_addcu
TMS28_addl = _idaapi.TMS28_addl
TMS28_addu = _idaapi.TMS28_addu
TMS28_addul = _idaapi.TMS28_addul
TMS28_adrk = _idaapi.TMS28_adrk
TMS28_and = _idaapi.TMS28_and
TMS28_andb = _idaapi.TMS28_andb
TMS28_asp = _idaapi.TMS28_asp
TMS28_asr = _idaapi.TMS28_asr
TMS28_asr64 = _idaapi.TMS28_asr64
TMS28_asrl = _idaapi.TMS28_asrl
TMS28_b = _idaapi.TMS28_b
TMS28_banz = _idaapi.TMS28_banz
TMS28_bar = _idaapi.TMS28_bar
TMS28_bf = _idaapi.TMS28_bf
TMS28_c27map = _idaapi.TMS28_c27map
TMS28_c27obj = _idaapi.TMS28_c27obj
TMS28_c28addr = _idaapi.TMS28_c28addr
TMS28_c28map = _idaapi.TMS28_c28map
TMS28_c28obj = _idaapi.TMS28_c28obj
TMS28_clrc = _idaapi.TMS28_clrc
TMS28_cmp = _idaapi.TMS28_cmp
TMS28_cmp64 = _idaapi.TMS28_cmp64
TMS28_cmpb = _idaapi.TMS28_cmpb
TMS28_cmpl = _idaapi.TMS28_cmpl
TMS28_cmpr = _idaapi.TMS28_cmpr
TMS28_csb = _idaapi.TMS28_csb
TMS28_dec = _idaapi.TMS28_dec
TMS28_dint = _idaapi.TMS28_dint
TMS28_dmac = _idaapi.TMS28_dmac
TMS28_dmov = _idaapi.TMS28_dmov
TMS28_eallow = _idaapi.TMS28_eallow
TMS28_edis = _idaapi.TMS28_edis
TMS28_eint = _idaapi.TMS28_eint
TMS28_estop0 = _idaapi.TMS28_estop0
TMS28_estop1 = _idaapi.TMS28_estop1
TMS28_ffc = _idaapi.TMS28_ffc
TMS28_flip = _idaapi.TMS28_flip
TMS28_iack = _idaapi.TMS28_iack
TMS28_idle = _idaapi.TMS28_idle
TMS28_imacl = _idaapi.TMS28_imacl
TMS28_impyal = _idaapi.TMS28_impyal
TMS28_impyl = _idaapi.TMS28_impyl
TMS28_impysl = _idaapi.TMS28_impysl
TMS28_impyxul = _idaapi.TMS28_impyxul
TMS28_in = _idaapi.TMS28_in
TMS28_inc = _idaapi.TMS28_inc
TMS28_intr = _idaapi.TMS28_intr
TMS28_iret = _idaapi.TMS28_iret
TMS28_lb = _idaapi.TMS28_lb
TMS28_lc = _idaapi.TMS28_lc
TMS28_lcr = _idaapi.TMS28_lcr
TMS28_loopnz = _idaapi.TMS28_loopnz
TMS28_loopz = _idaapi.TMS28_loopz
TMS28_lpaddr = _idaapi.TMS28_lpaddr
TMS28_lret = _idaapi.TMS28_lret
TMS28_lrete = _idaapi.TMS28_lrete
TMS28_lretr = _idaapi.TMS28_lretr
TMS28_lsl = _idaapi.TMS28_lsl
TMS28_lsl64 = _idaapi.TMS28_lsl64
TMS28_lsll = _idaapi.TMS28_lsll
TMS28_lsr = _idaapi.TMS28_lsr
TMS28_lsr64 = _idaapi.TMS28_lsr64
TMS28_lsrl = _idaapi.TMS28_lsrl
TMS28_mac = _idaapi.TMS28_mac
TMS28_max = _idaapi.TMS28_max
TMS28_maxcul = _idaapi.TMS28_maxcul
TMS28_maxl = _idaapi.TMS28_maxl
TMS28_min = _idaapi.TMS28_min
TMS28_mincul = _idaapi.TMS28_mincul
TMS28_minl = _idaapi.TMS28_minl
TMS28_mov = _idaapi.TMS28_mov
TMS28_mova = _idaapi.TMS28_mova
TMS28_movad = _idaapi.TMS28_movad
TMS28_movb = _idaapi.TMS28_movb
TMS28_movdl = _idaapi.TMS28_movdl
TMS28_movh = _idaapi.TMS28_movh
TMS28_movl = _idaapi.TMS28_movl
TMS28_movp = _idaapi.TMS28_movp
TMS28_movs = _idaapi.TMS28_movs
TMS28_movu = _idaapi.TMS28_movu
TMS28_movw = _idaapi.TMS28_movw
TMS28_movx = _idaapi.TMS28_movx
TMS28_movz = _idaapi.TMS28_movz
TMS28_mpy = _idaapi.TMS28_mpy
TMS28_mpya = _idaapi.TMS28_mpya
TMS28_mpyb = _idaapi.TMS28_mpyb
TMS28_mpys = _idaapi.TMS28_mpys
TMS28_mpyu = _idaapi.TMS28_mpyu
TMS28_mpyxu = _idaapi.TMS28_mpyxu
TMS28_nasp = _idaapi.TMS28_nasp
TMS28_neg = _idaapi.TMS28_neg
TMS28_neg64 = _idaapi.TMS28_neg64
TMS28_negtc = _idaapi.TMS28_negtc
TMS28_nop = _idaapi.TMS28_nop
TMS28_norm = _idaapi.TMS28_norm
TMS28_not = _idaapi.TMS28_not
TMS28_or = _idaapi.TMS28_or
TMS28_orb = _idaapi.TMS28_orb
TMS28_out = _idaapi.TMS28_out
TMS28_pop = _idaapi.TMS28_pop
TMS28_pread = _idaapi.TMS28_pread
TMS28_push = _idaapi.TMS28_push
TMS28_pwrite = _idaapi.TMS28_pwrite
TMS28_qmacl = _idaapi.TMS28_qmacl
TMS28_qmpyal = _idaapi.TMS28_qmpyal
TMS28_qmpyl = _idaapi.TMS28_qmpyl
TMS28_qmpysl = _idaapi.TMS28_qmpysl
TMS28_qmpyul = _idaapi.TMS28_qmpyul
TMS28_qmpyxul = _idaapi.TMS28_qmpyxul
TMS28_rol = _idaapi.TMS28_rol
TMS28_ror = _idaapi.TMS28_ror
TMS28_rpt = _idaapi.TMS28_rpt
TMS28_sat = _idaapi.TMS28_sat
TMS28_sat64 = _idaapi.TMS28_sat64
TMS28_sb = _idaapi.TMS28_sb
TMS28_sbbu = _idaapi.TMS28_sbbu
TMS28_sbf = _idaapi.TMS28_sbf
TMS28_sbrk = _idaapi.TMS28_sbrk
TMS28_setc = _idaapi.TMS28_setc
TMS28_sfr = _idaapi.TMS28_sfr
TMS28_spm = _idaapi.TMS28_spm
TMS28_sqra = _idaapi.TMS28_sqra
TMS28_sqrs = _idaapi.TMS28_sqrs
TMS28_sub = _idaapi.TMS28_sub
TMS28_subb = _idaapi.TMS28_subb
TMS28_subbl = _idaapi.TMS28_subbl
TMS28_subcu = _idaapi.TMS28_subcu
TMS28_subcul = _idaapi.TMS28_subcul
TMS28_subl = _idaapi.TMS28_subl
TMS28_subr = _idaapi.TMS28_subr
TMS28_subrl = _idaapi.TMS28_subrl
TMS28_subu = _idaapi.TMS28_subu
TMS28_subul = _idaapi.TMS28_subul
TMS28_sxtb = _idaapi.TMS28_sxtb
TMS28_tbit = _idaapi.TMS28_tbit
TMS28_tclr = _idaapi.TMS28_tclr
TMS28_test = _idaapi.TMS28_test
TMS28_trap = _idaapi.TMS28_trap
TMS28_tset = _idaapi.TMS28_tset
TMS28_uout = _idaapi.TMS28_uout
TMS28_xb = _idaapi.TMS28_xb
TMS28_xbanz = _idaapi.TMS28_xbanz
TMS28_xcall = _idaapi.TMS28_xcall
TMS28_xmac = _idaapi.TMS28_xmac
TMS28_xmacd = _idaapi.TMS28_xmacd
TMS28_xor = _idaapi.TMS28_xor
TMS28_xorb = _idaapi.TMS28_xorb
TMS28_xpread = _idaapi.TMS28_xpread
TMS28_xpwrite = _idaapi.TMS28_xpwrite
TMS28_xret = _idaapi.TMS28_xret
TMS28_xretc = _idaapi.TMS28_xretc
TMS28_zalr = _idaapi.TMS28_zalr
TMS28_zap = _idaapi.TMS28_zap
TMS28_zapa = _idaapi.TMS28_zapa
TMS28_last = _idaapi.TMS28_last
UNSP_null = _idaapi.UNSP_null
UNSP_add = _idaapi.UNSP_add
UNSP_adc = _idaapi.UNSP_adc
UNSP_sub = _idaapi.UNSP_sub
UNSP_sbc = _idaapi.UNSP_sbc
UNSP_cmp = _idaapi.UNSP_cmp
UNSP_cmpc = _idaapi.UNSP_cmpc
UNSP_neg = _idaapi.UNSP_neg
UNSP_negc = _idaapi.UNSP_negc
UNSP_xor = _idaapi.UNSP_xor
UNSP_load = _idaapi.UNSP_load
UNSP_or = _idaapi.UNSP_or
UNSP_and = _idaapi.UNSP_and
UNSP_test = _idaapi.UNSP_test
UNSP_store = _idaapi.UNSP_store
UNSP_add_s = _idaapi.UNSP_add_s
UNSP_adc_s = _idaapi.UNSP_adc_s
UNSP_sub_s = _idaapi.UNSP_sub_s
UNSP_sbc_s = _idaapi.UNSP_sbc_s
UNSP_cmp_s = _idaapi.UNSP_cmp_s
UNSP_cmpc_s = _idaapi.UNSP_cmpc_s
UNSP_neg_s = _idaapi.UNSP_neg_s
UNSP_negc_s = _idaapi.UNSP_negc_s
UNSP_xor_s = _idaapi.UNSP_xor_s
UNSP_load_s = _idaapi.UNSP_load_s
UNSP_or_s = _idaapi.UNSP_or_s
UNSP_and_s = _idaapi.UNSP_and_s
UNSP_test_s = _idaapi.UNSP_test_s
UNSP_store_s = _idaapi.UNSP_store_s
UNSP_retf = _idaapi.UNSP_retf
UNSP_reti = _idaapi.UNSP_reti
UNSP_pop = _idaapi.UNSP_pop
UNSP_push = _idaapi.UNSP_push
UNSP_call = _idaapi.UNSP_call
UNSP_goto = _idaapi.UNSP_goto
UNSP_nop = _idaapi.UNSP_nop
UNSP_exp = _idaapi.UNSP_exp
UNSP_jb = _idaapi.UNSP_jb
UNSP_jae = _idaapi.UNSP_jae
UNSP_jge = _idaapi.UNSP_jge
UNSP_jl = _idaapi.UNSP_jl
UNSP_jne = _idaapi.UNSP_jne
UNSP_je = _idaapi.UNSP_je
UNSP_jpl = _idaapi.UNSP_jpl
UNSP_jmi = _idaapi.UNSP_jmi
UNSP_jbe = _idaapi.UNSP_jbe
UNSP_ja = _idaapi.UNSP_ja
UNSP_jle = _idaapi.UNSP_jle
UNSP_jg = _idaapi.UNSP_jg
UNSP_jvc = _idaapi.UNSP_jvc
UNSP_jvs = _idaapi.UNSP_jvs
UNSP_jmp = _idaapi.UNSP_jmp
UNSP_mulss = _idaapi.UNSP_mulss
UNSP_mulus = _idaapi.UNSP_mulus
UNSP_muluu = _idaapi.UNSP_muluu
UNSP_divs = _idaapi.UNSP_divs
UNSP_divq = _idaapi.UNSP_divq
UNSP_int1 = _idaapi.UNSP_int1
UNSP_int2 = _idaapi.UNSP_int2
UNSP_fir_mov = _idaapi.UNSP_fir_mov
UNSP_fraction = _idaapi.UNSP_fraction
UNSP_irq = _idaapi.UNSP_irq
UNSP_secbank = _idaapi.UNSP_secbank
UNSP_fiq = _idaapi.UNSP_fiq
UNSP_irqnest = _idaapi.UNSP_irqnest
UNSP_break = _idaapi.UNSP_break
UNSP_asr = _idaapi.UNSP_asr
UNSP_asror = _idaapi.UNSP_asror
UNSP_lsl = _idaapi.UNSP_lsl
UNSP_lslor = _idaapi.UNSP_lslor
UNSP_lsr = _idaapi.UNSP_lsr
UNSP_lsror = _idaapi.UNSP_lsror
UNSP_rol = _idaapi.UNSP_rol
UNSP_ror = _idaapi.UNSP_ror
UNSP_tstb = _idaapi.UNSP_tstb
UNSP_setb = _idaapi.UNSP_setb
UNSP_clrb = _idaapi.UNSP_clrb
UNSP_invb = _idaapi.UNSP_invb
UNSP_last = _idaapi.UNSP_last
DALVIK_NOP = _idaapi.DALVIK_NOP
DALVIK_MOVE = _idaapi.DALVIK_MOVE
DALVIK_MOVE_FROM16 = _idaapi.DALVIK_MOVE_FROM16
DALVIK_MOVE_16 = _idaapi.DALVIK_MOVE_16
DALVIK_MOVE_WIDE = _idaapi.DALVIK_MOVE_WIDE
DALVIK_MOVE_WIDE_FROM16 = _idaapi.DALVIK_MOVE_WIDE_FROM16
DALVIK_MOVE_WIDE_16 = _idaapi.DALVIK_MOVE_WIDE_16
DALVIK_MOVE_OBJECT = _idaapi.DALVIK_MOVE_OBJECT
DALVIK_MOVE_OBJECT_FROM16 = _idaapi.DALVIK_MOVE_OBJECT_FROM16
DALVIK_MOVE_OBJECT_16 = _idaapi.DALVIK_MOVE_OBJECT_16
DALVIK_MOVE_RESULT = _idaapi.DALVIK_MOVE_RESULT
DALVIK_MOVE_RESULT_WIDE = _idaapi.DALVIK_MOVE_RESULT_WIDE
DALVIK_MOVE_RESULT_OBJECT = _idaapi.DALVIK_MOVE_RESULT_OBJECT
DALVIK_MOVE_EXCEPTION = _idaapi.DALVIK_MOVE_EXCEPTION
DALVIK_RETURN_VOID = _idaapi.DALVIK_RETURN_VOID
DALVIK_RETURN = _idaapi.DALVIK_RETURN
DALVIK_RETURN_WIDE = _idaapi.DALVIK_RETURN_WIDE
DALVIK_RETURN_OBJECT = _idaapi.DALVIK_RETURN_OBJECT
DALVIK_CONST_4 = _idaapi.DALVIK_CONST_4
DALVIK_CONST_16 = _idaapi.DALVIK_CONST_16
DALVIK_CONST = _idaapi.DALVIK_CONST
DALVIK_CONST_HIGH16 = _idaapi.DALVIK_CONST_HIGH16
DALVIK_CONST_WIDE_16 = _idaapi.DALVIK_CONST_WIDE_16
DALVIK_CONST_WIDE_32 = _idaapi.DALVIK_CONST_WIDE_32
DALVIK_CONST_WIDE = _idaapi.DALVIK_CONST_WIDE
DALVIK_CONST_WIDE_HIGH16 = _idaapi.DALVIK_CONST_WIDE_HIGH16
DALVIK_CONST_STRING = _idaapi.DALVIK_CONST_STRING
DALVIK_CONST_STRING_JUMBO = _idaapi.DALVIK_CONST_STRING_JUMBO
DALVIK_CONST_CLASS = _idaapi.DALVIK_CONST_CLASS
DALVIK_MONITOR_ENTER = _idaapi.DALVIK_MONITOR_ENTER
DALVIK_MONITOR_EXIT = _idaapi.DALVIK_MONITOR_EXIT
DALVIK_CHECK_CAST = _idaapi.DALVIK_CHECK_CAST
DALVIK_INSTANCE_OF = _idaapi.DALVIK_INSTANCE_OF
DALVIK_ARRAY_LENGTH = _idaapi.DALVIK_ARRAY_LENGTH
DALVIK_NEW_INSTANCE = _idaapi.DALVIK_NEW_INSTANCE
DALVIK_NEW_ARRAY = _idaapi.DALVIK_NEW_ARRAY
DALVIK_FILLED_NEW_ARRAY = _idaapi.DALVIK_FILLED_NEW_ARRAY
DALVIK_FILLED_NEW_ARRAY_RANGE = _idaapi.DALVIK_FILLED_NEW_ARRAY_RANGE
DALVIK_FILL_ARRAY_DATA = _idaapi.DALVIK_FILL_ARRAY_DATA
DALVIK_THROW = _idaapi.DALVIK_THROW
DALVIK_GOTO = _idaapi.DALVIK_GOTO
DALVIK_GOTO_16 = _idaapi.DALVIK_GOTO_16
DALVIK_GOTO_32 = _idaapi.DALVIK_GOTO_32
DALVIK_PACKED_SWITCH = _idaapi.DALVIK_PACKED_SWITCH
DALVIK_SPARSE_SWITCH = _idaapi.DALVIK_SPARSE_SWITCH
DALVIK_CMPL_FLOAT = _idaapi.DALVIK_CMPL_FLOAT
DALVIK_CMPG_FLOAT = _idaapi.DALVIK_CMPG_FLOAT
DALVIK_CMPL_DOUBLE = _idaapi.DALVIK_CMPL_DOUBLE
DALVIK_CMPG_DOUBLE = _idaapi.DALVIK_CMPG_DOUBLE
DALVIK_CMP_LONG = _idaapi.DALVIK_CMP_LONG
DALVIK_IF_EQ = _idaapi.DALVIK_IF_EQ
DALVIK_IF_NE = _idaapi.DALVIK_IF_NE
DALVIK_IF_LT = _idaapi.DALVIK_IF_LT
DALVIK_IF_GE = _idaapi.DALVIK_IF_GE
DALVIK_IF_GT = _idaapi.DALVIK_IF_GT
DALVIK_IF_LE = _idaapi.DALVIK_IF_LE
DALVIK_IF_EQZ = _idaapi.DALVIK_IF_EQZ
DALVIK_IF_NEZ = _idaapi.DALVIK_IF_NEZ
DALVIK_IF_LTZ = _idaapi.DALVIK_IF_LTZ
DALVIK_IF_GEZ = _idaapi.DALVIK_IF_GEZ
DALVIK_IF_GTZ = _idaapi.DALVIK_IF_GTZ
DALVIK_IF_LEZ = _idaapi.DALVIK_IF_LEZ
DALVIK_UNUSED_3E = _idaapi.DALVIK_UNUSED_3E
DALVIK_UNUSED_3F = _idaapi.DALVIK_UNUSED_3F
DALVIK_UNUSED_40 = _idaapi.DALVIK_UNUSED_40
DALVIK_UNUSED_41 = _idaapi.DALVIK_UNUSED_41
DALVIK_UNUSED_42 = _idaapi.DALVIK_UNUSED_42
DALVIK_UNUSED_43 = _idaapi.DALVIK_UNUSED_43
DALVIK_AGET = _idaapi.DALVIK_AGET
DALVIK_AGET_WIDE = _idaapi.DALVIK_AGET_WIDE
DALVIK_AGET_OBJECT = _idaapi.DALVIK_AGET_OBJECT
DALVIK_AGET_BOOLEAN = _idaapi.DALVIK_AGET_BOOLEAN
DALVIK_AGET_BYTE = _idaapi.DALVIK_AGET_BYTE
DALVIK_AGET_CHAR = _idaapi.DALVIK_AGET_CHAR
DALVIK_AGET_SHORT = _idaapi.DALVIK_AGET_SHORT
DALVIK_APUT = _idaapi.DALVIK_APUT
DALVIK_APUT_WIDE = _idaapi.DALVIK_APUT_WIDE
DALVIK_APUT_OBJECT = _idaapi.DALVIK_APUT_OBJECT
DALVIK_APUT_BOOLEAN = _idaapi.DALVIK_APUT_BOOLEAN
DALVIK_APUT_BYTE = _idaapi.DALVIK_APUT_BYTE
DALVIK_APUT_CHAR = _idaapi.DALVIK_APUT_CHAR
DALVIK_APUT_SHORT = _idaapi.DALVIK_APUT_SHORT
DALVIK_IGET = _idaapi.DALVIK_IGET
DALVIK_IGET_WIDE = _idaapi.DALVIK_IGET_WIDE
DALVIK_IGET_OBJECT = _idaapi.DALVIK_IGET_OBJECT
DALVIK_IGET_BOOLEAN = _idaapi.DALVIK_IGET_BOOLEAN
DALVIK_IGET_BYTE = _idaapi.DALVIK_IGET_BYTE
DALVIK_IGET_CHAR = _idaapi.DALVIK_IGET_CHAR
DALVIK_IGET_SHORT = _idaapi.DALVIK_IGET_SHORT
DALVIK_IPUT = _idaapi.DALVIK_IPUT
DALVIK_IPUT_WIDE = _idaapi.DALVIK_IPUT_WIDE
DALVIK_IPUT_OBJECT = _idaapi.DALVIK_IPUT_OBJECT
DALVIK_IPUT_BOOLEAN = _idaapi.DALVIK_IPUT_BOOLEAN
DALVIK_IPUT_BYTE = _idaapi.DALVIK_IPUT_BYTE
DALVIK_IPUT_CHAR = _idaapi.DALVIK_IPUT_CHAR
DALVIK_IPUT_SHORT = _idaapi.DALVIK_IPUT_SHORT
DALVIK_SGET = _idaapi.DALVIK_SGET
DALVIK_SGET_WIDE = _idaapi.DALVIK_SGET_WIDE
DALVIK_SGET_OBJECT = _idaapi.DALVIK_SGET_OBJECT
DALVIK_SGET_BOOLEAN = _idaapi.DALVIK_SGET_BOOLEAN
DALVIK_SGET_BYTE = _idaapi.DALVIK_SGET_BYTE
DALVIK_SGET_CHAR = _idaapi.DALVIK_SGET_CHAR
DALVIK_SGET_SHORT = _idaapi.DALVIK_SGET_SHORT
DALVIK_SPUT = _idaapi.DALVIK_SPUT
DALVIK_SPUT_WIDE = _idaapi.DALVIK_SPUT_WIDE
DALVIK_SPUT_OBJECT = _idaapi.DALVIK_SPUT_OBJECT
DALVIK_SPUT_BOOLEAN = _idaapi.DALVIK_SPUT_BOOLEAN
DALVIK_SPUT_BYTE = _idaapi.DALVIK_SPUT_BYTE
DALVIK_SPUT_CHAR = _idaapi.DALVIK_SPUT_CHAR
DALVIK_SPUT_SHORT = _idaapi.DALVIK_SPUT_SHORT
DALVIK_INVOKE_VIRTUAL = _idaapi.DALVIK_INVOKE_VIRTUAL
DALVIK_INVOKE_SUPER = _idaapi.DALVIK_INVOKE_SUPER
DALVIK_INVOKE_DIRECT = _idaapi.DALVIK_INVOKE_DIRECT
DALVIK_INVOKE_STATIC = _idaapi.DALVIK_INVOKE_STATIC
DALVIK_INVOKE_INTERFACE = _idaapi.DALVIK_INVOKE_INTERFACE
DALVIK_UNUSED_73 = _idaapi.DALVIK_UNUSED_73
DALVIK_INVOKE_VIRTUAL_RANGE = _idaapi.DALVIK_INVOKE_VIRTUAL_RANGE
DALVIK_INVOKE_SUPER_RANGE = _idaapi.DALVIK_INVOKE_SUPER_RANGE
DALVIK_INVOKE_DIRECT_RANGE = _idaapi.DALVIK_INVOKE_DIRECT_RANGE
DALVIK_INVOKE_STATIC_RANGE = _idaapi.DALVIK_INVOKE_STATIC_RANGE
DALVIK_INVOKE_INTERFACE_RANGE = _idaapi.DALVIK_INVOKE_INTERFACE_RANGE
DALVIK_UNUSED_79 = _idaapi.DALVIK_UNUSED_79
DALVIK_UNUSED_7A = _idaapi.DALVIK_UNUSED_7A
DALVIK_NEG_INT = _idaapi.DALVIK_NEG_INT
DALVIK_NOT_INT = _idaapi.DALVIK_NOT_INT
DALVIK_NEG_LONG = _idaapi.DALVIK_NEG_LONG
DALVIK_NOT_LONG = _idaapi.DALVIK_NOT_LONG
DALVIK_NEG_FLOAT = _idaapi.DALVIK_NEG_FLOAT
DALVIK_NEG_DOUBLE = _idaapi.DALVIK_NEG_DOUBLE
DALVIK_INT_TO_LONG = _idaapi.DALVIK_INT_TO_LONG
DALVIK_INT_TO_FLOAT = _idaapi.DALVIK_INT_TO_FLOAT
DALVIK_INT_TO_DOUBLE = _idaapi.DALVIK_INT_TO_DOUBLE
DALVIK_LONG_TO_INT = _idaapi.DALVIK_LONG_TO_INT
DALVIK_LONG_TO_FLOAT = _idaapi.DALVIK_LONG_TO_FLOAT
DALVIK_LONG_TO_DOUBLE = _idaapi.DALVIK_LONG_TO_DOUBLE
DALVIK_FLOAT_TO_INT = _idaapi.DALVIK_FLOAT_TO_INT
DALVIK_FLOAT_TO_LONG = _idaapi.DALVIK_FLOAT_TO_LONG
DALVIK_FLOAT_TO_DOUBLE = _idaapi.DALVIK_FLOAT_TO_DOUBLE
DALVIK_DOUBLE_TO_INT = _idaapi.DALVIK_DOUBLE_TO_INT
DALVIK_DOUBLE_TO_LONG = _idaapi.DALVIK_DOUBLE_TO_LONG
DALVIK_DOUBLE_TO_FLOAT = _idaapi.DALVIK_DOUBLE_TO_FLOAT
DALVIK_INT_TO_BYTE = _idaapi.DALVIK_INT_TO_BYTE
DALVIK_INT_TO_CHAR = _idaapi.DALVIK_INT_TO_CHAR
DALVIK_INT_TO_SHORT = _idaapi.DALVIK_INT_TO_SHORT
DALVIK_ADD_INT = _idaapi.DALVIK_ADD_INT
DALVIK_SUB_INT = _idaapi.DALVIK_SUB_INT
DALVIK_MUL_INT = _idaapi.DALVIK_MUL_INT
DALVIK_DIV_INT = _idaapi.DALVIK_DIV_INT
DALVIK_REM_INT = _idaapi.DALVIK_REM_INT
DALVIK_AND_INT = _idaapi.DALVIK_AND_INT
DALVIK_OR_INT = _idaapi.DALVIK_OR_INT
DALVIK_XOR_INT = _idaapi.DALVIK_XOR_INT
DALVIK_SHL_INT = _idaapi.DALVIK_SHL_INT
DALVIK_SHR_INT = _idaapi.DALVIK_SHR_INT
DALVIK_USHR_INT = _idaapi.DALVIK_USHR_INT
DALVIK_ADD_LONG = _idaapi.DALVIK_ADD_LONG
DALVIK_SUB_LONG = _idaapi.DALVIK_SUB_LONG
DALVIK_MUL_LONG = _idaapi.DALVIK_MUL_LONG
DALVIK_DIV_LONG = _idaapi.DALVIK_DIV_LONG
DALVIK_REM_LONG = _idaapi.DALVIK_REM_LONG
DALVIK_AND_LONG = _idaapi.DALVIK_AND_LONG
DALVIK_OR_LONG = _idaapi.DALVIK_OR_LONG
DALVIK_XOR_LONG = _idaapi.DALVIK_XOR_LONG
DALVIK_SHL_LONG = _idaapi.DALVIK_SHL_LONG
DALVIK_SHR_LONG = _idaapi.DALVIK_SHR_LONG
DALVIK_USHR_LONG = _idaapi.DALVIK_USHR_LONG
DALVIK_ADD_FLOAT = _idaapi.DALVIK_ADD_FLOAT
DALVIK_SUB_FLOAT = _idaapi.DALVIK_SUB_FLOAT
DALVIK_MUL_FLOAT = _idaapi.DALVIK_MUL_FLOAT
DALVIK_DIV_FLOAT = _idaapi.DALVIK_DIV_FLOAT
DALVIK_REM_FLOAT = _idaapi.DALVIK_REM_FLOAT
DALVIK_ADD_DOUBLE = _idaapi.DALVIK_ADD_DOUBLE
DALVIK_SUB_DOUBLE = _idaapi.DALVIK_SUB_DOUBLE
DALVIK_MUL_DOUBLE = _idaapi.DALVIK_MUL_DOUBLE
DALVIK_DIV_DOUBLE = _idaapi.DALVIK_DIV_DOUBLE
DALVIK_REM_DOUBLE = _idaapi.DALVIK_REM_DOUBLE
DALVIK_ADD_INT_2ADDR = _idaapi.DALVIK_ADD_INT_2ADDR
DALVIK_SUB_INT_2ADDR = _idaapi.DALVIK_SUB_INT_2ADDR
DALVIK_MUL_INT_2ADDR = _idaapi.DALVIK_MUL_INT_2ADDR
DALVIK_DIV_INT_2ADDR = _idaapi.DALVIK_DIV_INT_2ADDR
DALVIK_REM_INT_2ADDR = _idaapi.DALVIK_REM_INT_2ADDR
DALVIK_AND_INT_2ADDR = _idaapi.DALVIK_AND_INT_2ADDR
DALVIK_OR_INT_2ADDR = _idaapi.DALVIK_OR_INT_2ADDR
DALVIK_XOR_INT_2ADDR = _idaapi.DALVIK_XOR_INT_2ADDR
DALVIK_SHL_INT_2ADDR = _idaapi.DALVIK_SHL_INT_2ADDR
DALVIK_SHR_INT_2ADDR = _idaapi.DALVIK_SHR_INT_2ADDR
DALVIK_USHR_INT_2ADDR = _idaapi.DALVIK_USHR_INT_2ADDR
DALVIK_ADD_LONG_2ADDR = _idaapi.DALVIK_ADD_LONG_2ADDR
DALVIK_SUB_LONG_2ADDR = _idaapi.DALVIK_SUB_LONG_2ADDR
DALVIK_MUL_LONG_2ADDR = _idaapi.DALVIK_MUL_LONG_2ADDR
DALVIK_DIV_LONG_2ADDR = _idaapi.DALVIK_DIV_LONG_2ADDR
DALVIK_REM_LONG_2ADDR = _idaapi.DALVIK_REM_LONG_2ADDR
DALVIK_AND_LONG_2ADDR = _idaapi.DALVIK_AND_LONG_2ADDR
DALVIK_OR_LONG_2ADDR = _idaapi.DALVIK_OR_LONG_2ADDR
DALVIK_XOR_LONG_2ADDR = _idaapi.DALVIK_XOR_LONG_2ADDR
DALVIK_SHL_LONG_2ADDR = _idaapi.DALVIK_SHL_LONG_2ADDR
DALVIK_SHR_LONG_2ADDR = _idaapi.DALVIK_SHR_LONG_2ADDR
DALVIK_USHR_LONG_2ADDR = _idaapi.DALVIK_USHR_LONG_2ADDR
DALVIK_ADD_FLOAT_2ADDR = _idaapi.DALVIK_ADD_FLOAT_2ADDR
DALVIK_SUB_FLOAT_2ADDR = _idaapi.DALVIK_SUB_FLOAT_2ADDR
DALVIK_MUL_FLOAT_2ADDR = _idaapi.DALVIK_MUL_FLOAT_2ADDR
DALVIK_DIV_FLOAT_2ADDR = _idaapi.DALVIK_DIV_FLOAT_2ADDR
DALVIK_REM_FLOAT_2ADDR = _idaapi.DALVIK_REM_FLOAT_2ADDR
DALVIK_ADD_DOUBLE_2ADDR = _idaapi.DALVIK_ADD_DOUBLE_2ADDR
DALVIK_SUB_DOUBLE_2ADDR = _idaapi.DALVIK_SUB_DOUBLE_2ADDR
DALVIK_MUL_DOUBLE_2ADDR = _idaapi.DALVIK_MUL_DOUBLE_2ADDR
DALVIK_DIV_DOUBLE_2ADDR = _idaapi.DALVIK_DIV_DOUBLE_2ADDR
DALVIK_REM_DOUBLE_2ADDR = _idaapi.DALVIK_REM_DOUBLE_2ADDR
DALVIK_ADD_INT_LIT16 = _idaapi.DALVIK_ADD_INT_LIT16
DALVIK_RSUB_INT = _idaapi.DALVIK_RSUB_INT
DALVIK_MUL_INT_LIT16 = _idaapi.DALVIK_MUL_INT_LIT16
DALVIK_DIV_INT_LIT16 = _idaapi.DALVIK_DIV_INT_LIT16
DALVIK_REM_INT_LIT16 = _idaapi.DALVIK_REM_INT_LIT16
DALVIK_AND_INT_LIT16 = _idaapi.DALVIK_AND_INT_LIT16
DALVIK_OR_INT_LIT16 = _idaapi.DALVIK_OR_INT_LIT16
DALVIK_XOR_INT_LIT16 = _idaapi.DALVIK_XOR_INT_LIT16
DALVIK_ADD_INT_LIT8 = _idaapi.DALVIK_ADD_INT_LIT8
DALVIK_RSUB_INT_LIT8 = _idaapi.DALVIK_RSUB_INT_LIT8
DALVIK_MUL_INT_LIT8 = _idaapi.DALVIK_MUL_INT_LIT8
DALVIK_DIV_INT_LIT8 = _idaapi.DALVIK_DIV_INT_LIT8
DALVIK_REM_INT_LIT8 = _idaapi.DALVIK_REM_INT_LIT8
DALVIK_AND_INT_LIT8 = _idaapi.DALVIK_AND_INT_LIT8
DALVIK_OR_INT_LIT8 = _idaapi.DALVIK_OR_INT_LIT8
DALVIK_XOR_INT_LIT8 = _idaapi.DALVIK_XOR_INT_LIT8
DALVIK_SHL_INT_LIT8 = _idaapi.DALVIK_SHL_INT_LIT8
DALVIK_SHR_INT_LIT8 = _idaapi.DALVIK_SHR_INT_LIT8
DALVIK_USHR_INT_LIT8 = _idaapi.DALVIK_USHR_INT_LIT8
DALVIK_IGET_VOLATILE = _idaapi.DALVIK_IGET_VOLATILE
DALVIK_IPUT_VOLATILE = _idaapi.DALVIK_IPUT_VOLATILE
DALVIK_SGET_VOLATILE = _idaapi.DALVIK_SGET_VOLATILE
DALVIK_SPUT_VOLATILE = _idaapi.DALVIK_SPUT_VOLATILE
DALVIK_IGET_OBJECT_VOLATILE = _idaapi.DALVIK_IGET_OBJECT_VOLATILE
DALVIK_IGET_WIDE_VOLATILE = _idaapi.DALVIK_IGET_WIDE_VOLATILE
DALVIK_IPUT_WIDE_VOLATILE = _idaapi.DALVIK_IPUT_WIDE_VOLATILE
DALVIK_SGET_WIDE_VOLATILE = _idaapi.DALVIK_SGET_WIDE_VOLATILE
DALVIK_SPUT_WIDE_VOLATILE = _idaapi.DALVIK_SPUT_WIDE_VOLATILE
DALVIK_BREAKPOINT = _idaapi.DALVIK_BREAKPOINT
DALVIK_THROW_VERIFICATION_ERROR = _idaapi.DALVIK_THROW_VERIFICATION_ERROR
DALVIK_EXECUTE_INLINE = _idaapi.DALVIK_EXECUTE_INLINE
DALVIK_EXECUTE_INLINE_RANGE = _idaapi.DALVIK_EXECUTE_INLINE_RANGE
DALVIK_INVOKE_DIRECT_EMPTY = _idaapi.DALVIK_INVOKE_DIRECT_EMPTY
DALVIK_RETURN_VOID_BARRIER = _idaapi.DALVIK_RETURN_VOID_BARRIER
DALVIK_IGET_QUICK = _idaapi.DALVIK_IGET_QUICK
DALVIK_IGET_WIDE_QUICK = _idaapi.DALVIK_IGET_WIDE_QUICK
DALVIK_IGET_OBJECT_QUICK = _idaapi.DALVIK_IGET_OBJECT_QUICK
DALVIK_IPUT_QUICK = _idaapi.DALVIK_IPUT_QUICK
DALVIK_IPUT_WIDE_QUICK = _idaapi.DALVIK_IPUT_WIDE_QUICK
DALVIK_IPUT_OBJECT_QUICK = _idaapi.DALVIK_IPUT_OBJECT_QUICK
DALVIK_INVOKE_VIRTUAL_QUICK = _idaapi.DALVIK_INVOKE_VIRTUAL_QUICK
DALVIK_INVOKE_VIRTUAL_QUICK_RANGE = _idaapi.DALVIK_INVOKE_VIRTUAL_QUICK_RANGE
DALVIK_INVOKE_SUPER_QUICK = _idaapi.DALVIK_INVOKE_SUPER_QUICK
DALVIK_INVOKE_SUPER_QUICK_RANGE = _idaapi.DALVIK_INVOKE_SUPER_QUICK_RANGE
DALVIK_IPUT_OBJECT_VOLATILE = _idaapi.DALVIK_IPUT_OBJECT_VOLATILE
DALVIK_SGET_OBJECT_VOLATILE = _idaapi.DALVIK_SGET_OBJECT_VOLATILE
DALVIK_SPUT_OBJECT_VOLATILE = _idaapi.DALVIK_SPUT_OBJECT_VOLATILE
DALVIK_UNUSED_FF = _idaapi.DALVIK_UNUSED_FF
DALVIK_LAST = _idaapi.DALVIK_LAST
class area_t(object):
    """
    Proxy of C++ area_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    startEA = _swig_property(_idaapi.area_t_startEA_get, _idaapi.area_t_startEA_set)
    endEA = _swig_property(_idaapi.area_t_endEA_get, _idaapi.area_t_endEA_set)
    def __init__(self, *args):
        """
        __init__(self) -> area_t
        __init__(self, ea1, ea2) -> area_t
        """
        this = _idaapi.new_area_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.area_t_compare(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.area_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.area_t___ne__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.area_t___gt__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.area_t___lt__(self, *args)

    def contains(self, *args):
        """
        contains(self, ea) -> bool
        contains(self, r) -> bool
        """
        return _idaapi.area_t_contains(self, *args)

    def overlaps(self, *args):
        """
        overlaps(self, r) -> bool
        """
        return _idaapi.area_t_overlaps(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.area_t_clear(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.area_t_empty(self, *args)

    def size(self, *args):
        """
        size(self) -> asize_t
        """
        return _idaapi.area_t_size(self, *args)

    def intersect(self, *args):
        """
        intersect(self, r)
        """
        return _idaapi.area_t_intersect(self, *args)

    def extend(self, *args):
        """
        extend(self, ea)
        """
        return _idaapi.area_t_extend(self, *args)

    def _print(self, *args):
        """
        _print(self) -> size_t
        """
        return _idaapi.area_t__print(self, *args)

    __swig_destroy__ = _idaapi.delete_area_t
    __del__ = lambda self : None;
area_t_swigregister = _idaapi.area_t_swigregister
area_t_swigregister(area_t)

def area_t_print(*args):
  """
  area_t_print(cb) -> size_t
  """
  return _idaapi.area_t_print(*args)

class areavec_t(object):
    """
    Proxy of C++ areavec_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> areavec_t
        """
        this = _idaapi.new_areavec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_areavec_t
    __del__ = lambda self : None;
areavec_t_swigregister = _idaapi.areavec_t_swigregister
areavec_t_swigregister(areavec_t)

class areaset_t(object):
    """
    Proxy of C++ areaset_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> areaset_t
        __init__(self, area) -> areaset_t
        __init__(self, ivs) -> areaset_t
        """
        this = _idaapi.new_areaset_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.areaset_t_swap(self, *args)

    def add(self, *args):
        """
        add(self, area) -> bool
        add(self, start, _end) -> bool
        add(self, aset) -> bool
        """
        return _idaapi.areaset_t_add(self, *args)

    def sub(self, *args):
        """
        sub(self, area) -> bool
        sub(self, ea) -> bool
        sub(self, aset) -> bool
        """
        return _idaapi.areaset_t_sub(self, *args)

    def includes(self, *args):
        """
        includes(self, area) -> bool
        """
        return _idaapi.areaset_t_includes(self, *args)

    def _print(self, *args):
        """
        _print(self) -> size_t
        """
        return _idaapi.areaset_t__print(self, *args)

    def getarea(self, *args):
        """
        getarea(self, idx) -> area_t
        """
        return _idaapi.areaset_t_getarea(self, *args)

    def lastarea(self, *args):
        """
        lastarea(self) -> area_t
        """
        return _idaapi.areaset_t_lastarea(self, *args)

    def nareas(self, *args):
        """
        nareas(self) -> size_t
        """
        return _idaapi.areaset_t_nareas(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.areaset_t_empty(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.areaset_t_clear(self, *args)

    def has_common(self, *args):
        """
        has_common(self, area) -> bool
        has_common(self, aset) -> bool
        """
        return _idaapi.areaset_t_has_common(self, *args)

    def contains(self, *args):
        """
        contains(self, ea) -> bool
        contains(self, aset) -> bool
        """
        return _idaapi.areaset_t_contains(self, *args)

    def intersect(self, *args):
        """
        intersect(self, aset) -> bool
        """
        return _idaapi.areaset_t_intersect(self, *args)

    def is_subset_of(self, *args):
        """
        is_subset_of(self, aset) -> bool
        """
        return _idaapi.areaset_t_is_subset_of(self, *args)

    def is_equal(self, *args):
        """
        is_equal(self, aset) -> bool
        """
        return _idaapi.areaset_t_is_equal(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, aset) -> bool
        """
        return _idaapi.areaset_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, aset) -> bool
        """
        return _idaapi.areaset_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> areaset_t::const_iterator
        begin(self) -> areaset_t::iterator
        """
        return _idaapi.areaset_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> areaset_t::const_iterator
        end(self) -> areaset_t::iterator
        """
        return _idaapi.areaset_t_end(self, *args)

    def find_area(self, *args):
        """
        find_area(self, ea) -> area_t
        """
        return _idaapi.areaset_t_find_area(self, *args)

    def cached_area(self, *args):
        """
        cached_area(self) -> area_t
        """
        return _idaapi.areaset_t_cached_area(self, *args)

    def next_addr(self, *args):
        """
        next_addr(self, ea) -> ea_t
        """
        return _idaapi.areaset_t_next_addr(self, *args)

    def prev_addr(self, *args):
        """
        prev_addr(self, ea) -> ea_t
        """
        return _idaapi.areaset_t_prev_addr(self, *args)

    def next_area(self, *args):
        """
        next_area(self, ea) -> ea_t
        """
        return _idaapi.areaset_t_next_area(self, *args)

    def prev_area(self, *args):
        """
        prev_area(self, ea) -> ea_t
        """
        return _idaapi.areaset_t_prev_area(self, *args)

    __swig_destroy__ = _idaapi.delete_areaset_t
    __del__ = lambda self : None;
areaset_t_swigregister = _idaapi.areaset_t_swigregister
areaset_t_swigregister(areaset_t)

class area_visitor2_t(object):
    """
    Proxy of C++ area_visitor2_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_area(self, *args):
        """
        visit_area(self, a) -> int
        """
        return _idaapi.area_visitor2_t_visit_area(self, *args)

    __swig_destroy__ = _idaapi.delete_area_visitor2_t
    __del__ = lambda self : None;
area_visitor2_t_swigregister = _idaapi.area_visitor2_t_swigregister
area_visitor2_t_swigregister(area_visitor2_t)

class areacb_t(object):
    """
    Proxy of C++ areacb_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def zero(self, *args):
        """
        zero(self)
        """
        return _idaapi.areacb_t_zero(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> areacb_t
        """
        this = _idaapi.new_areacb_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def terminate(self, *args):
        """
        terminate(self)
        """
        return _idaapi.areacb_t_terminate(self, *args)

    __swig_destroy__ = _idaapi.delete_areacb_t
    __del__ = lambda self : None;
    def get_netnode(self, *args):
        """
        get_netnode(self) -> uval_t
        """
        return _idaapi.areacb_t_get_netnode(self, *args)

    def save(self, *args):
        """
        save(self)
        """
        return _idaapi.areacb_t_save(self, *args)

    def link(self, *args):
        """
        link(self, file, name, _infosize) -> bool
        """
        return _idaapi.areacb_t_link(self, *args)

    def create(self, *args):
        """
        create(self, file, name, _infosize) -> bool
        """
        return _idaapi.areacb_t_create(self, *args)

    def kill(self, *args):
        """
        kill(self)
        """
        return _idaapi.areacb_t_kill(self, *args)

    def create_area(self, *args):
        """
        create_area(self, info) -> bool
        """
        return _idaapi.areacb_t_create_area(self, *args)

    def update(self, *args):
        """
        update(self, info) -> bool
        """
        return _idaapi.areacb_t_update(self, *args)

    def get_area(self, *args):
        """
        get_area(self, ea) -> area_t
        """
        return _idaapi.areacb_t_get_area(self, *args)

    def getn_area(self, *args):
        """
        getn_area(self, n) -> area_t
        """
        return _idaapi.areacb_t_getn_area(self, *args)

    def get_area_num(self, *args):
        """
        get_area_num(self, ea) -> int
        """
        return _idaapi.areacb_t_get_area_num(self, *args)

    def prepare_to_create(self, *args):
        """
        prepare_to_create(self, start, end) -> ea_t
        """
        return _idaapi.areacb_t_prepare_to_create(self, *args)

    def get_next_area(self, *args):
        """
        get_next_area(self, ea) -> int
        """
        return _idaapi.areacb_t_get_next_area(self, *args)

    def get_prev_area(self, *args):
        """
        get_prev_area(self, ea) -> int
        """
        return _idaapi.areacb_t_get_prev_area(self, *args)

    def next_area_ptr(self, *args):
        """
        next_area_ptr(self, ea) -> area_t
        """
        return _idaapi.areacb_t_next_area_ptr(self, *args)

    def prev_area_ptr(self, *args):
        """
        prev_area_ptr(self, ea) -> area_t
        """
        return _idaapi.areacb_t_prev_area_ptr(self, *args)

    def first_area_ptr(self, *args):
        """
        first_area_ptr(self) -> area_t
        """
        return _idaapi.areacb_t_first_area_ptr(self, *args)

    def last_area_ptr(self, *args):
        """
        last_area_ptr(self) -> area_t
        """
        return _idaapi.areacb_t_last_area_ptr(self, *args)

    def del_area(self, *args):
        """
        del_area(self, ea, delcmt=True) -> bool
        """
        return _idaapi.areacb_t_del_area(self, *args)

    def may_start_at(self, *args):
        """
        may_start_at(self, n, newstart) -> bool
        """
        return _idaapi.areacb_t_may_start_at(self, *args)

    def may_end_at(self, *args):
        """
        may_end_at(self, n, newend) -> bool
        """
        return _idaapi.areacb_t_may_end_at(self, *args)

    def set_start(self, *args):
        """
        set_start(self, n, newstart) -> bool
        """
        return _idaapi.areacb_t_set_start(self, *args)

    def set_end(self, *args):
        """
        set_end(self, n, newend) -> bool
        """
        return _idaapi.areacb_t_set_end(self, *args)

    def make_hole(self, *args):
        """
        make_hole(self, ea1, ea2, create_tail_area)
        """
        return _idaapi.areacb_t_make_hole(self, *args)

    def resize_areas(self, *args):
        """
        resize_areas(self, n, newstart) -> bool
        """
        return _idaapi.areacb_t_resize_areas(self, *args)

    def get_area_qty(self, *args):
        """
        get_area_qty(self) -> uint
        """
        return _idaapi.areacb_t_get_area_qty(self, *args)

    def set_area_cmt(self, *args):
        """
        set_area_cmt(self, a, cmt, repeatable) -> bool
        """
        return _idaapi.areacb_t_set_area_cmt(self, *args)

    def del_area_cmt(self, *args):
        """
        del_area_cmt(self, a, repeatable)
        """
        return _idaapi.areacb_t_del_area_cmt(self, *args)

    def get_area_cmt(self, *args):
        """
        get_area_cmt(self, a, repeatable) -> char *
        """
        return _idaapi.areacb_t_get_area_cmt(self, *args)

    def for_all_areas2(self, *args):
        """
        for_all_areas2(self, ea1, ea2, av) -> int
        """
        return _idaapi.areacb_t_for_all_areas2(self, *args)

    def may_lock_area(self, *args):
        """
        may_lock_area(self, a) -> bool
        """
        return _idaapi.areacb_t_may_lock_area(self, *args)

    def get_type(self, *args):
        """
        get_type(self) -> areacb_type_t
        """
        return _idaapi.areacb_t_get_type(self, *args)

areacb_t_swigregister = _idaapi.areacb_t_swigregister
areacb_t_swigregister(areacb_t)

class lock_area(object):
    """
    Proxy of C++ lock_area class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _cb, _area) -> lock_area
        """
        this = _idaapi.new_lock_area(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lock_area
    __del__ = lambda self : None;
lock_area_swigregister = _idaapi.lock_area_swigregister
lock_area_swigregister(lock_area)

class auto_display_t(object):
    """
    Proxy of C++ auto_display_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = _swig_property(_idaapi.auto_display_t_type_get, _idaapi.auto_display_t_type_set)
    ea = _swig_property(_idaapi.auto_display_t_ea_get, _idaapi.auto_display_t_ea_set)
    state = _swig_property(_idaapi.auto_display_t_state_get, _idaapi.auto_display_t_state_set)
    def __init__(self, *args):
        """
        __init__(self) -> auto_display_t
        """
        this = _idaapi.new_auto_display_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_auto_display_t
    __del__ = lambda self : None;
auto_display_t_swigregister = _idaapi.auto_display_t_swigregister
auto_display_t_swigregister(auto_display_t)
AU_NONE = cvar.AU_NONE
AU_UNK = cvar.AU_UNK
AU_CODE = cvar.AU_CODE
AU_WEAK = cvar.AU_WEAK
AU_PROC = cvar.AU_PROC
AU_TAIL = cvar.AU_TAIL
AU_TRSP = cvar.AU_TRSP
AU_USED = cvar.AU_USED
AU_TYPE = cvar.AU_TYPE
AU_LIBF = cvar.AU_LIBF
AU_LBF2 = cvar.AU_LBF2
AU_LBF3 = cvar.AU_LBF3
AU_CHLB = cvar.AU_CHLB
AU_FINAL = cvar.AU_FINAL
st_Ready = cvar.st_Ready
st_Think = cvar.st_Think
st_Waiting = cvar.st_Waiting
st_Work = cvar.st_Work


def showAuto(*args):
  """
  showAuto(ea, type=AU_NONE)
  """
  return _idaapi.showAuto(*args)

def showAddr(*args):
  """
  showAddr(ea)
  """
  return _idaapi.showAddr(*args)

def setStat(*args):
  """
  setStat(st) -> idastate_t
  """
  return _idaapi.setStat(*args)

def may_create_stkvars(*args):
  """
  may_create_stkvars() -> bool
  """
  return _idaapi.may_create_stkvars(*args)

def may_trace_sp(*args):
  """
  may_trace_sp() -> bool
  """
  return _idaapi.may_trace_sp(*args)

def auto_mark_range(*args):
  """
  auto_mark_range(start, end, type)
  """
  return _idaapi.auto_mark_range(*args)

def autoMark(*args):
  """
  autoMark(ea, type)
  """
  return _idaapi.autoMark(*args)

def autoUnmark(*args):
  """
  autoUnmark(start, end, type)
  """
  return _idaapi.autoUnmark(*args)

def noUsed(*args):
  """
    noUsed(ea)
    noUsed(sEA, eEA)
    """
  return _idaapi.noUsed(*args)

def auto_make_code(*args):
  """
  auto_make_code(ea)
  """
  return _idaapi.auto_make_code(*args)

def auto_make_proc(*args):
  """
  auto_make_proc(ea)
  """
  return _idaapi.auto_make_proc(*args)

def reanalyze_callers(*args):
  """
  reanalyze_callers(ea, noret)
  """
  return _idaapi.reanalyze_callers(*args)

def revert_ida_decisions(*args):
  """
  revert_ida_decisions(ea1, ea2)
  """
  return _idaapi.revert_ida_decisions(*args)

def auto_apply_type(*args):
  """
  auto_apply_type(caller, callee)
  """
  return _idaapi.auto_apply_type(*args)

def analyze_area(*args):
  """
  analyze_area(sEA, eEA) -> int
  """
  return _idaapi.analyze_area(*args)

def autoWait(*args):
  """
  autoWait() -> bool
  """
  return _idaapi.autoWait(*args)

def autoCancel(*args):
  """
  autoCancel(ea1, ea2)
  """
  return _idaapi.autoCancel(*args)

def autoIsOk(*args):
  """
  autoIsOk() -> bool
  """
  return _idaapi.autoIsOk(*args)

def autoStep(*args):
  """
  autoStep() -> bool
  """
  return _idaapi.autoStep(*args)

def peek_auto_queue(*args):
  """
  peek_auto_queue(low_ea, type) -> ea_t
  """
  return _idaapi.peek_auto_queue(*args)

def auto_get(*args):
  """
  auto_get(lowEA, highEA, type) -> ea_t
  """
  return _idaapi.auto_get(*args)

def autoGetName(*args):
  """
  autoGetName(type) -> char const *
  """
  return _idaapi.autoGetName(*args)

def enable_flags(*args):
  """
  enable_flags(startEA, endEA, stt) -> error_t
  """
  return _idaapi.enable_flags(*args)

def disable_flags(*args):
  """
  disable_flags(startEA, endEA) -> error_t
  """
  return _idaapi.disable_flags(*args)

def change_storage_type(*args):
  """
  change_storage_type(startEA, endEA, stt) -> error_t
  """
  return _idaapi.change_storage_type(*args)

def nextaddr(*args):
  """
  nextaddr(ea) -> ea_t
  """
  return _idaapi.nextaddr(*args)

def prevaddr(*args):
  """
  prevaddr(ea) -> ea_t
  """
  return _idaapi.prevaddr(*args)

def nextchunk(*args):
  """
  nextchunk(ea) -> ea_t
  """
  return _idaapi.nextchunk(*args)

def prevchunk(*args):
  """
  prevchunk(ea) -> ea_t
  """
  return _idaapi.prevchunk(*args)

def chunkstart(*args):
  """
  chunkstart(ea) -> ea_t
  """
  return _idaapi.chunkstart(*args)

def chunksize(*args):
  """
  chunksize(ea) -> asize_t
  """
  return _idaapi.chunksize(*args)

def freechunk(*args):
  """
  freechunk(bottom, size, step) -> ea_t
  """
  return _idaapi.freechunk(*args)

def next_unknown(*args):
  """
  next_unknown(ea, maxea) -> ea_t
  """
  return _idaapi.next_unknown(*args)

def prev_unknown(*args):
  """
  prev_unknown(ea, minea) -> ea_t
  """
  return _idaapi.prev_unknown(*args)

def prev_head(*args):
  """
  prev_head(ea, minea) -> ea_t
  """
  return _idaapi.prev_head(*args)

def next_head(*args):
  """
  next_head(ea, maxea) -> ea_t
  """
  return _idaapi.next_head(*args)

def prev_not_tail(*args):
  """
  prev_not_tail(ea) -> ea_t
  """
  return _idaapi.prev_not_tail(*args)

def next_not_tail(*args):
  """
  next_not_tail(ea) -> ea_t
  """
  return _idaapi.next_not_tail(*args)

def get_item_head(*args):
  """
  get_item_head(ea) -> ea_t
  """
  return _idaapi.get_item_head(*args)

def get_item_end(*args):
  """
  get_item_end(ea) -> ea_t
  """
  return _idaapi.get_item_end(*args)

def calc_max_item_end(*args):
  """
  calc_max_item_end(ea, how=15) -> ea_t
  """
  return _idaapi.calc_max_item_end(*args)
ITEM_END_FIXUP = _idaapi.ITEM_END_FIXUP
ITEM_END_INITED = _idaapi.ITEM_END_INITED
ITEM_END_NAME = _idaapi.ITEM_END_NAME
ITEM_END_XREF = _idaapi.ITEM_END_XREF

def get_item_size(*args):
  """
  get_item_size(ea) -> asize_t
  """
  return _idaapi.get_item_size(*args)

def isEnabled(*args):
  """
  isEnabled(ea) -> bool
  """
  return _idaapi.isEnabled(*args)

def get_flags_ex(*args):
  """
  get_flags_ex(ea, how) -> flags_t
  """
  return _idaapi.get_flags_ex(*args)
GFE_NOVALUE = _idaapi.GFE_NOVALUE

def get_flags_novalue(*args):
  """
  get_flags_novalue(ea) -> flags_t
  """
  return _idaapi.get_flags_novalue(*args)

def getFlags(*args):
  """
  getFlags(ea) -> flags_t
  """
  return _idaapi.getFlags(*args)

def get_item_flag(*args):
  """
  get_item_flag(frm, n, ea, appzero) -> flags_t
  """
  return _idaapi.get_item_flag(*args)

def setFlags(*args):
  """
  setFlags(ea, flags)
  """
  return _idaapi.setFlags(*args)
MS_VAL = _idaapi.MS_VAL
FF_IVL = _idaapi.FF_IVL

def hasValue(*args):
  """
  hasValue(F) -> bool
  """
  return _idaapi.hasValue(*args)

def f_hasValue(*args):
  """
  f_hasValue(f, arg2) -> bool
  """
  return _idaapi.f_hasValue(*args)

def delValue(*args):
  """
  delValue(ea)
  """
  return _idaapi.delValue(*args)

def isLoaded(*args):
  """
  isLoaded(ea) -> bool
  """
  return _idaapi.isLoaded(*args)

def nbits(*args):
  """
  nbits(ea) -> int
  """
  return _idaapi.nbits(*args)

def bytesize(*args):
  """
  bytesize(ea) -> int
  """
  return _idaapi.bytesize(*args)

def get_byte(*args):
  """
  get_byte(ea) -> uchar
  """
  return _idaapi.get_byte(*args)

def get_db_byte(*args):
  """
  get_db_byte(ea) -> uchar
  """
  return _idaapi.get_db_byte(*args)

def get_word(*args):
  """
  get_word(ea) -> ushort
  """
  return _idaapi.get_word(*args)

def get_3byte(*args):
  """
  get_3byte(ea) -> uint32
  """
  return _idaapi.get_3byte(*args)

def get_long(*args):
  """
  get_long(ea) -> uint32
  """
  return _idaapi.get_long(*args)

def get_qword(*args):
  """
  get_qword(ea) -> uint64
  """
  return _idaapi.get_qword(*args)

def get_full_byte(*args):
  """
  get_full_byte(ea) -> uint32
  """
  return _idaapi.get_full_byte(*args)

def get_full_word(*args):
  """
  get_full_word(ea) -> uint64
  """
  return _idaapi.get_full_word(*args)

def get_full_long(*args):
  """
  get_full_long(ea) -> uint64
  """
  return _idaapi.get_full_long(*args)

def get_16bit(*args):
  """
  get_16bit(ea) -> uint32
  """
  return _idaapi.get_16bit(*args)

def get_32bit(*args):
  """
  get_32bit(ea) -> uint32
  """
  return _idaapi.get_32bit(*args)

def get_64bit(*args):
  """
  get_64bit(ea) -> uint64
  """
  return _idaapi.get_64bit(*args)

def get_data_value(*args):
  """
  get_data_value(ea, v, size) -> bool
  """
  return _idaapi.get_data_value(*args)

def get_original_byte(*args):
  """
  get_original_byte(ea) -> uint32
  """
  return _idaapi.get_original_byte(*args)

def get_original_word(*args):
  """
  get_original_word(ea) -> uint64
  """
  return _idaapi.get_original_word(*args)

def get_original_long(*args):
  """
  get_original_long(ea) -> uint64
  """
  return _idaapi.get_original_long(*args)

def get_original_qword(*args):
  """
  get_original_qword(ea) -> uint64
  """
  return _idaapi.get_original_qword(*args)

def put_byte(*args):
  """
  put_byte(ea, x) -> bool
  """
  return _idaapi.put_byte(*args)

def put_word(*args):
  """
  put_word(ea, x)
  """
  return _idaapi.put_word(*args)

def put_long(*args):
  """
  put_long(ea, x)
  """
  return _idaapi.put_long(*args)

def put_qword(*args):
  """
  put_qword(ea, x)
  """
  return _idaapi.put_qword(*args)

def patch_byte(*args):
  """
  patch_byte(ea, x) -> bool
  """
  return _idaapi.patch_byte(*args)

def patch_word(*args):
  """
  patch_word(ea, x) -> bool
  """
  return _idaapi.patch_word(*args)

def patch_long(*args):
  """
  patch_long(ea, x) -> bool
  """
  return _idaapi.patch_long(*args)

def patch_qword(*args):
  """
  patch_qword(ea, x) -> bool
  """
  return _idaapi.patch_qword(*args)

def add_byte(*args):
  """
  add_byte(ea, value)
  """
  return _idaapi.add_byte(*args)

def add_word(*args):
  """
  add_word(ea, value)
  """
  return _idaapi.add_word(*args)

def add_long(*args):
  """
  add_long(ea, value)
  """
  return _idaapi.add_long(*args)

def add_qword(*args):
  """
  add_qword(ea, value)
  """
  return _idaapi.add_qword(*args)

def get_zero_areas(*args):
  """
  get_zero_areas(zareas, range) -> bool
  """
  return _idaapi.get_zero_areas(*args)

def get_many_bytes_ex(*args):
  """
  get_many_bytes_ex(ea, buf, size, mask) -> int
  """
  return _idaapi.get_many_bytes_ex(*args)

def put_many_bytes(*args):
  """
  put_many_bytes(ea, buf)
  """
  return _idaapi.put_many_bytes(*args)

def patch_many_bytes(*args):
  """
  patch_many_bytes(ea, buf)
  """
  return _idaapi.patch_many_bytes(*args)
MS_CLS = _idaapi.MS_CLS
FF_CODE = _idaapi.FF_CODE
FF_DATA = _idaapi.FF_DATA
FF_TAIL = _idaapi.FF_TAIL
FF_UNK = _idaapi.FF_UNK

def isCode(*args):
  """
  isCode(F) -> bool
  """
  return _idaapi.isCode(*args)

def f_isCode(*args):
  """
  f_isCode(F, arg2) -> bool
  """
  return _idaapi.f_isCode(*args)

def isData(*args):
  """
  isData(F) -> bool
  """
  return _idaapi.isData(*args)

def f_isData(*args):
  """
  f_isData(F, arg2) -> bool
  """
  return _idaapi.f_isData(*args)

def isTail(*args):
  """
  isTail(F) -> bool
  """
  return _idaapi.isTail(*args)

def f_isTail(*args):
  """
  f_isTail(F, arg2) -> bool
  """
  return _idaapi.f_isTail(*args)

def isNotTail(*args):
  """
  isNotTail(F) -> bool
  """
  return _idaapi.isNotTail(*args)

def f_isNotTail(*args):
  """
  f_isNotTail(F, arg2) -> bool
  """
  return _idaapi.f_isNotTail(*args)

def isUnknown(*args):
  """
  isUnknown(F) -> bool
  """
  return _idaapi.isUnknown(*args)

def isHead(*args):
  """
  isHead(F) -> bool
  """
  return _idaapi.isHead(*args)

def f_isHead(*args):
  """
  f_isHead(F, arg2) -> bool
  """
  return _idaapi.f_isHead(*args)

def do_unknown(*args):
  """
  do_unknown(ea, flags) -> bool
  """
  return _idaapi.do_unknown(*args)
DOUNK_SIMPLE = _idaapi.DOUNK_SIMPLE
DOUNK_EXPAND = _idaapi.DOUNK_EXPAND
DOUNK_DELNAMES = _idaapi.DOUNK_DELNAMES
DOUNK_NOTRUNC = _idaapi.DOUNK_NOTRUNC

def do_unknown_range(*args):
  """
  do_unknown_range(ea, size, flags)
  """
  return _idaapi.do_unknown_range(*args)

def is_manual_insn(*args):
  """
  is_manual_insn(ea) -> bool
  """
  return _idaapi.is_manual_insn(*args)

def get_manual_insn(*args):
  """
  get_manual_insn(ea) -> char *
  """
  return _idaapi.get_manual_insn(*args)

def set_manual_insn(*args):
  """
  set_manual_insn(ea, manual_insn)
  """
  return _idaapi.set_manual_insn(*args)
MS_COMM = _idaapi.MS_COMM
FF_COMM = _idaapi.FF_COMM
FF_REF = _idaapi.FF_REF
FF_LINE = _idaapi.FF_LINE
FF_NAME = _idaapi.FF_NAME
FF_LABL = _idaapi.FF_LABL
FF_FLOW = _idaapi.FF_FLOW
FF_SIGN = _idaapi.FF_SIGN
FF_BNOT = _idaapi.FF_BNOT
FF_VAR = _idaapi.FF_VAR

def isFlow(*args):
  """
  isFlow(F) -> bool
  """
  return _idaapi.isFlow(*args)

def isVar(*args):
  """
  isVar(F) -> bool
  """
  return _idaapi.isVar(*args)

def hasExtra(*args):
  """
  hasExtra(F) -> bool
  """
  return _idaapi.hasExtra(*args)

def has_cmt(*args):
  """
  has_cmt(F) -> bool
  """
  return _idaapi.has_cmt(*args)

def hasRef(*args):
  """
  hasRef(F) -> bool
  """
  return _idaapi.hasRef(*args)

def f_hasRef(*args):
  """
  f_hasRef(f, arg2) -> bool
  """
  return _idaapi.f_hasRef(*args)

def has_name(*args):
  """
  has_name(F) -> bool
  """
  return _idaapi.has_name(*args)

def f_has_name(*args):
  """
  f_has_name(f, arg2) -> bool
  """
  return _idaapi.f_has_name(*args)
FF_ANYNAME = _idaapi.FF_ANYNAME

def has_dummy_name(*args):
  """
  has_dummy_name(F) -> bool
  """
  return _idaapi.has_dummy_name(*args)

def f_has_dummy_name(*args):
  """
  f_has_dummy_name(f, arg2) -> bool
  """
  return _idaapi.f_has_dummy_name(*args)

def has_auto_name(*args):
  """
  has_auto_name(F) -> bool
  """
  return _idaapi.has_auto_name(*args)

def has_any_name(*args):
  """
  has_any_name(F) -> bool
  """
  return _idaapi.has_any_name(*args)

def has_user_name(*args):
  """
  has_user_name(F) -> bool
  """
  return _idaapi.has_user_name(*args)

def f_has_user_name(*args):
  """
  f_has_user_name(F, arg2) -> bool
  """
  return _idaapi.f_has_user_name(*args)

def is_invsign(*args):
  """
  is_invsign(ea, F, n) -> bool
  """
  return _idaapi.is_invsign(*args)

def toggle_sign(*args):
  """
  toggle_sign(ea, n) -> bool
  """
  return _idaapi.toggle_sign(*args)

def signed_data_flag(*args):
  """
  signed_data_flag() -> flags_t
  """
  return _idaapi.signed_data_flag(*args)

def is_signed_data(*args):
  """
  is_signed_data(F) -> bool
  """
  return _idaapi.is_signed_data(*args)

def is_bnot(*args):
  """
  is_bnot(ea, F, n) -> bool
  """
  return _idaapi.is_bnot(*args)

def toggle_bnot(*args):
  """
  toggle_bnot(ea, n) -> bool
  """
  return _idaapi.toggle_bnot(*args)

def bnot_data_flag(*args):
  """
  bnot_data_flag() -> flags_t
  """
  return _idaapi.bnot_data_flag(*args)

def is_bnot_data(*args):
  """
  is_bnot_data(F) -> bool
  """
  return _idaapi.is_bnot_data(*args)

def is_lzero(*args):
  """
  is_lzero(ea, n) -> bool
  """
  return _idaapi.is_lzero(*args)

def set_lzero(*args):
  """
  set_lzero(ea, n) -> bool
  """
  return _idaapi.set_lzero(*args)

def clr_lzero(*args):
  """
  clr_lzero(ea, n) -> bool
  """
  return _idaapi.clr_lzero(*args)

def toggle_lzero(*args):
  """
  toggle_lzero(ea, n) -> bool
  """
  return _idaapi.toggle_lzero(*args)

def leading_zero_important(*args):
  """
  leading_zero_important(ea, n) -> bool
  """
  return _idaapi.leading_zero_important(*args)

def doVar(*args):
  """
  doVar(ea, isvar=True)
  """
  return _idaapi.doVar(*args)
MS_0TYPE = _idaapi.MS_0TYPE
FF_0VOID = _idaapi.FF_0VOID
FF_0NUMH = _idaapi.FF_0NUMH
FF_0NUMD = _idaapi.FF_0NUMD
FF_0CHAR = _idaapi.FF_0CHAR
FF_0SEG = _idaapi.FF_0SEG
FF_0OFF = _idaapi.FF_0OFF
FF_0NUMB = _idaapi.FF_0NUMB
FF_0NUMO = _idaapi.FF_0NUMO
FF_0ENUM = _idaapi.FF_0ENUM
FF_0FOP = _idaapi.FF_0FOP
FF_0STRO = _idaapi.FF_0STRO
FF_0STK = _idaapi.FF_0STK
FF_0FLT = _idaapi.FF_0FLT
FF_0CUST = _idaapi.FF_0CUST
MS_1TYPE = _idaapi.MS_1TYPE
FF_1VOID = _idaapi.FF_1VOID
FF_1NUMH = _idaapi.FF_1NUMH
FF_1NUMD = _idaapi.FF_1NUMD
FF_1CHAR = _idaapi.FF_1CHAR
FF_1SEG = _idaapi.FF_1SEG
FF_1OFF = _idaapi.FF_1OFF
FF_1NUMB = _idaapi.FF_1NUMB
FF_1NUMO = _idaapi.FF_1NUMO
FF_1ENUM = _idaapi.FF_1ENUM
FF_1FOP = _idaapi.FF_1FOP
FF_1STRO = _idaapi.FF_1STRO
FF_1STK = _idaapi.FF_1STK
FF_1FLT = _idaapi.FF_1FLT
FF_1CUST = _idaapi.FF_1CUST

def isDefArg0(*args):
  """
  isDefArg0(F) -> bool
  """
  return _idaapi.isDefArg0(*args)

def isDefArg1(*args):
  """
  isDefArg1(F) -> bool
  """
  return _idaapi.isDefArg1(*args)

def isOff0(*args):
  """
  isOff0(F) -> bool
  """
  return _idaapi.isOff0(*args)

def isOff1(*args):
  """
  isOff1(F) -> bool
  """
  return _idaapi.isOff1(*args)

def isChar0(*args):
  """
  isChar0(F) -> bool
  """
  return _idaapi.isChar0(*args)

def isChar1(*args):
  """
  isChar1(F) -> bool
  """
  return _idaapi.isChar1(*args)

def isSeg0(*args):
  """
  isSeg0(F) -> bool
  """
  return _idaapi.isSeg0(*args)

def isSeg1(*args):
  """
  isSeg1(F) -> bool
  """
  return _idaapi.isSeg1(*args)

def isEnum0(*args):
  """
  isEnum0(F) -> bool
  """
  return _idaapi.isEnum0(*args)

def isEnum1(*args):
  """
  isEnum1(F) -> bool
  """
  return _idaapi.isEnum1(*args)

def isFop0(*args):
  """
  isFop0(F) -> bool
  """
  return _idaapi.isFop0(*args)

def isFop1(*args):
  """
  isFop1(F) -> bool
  """
  return _idaapi.isFop1(*args)

def isStroff0(*args):
  """
  isStroff0(F) -> bool
  """
  return _idaapi.isStroff0(*args)

def isStroff1(*args):
  """
  isStroff1(F) -> bool
  """
  return _idaapi.isStroff1(*args)

def isStkvar0(*args):
  """
  isStkvar0(F) -> bool
  """
  return _idaapi.isStkvar0(*args)

def isStkvar1(*args):
  """
  isStkvar1(F) -> bool
  """
  return _idaapi.isStkvar1(*args)

def isFloat0(*args):
  """
  isFloat0(F) -> bool
  """
  return _idaapi.isFloat0(*args)

def isFloat1(*args):
  """
  isFloat1(F) -> bool
  """
  return _idaapi.isFloat1(*args)

def isCustFmt0(*args):
  """
  isCustFmt0(F) -> bool
  """
  return _idaapi.isCustFmt0(*args)

def isCustFmt1(*args):
  """
  isCustFmt1(F) -> bool
  """
  return _idaapi.isCustFmt1(*args)

def isNum0(*args):
  """
  isNum0(F) -> bool
  """
  return _idaapi.isNum0(*args)

def isNum1(*args):
  """
  isNum1(F) -> bool
  """
  return _idaapi.isNum1(*args)

def get_optype_flags0(*args):
  """
  get_optype_flags0(F) -> flags_t
  """
  return _idaapi.get_optype_flags0(*args)

def get_optype_flags1(*args):
  """
  get_optype_flags1(F) -> flags_t
  """
  return _idaapi.get_optype_flags1(*args)
OPND_OUTER = _idaapi.OPND_OUTER
OPND_MASK = _idaapi.OPND_MASK
OPND_ALL = _idaapi.OPND_ALL

def isDefArg(*args):
  """
  isDefArg(F, n) -> bool
  """
  return _idaapi.isDefArg(*args)

def isOff(*args):
  """
  isOff(F, n) -> bool
  """
  return _idaapi.isOff(*args)

def isChar(*args):
  """
  isChar(F, n) -> bool
  """
  return _idaapi.isChar(*args)

def isSeg(*args):
  """
  isSeg(F, n) -> bool
  """
  return _idaapi.isSeg(*args)

def isEnum(*args):
  """
  isEnum(F, n) -> bool
  """
  return _idaapi.isEnum(*args)

def isFop(*args):
  """
  isFop(F, n) -> bool
  """
  return _idaapi.isFop(*args)

def isStroff(*args):
  """
  isStroff(F, n) -> bool
  """
  return _idaapi.isStroff(*args)

def isStkvar(*args):
  """
  isStkvar(F, n) -> bool
  """
  return _idaapi.isStkvar(*args)

def isFltnum(*args):
  """
  isFltnum(F, n) -> bool
  """
  return _idaapi.isFltnum(*args)

def isCustFmt(*args):
  """
  isCustFmt(F, n) -> bool
  """
  return _idaapi.isCustFmt(*args)

def isNum(*args):
  """
  isNum(F, n) -> bool
  """
  return _idaapi.isNum(*args)

def isVoid(*args):
  """
  isVoid(ea, F, n) -> bool
  """
  return _idaapi.isVoid(*args)

def op_adds_xrefs(*args):
  """
  op_adds_xrefs(F, n) -> bool
  """
  return _idaapi.op_adds_xrefs(*args)

def set_op_type(*args):
  """
  set_op_type(ea, type, n) -> bool
  """
  return _idaapi.set_op_type(*args)

def typeflag(*args):
  """
  typeflag(ea, oldflag, type, n) -> flags_t
  """
  return _idaapi.typeflag(*args)

def op_seg(*args):
  """
  op_seg(ea, n) -> bool
  """
  return _idaapi.op_seg(*args)

def op_enum(*args):
  """
  op_enum(ea, n, id, serial) -> bool
  """
  return _idaapi.op_enum(*args)

def get_enum_id(*args):
  """
  get_enum_id(ea, n) -> enum_t
  """
  return _idaapi.get_enum_id(*args)

def op_stroff(*args):
  """
  op_stroff(ea, n, path, path_len, delta) -> bool
  """
  return _idaapi.op_stroff(*args)

def get_stroff_path(*args):
  """
  get_stroff_path(ea, n, path, delta) -> int
  """
  return _idaapi.get_stroff_path(*args)

def op_stkvar(*args):
  """
  op_stkvar(ea, n) -> bool
  """
  return _idaapi.op_stkvar(*args)

def set_forced_operand(*args):
  """
  set_forced_operand(ea, n, op) -> bool
  """
  return _idaapi.set_forced_operand(*args)

def get_forced_operand(*args):
  """
  get_forced_operand(ea, n) -> ssize_t
  """
  return _idaapi.get_forced_operand(*args)

def is_forced_operand(*args):
  """
  is_forced_operand(ea, n) -> bool
  """
  return _idaapi.is_forced_operand(*args)

def charflag(*args):
  """
  charflag() -> flags_t
  """
  return _idaapi.charflag(*args)

def offflag(*args):
  """
  offflag() -> flags_t
  """
  return _idaapi.offflag(*args)

def enumflag(*args):
  """
  enumflag() -> flags_t
  """
  return _idaapi.enumflag(*args)

def stroffflag(*args):
  """
  stroffflag() -> flags_t
  """
  return _idaapi.stroffflag(*args)

def stkvarflag(*args):
  """
  stkvarflag() -> flags_t
  """
  return _idaapi.stkvarflag(*args)

def fltflag(*args):
  """
  fltflag() -> flags_t
  """
  return _idaapi.fltflag(*args)

def custfmtflag(*args):
  """
  custfmtflag() -> flags_t
  """
  return _idaapi.custfmtflag(*args)

def segflag(*args):
  """
  segflag() -> flags_t
  """
  return _idaapi.segflag(*args)

def numflag(*args):
  """
  numflag() -> flags_t
  """
  return _idaapi.numflag(*args)

def hexflag(*args):
  """
  hexflag() -> flags_t
  """
  return _idaapi.hexflag(*args)

def decflag(*args):
  """
  decflag() -> flags_t
  """
  return _idaapi.decflag(*args)

def octflag(*args):
  """
  octflag() -> flags_t
  """
  return _idaapi.octflag(*args)

def binflag(*args):
  """
  binflag() -> flags_t
  """
  return _idaapi.binflag(*args)

def op_chr(*args):
  """
  op_chr(ea, n) -> bool
  """
  return _idaapi.op_chr(*args)

def op_num(*args):
  """
  op_num(ea, n) -> bool
  """
  return _idaapi.op_num(*args)

def op_hex(*args):
  """
  op_hex(ea, n) -> bool
  """
  return _idaapi.op_hex(*args)

def op_dec(*args):
  """
  op_dec(ea, n) -> bool
  """
  return _idaapi.op_dec(*args)

def op_oct(*args):
  """
  op_oct(ea, n) -> bool
  """
  return _idaapi.op_oct(*args)

def op_bin(*args):
  """
  op_bin(ea, n) -> bool
  """
  return _idaapi.op_bin(*args)

def op_flt(*args):
  """
  op_flt(ea, n) -> bool
  """
  return _idaapi.op_flt(*args)

def op_custfmt(*args):
  """
  op_custfmt(ea, n, fid) -> bool
  """
  return _idaapi.op_custfmt(*args)

def noType(*args):
  """
  noType(ea, n) -> bool
  """
  return _idaapi.noType(*args)

def getDefaultRadix(*args):
  """
  getDefaultRadix() -> int
  """
  return _idaapi.getDefaultRadix(*args)

def getRadix(*args):
  """
  getRadix(F, n) -> int
  """
  return _idaapi.getRadix(*args)

def getRadixEA(*args):
  """
  getRadixEA(ea, n) -> int
  """
  return _idaapi.getRadixEA(*args)
DT_TYPE = _idaapi.DT_TYPE
FF_BYTE = _idaapi.FF_BYTE
FF_WORD = _idaapi.FF_WORD
FF_DWRD = _idaapi.FF_DWRD
FF_QWRD = _idaapi.FF_QWRD
FF_TBYT = _idaapi.FF_TBYT
FF_ASCI = _idaapi.FF_ASCI
FF_STRU = _idaapi.FF_STRU
FF_OWRD = _idaapi.FF_OWRD
FF_FLOAT = _idaapi.FF_FLOAT
FF_DOUBLE = _idaapi.FF_DOUBLE
FF_PACKREAL = _idaapi.FF_PACKREAL
FF_ALIGN = _idaapi.FF_ALIGN
FF_3BYTE = _idaapi.FF_3BYTE
FF_CUSTOM = _idaapi.FF_CUSTOM
FF_YWRD = _idaapi.FF_YWRD

def codeflag(*args):
  """
  codeflag() -> flags_t
  """
  return _idaapi.codeflag(*args)

def byteflag(*args):
  """
  byteflag() -> flags_t
  """
  return _idaapi.byteflag(*args)

def wordflag(*args):
  """
  wordflag() -> flags_t
  """
  return _idaapi.wordflag(*args)

def dwrdflag(*args):
  """
  dwrdflag() -> flags_t
  """
  return _idaapi.dwrdflag(*args)

def qwrdflag(*args):
  """
  qwrdflag() -> flags_t
  """
  return _idaapi.qwrdflag(*args)

def owrdflag(*args):
  """
  owrdflag() -> flags_t
  """
  return _idaapi.owrdflag(*args)

def ywrdflag(*args):
  """
  ywrdflag() -> flags_t
  """
  return _idaapi.ywrdflag(*args)

def tbytflag(*args):
  """
  tbytflag() -> flags_t
  """
  return _idaapi.tbytflag(*args)

def asciflag(*args):
  """
  asciflag() -> flags_t
  """
  return _idaapi.asciflag(*args)

def struflag(*args):
  """
  struflag() -> flags_t
  """
  return _idaapi.struflag(*args)

def custflag(*args):
  """
  custflag() -> flags_t
  """
  return _idaapi.custflag(*args)

def alignflag(*args):
  """
  alignflag() -> flags_t
  """
  return _idaapi.alignflag(*args)

def floatflag(*args):
  """
  floatflag() -> flags_t
  """
  return _idaapi.floatflag(*args)

def doubleflag(*args):
  """
  doubleflag() -> flags_t
  """
  return _idaapi.doubleflag(*args)

def tribyteflag(*args):
  """
  tribyteflag() -> flags_t
  """
  return _idaapi.tribyteflag(*args)

def packrealflag(*args):
  """
  packrealflag() -> flags_t
  """
  return _idaapi.packrealflag(*args)

def isByte(*args):
  """
  isByte(F) -> bool
  """
  return _idaapi.isByte(*args)

def isWord(*args):
  """
  isWord(F) -> bool
  """
  return _idaapi.isWord(*args)

def isDwrd(*args):
  """
  isDwrd(F) -> bool
  """
  return _idaapi.isDwrd(*args)

def isQwrd(*args):
  """
  isQwrd(F) -> bool
  """
  return _idaapi.isQwrd(*args)

def isOwrd(*args):
  """
  isOwrd(F) -> bool
  """
  return _idaapi.isOwrd(*args)

def isYwrd(*args):
  """
  isYwrd(F) -> bool
  """
  return _idaapi.isYwrd(*args)

def isTbyt(*args):
  """
  isTbyt(F) -> bool
  """
  return _idaapi.isTbyt(*args)

def isFloat(*args):
  """
  isFloat(F) -> bool
  """
  return _idaapi.isFloat(*args)

def isDouble(*args):
  """
  isDouble(F) -> bool
  """
  return _idaapi.isDouble(*args)

def isPackReal(*args):
  """
  isPackReal(F) -> bool
  """
  return _idaapi.isPackReal(*args)

def isASCII(*args):
  """
  isASCII(F) -> bool
  """
  return _idaapi.isASCII(*args)

def isStruct(*args):
  """
  isStruct(F) -> bool
  """
  return _idaapi.isStruct(*args)

def isAlign(*args):
  """
  isAlign(F) -> bool
  """
  return _idaapi.isAlign(*args)

def is3byte(*args):
  """
  is3byte(F) -> bool
  """
  return _idaapi.is3byte(*args)

def isCustom(*args):
  """
  isCustom(F) -> bool
  """
  return _idaapi.isCustom(*args)

def f_isByte(*args):
  """
  f_isByte(F, arg2) -> bool
  """
  return _idaapi.f_isByte(*args)

def f_isWord(*args):
  """
  f_isWord(F, arg2) -> bool
  """
  return _idaapi.f_isWord(*args)

def f_isDwrd(*args):
  """
  f_isDwrd(F, arg2) -> bool
  """
  return _idaapi.f_isDwrd(*args)

def f_isQwrd(*args):
  """
  f_isQwrd(F, arg2) -> bool
  """
  return _idaapi.f_isQwrd(*args)

def f_isOwrd(*args):
  """
  f_isOwrd(F, arg2) -> bool
  """
  return _idaapi.f_isOwrd(*args)

def f_isYwrd(*args):
  """
  f_isYwrd(F, arg2) -> bool
  """
  return _idaapi.f_isYwrd(*args)

def f_isTbyt(*args):
  """
  f_isTbyt(F, arg2) -> bool
  """
  return _idaapi.f_isTbyt(*args)

def f_isFloat(*args):
  """
  f_isFloat(F, arg2) -> bool
  """
  return _idaapi.f_isFloat(*args)

def f_isDouble(*args):
  """
  f_isDouble(F, arg2) -> bool
  """
  return _idaapi.f_isDouble(*args)

def f_isPackReal(*args):
  """
  f_isPackReal(F, arg2) -> bool
  """
  return _idaapi.f_isPackReal(*args)

def f_isASCII(*args):
  """
  f_isASCII(F, arg2) -> bool
  """
  return _idaapi.f_isASCII(*args)

def f_isStruct(*args):
  """
  f_isStruct(F, arg2) -> bool
  """
  return _idaapi.f_isStruct(*args)

def f_isAlign(*args):
  """
  f_isAlign(F, arg2) -> bool
  """
  return _idaapi.f_isAlign(*args)

def f_is3byte(*args):
  """
  f_is3byte(F, arg2) -> bool
  """
  return _idaapi.f_is3byte(*args)

def f_isCustom(*args):
  """
  f_isCustom(F, arg2) -> bool
  """
  return _idaapi.f_isCustom(*args)

def is_same_data_type(*args):
  """
  is_same_data_type(F1, F2) -> bool
  """
  return _idaapi.is_same_data_type(*args)

def get_flags_by_size(*args):
  """
  get_flags_by_size(size) -> flags_t
  """
  return _idaapi.get_flags_by_size(*args)

def do_data_ex(*args):
  """
  do_data_ex(ea, dataflag, size, tid) -> bool
  """
  return _idaapi.do_data_ex(*args)

def doByte(*args):
  """
  doByte(ea, length) -> bool
  """
  return _idaapi.doByte(*args)

def doWord(*args):
  """
  doWord(ea, length) -> bool
  """
  return _idaapi.doWord(*args)

def doDwrd(*args):
  """
  doDwrd(ea, length) -> bool
  """
  return _idaapi.doDwrd(*args)

def doQwrd(*args):
  """
  doQwrd(ea, length) -> bool
  """
  return _idaapi.doQwrd(*args)

def doOwrd(*args):
  """
  doOwrd(ea, length) -> bool
  """
  return _idaapi.doOwrd(*args)

def doYwrd(*args):
  """
  doYwrd(ea, length) -> bool
  """
  return _idaapi.doYwrd(*args)

def doTbyt(*args):
  """
  doTbyt(ea, length) -> bool
  """
  return _idaapi.doTbyt(*args)

def doFloat(*args):
  """
  doFloat(ea, length) -> bool
  """
  return _idaapi.doFloat(*args)

def doDouble(*args):
  """
  doDouble(ea, length) -> bool
  """
  return _idaapi.doDouble(*args)

def doPackReal(*args):
  """
  doPackReal(ea, length) -> bool
  """
  return _idaapi.doPackReal(*args)

def doASCI(*args):
  """
  doASCI(ea, length) -> bool
  """
  return _idaapi.doASCI(*args)

def do3byte(*args):
  """
  do3byte(ea, length) -> bool
  """
  return _idaapi.do3byte(*args)

def doStruct(*args):
  """
  doStruct(ea, length, tid) -> bool
  """
  return _idaapi.doStruct(*args)

def doCustomData(*args):
  """
  doCustomData(ea, length, dtid, fid) -> bool
  """
  return _idaapi.doCustomData(*args)

def doAlign(*args):
  """
  doAlign(ea, length, alignment) -> bool
  """
  return _idaapi.doAlign(*args)

def calc_min_align(*args):
  """
  calc_min_align(length) -> int
  """
  return _idaapi.calc_min_align(*args)

def calc_max_align(*args):
  """
  calc_max_align(endea) -> int
  """
  return _idaapi.calc_max_align(*args)

def calc_def_align(*args):
  """
  calc_def_align(ea, mina, maxa) -> int
  """
  return _idaapi.calc_def_align(*args)

def do16bit(*args):
  """
  do16bit(ea, length) -> bool
  """
  return _idaapi.do16bit(*args)

def do32bit(*args):
  """
  do32bit(ea, length) -> bool
  """
  return _idaapi.do32bit(*args)
ALOPT_IGNHEADS = _idaapi.ALOPT_IGNHEADS
ALOPT_IGNPRINT = _idaapi.ALOPT_IGNPRINT

def get_max_ascii_length(*args):
  """
  get_max_ascii_length(ea, strtype, options=0) -> size_t
  """
  return _idaapi.get_max_ascii_length(*args)
ACFOPT_ASCII = _idaapi.ACFOPT_ASCII
ACFOPT_UTF16 = _idaapi.ACFOPT_UTF16
ACFOPT_UTF8 = _idaapi.ACFOPT_UTF8
ACFOPT_CONVMASK = _idaapi.ACFOPT_CONVMASK
ACFOPT_ESCAPE = _idaapi.ACFOPT_ESCAPE

def make_ascii_string(*args):
  """
  make_ascii_string(start, len, strtype) -> bool
  """
  return _idaapi.make_ascii_string(*args)

def print_ascii_string_type(*args):
  """
  print_ascii_string_type(strtype) -> char *
  """
  return _idaapi.print_ascii_string_type(*args)

def get_opinfo(*args):
  """
  get_opinfo(ea, n, flags, buf) -> opinfo_t
  """
  return _idaapi.get_opinfo(*args)

def set_opinfo(*args):
  """
  set_opinfo(ea, n, flag, ti) -> bool
  """
  return _idaapi.set_opinfo(*args)

def get_data_elsize(*args):
  """
  get_data_elsize(ea, F, ti=None) -> asize_t
  """
  return _idaapi.get_data_elsize(*args)

def get_full_data_elsize(*args):
  """
  get_full_data_elsize(ea, F, ti=None) -> asize_t
  """
  return _idaapi.get_full_data_elsize(*args)

def is_varsize_item(*args):
  """
  is_varsize_item(ea, F, ti=None, itemsize=None) -> int
  """
  return _idaapi.is_varsize_item(*args)

def can_define_item(*args):
  """
  can_define_item(ea, length, flags) -> bool
  """
  return _idaapi.can_define_item(*args)
MS_CODE = _idaapi.MS_CODE
FF_FUNC = _idaapi.FF_FUNC
FF_IMMD = _idaapi.FF_IMMD
FF_JUMP = _idaapi.FF_JUMP

def isImmd(*args):
  """
  isImmd(F) -> bool
  """
  return _idaapi.isImmd(*args)

def isFunc(*args):
  """
  isFunc(F) -> bool
  """
  return _idaapi.isFunc(*args)

def doImmd(*args):
  """
  doImmd(ea) -> bool
  """
  return _idaapi.doImmd(*args)

def noImmd(*args):
  """
  noImmd(ea) -> bool
  """
  return _idaapi.noImmd(*args)
MS_TAIL = _idaapi.MS_TAIL
TL_TSFT = _idaapi.TL_TSFT
TL_TOFF = _idaapi.TL_TOFF
MAX_TOFF = _idaapi.MAX_TOFF

def gettof(*args):
  """
  gettof(F) -> ushort
  """
  return _idaapi.gettof(*args)

def get_custom_data_types(*args):
  """
  get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int
  """
  return _idaapi.get_custom_data_types(*args)

def get_custom_data_formats(*args):
  """
  get_custom_data_formats(out, dtid) -> int
  """
  return _idaapi.get_custom_data_formats(*args)

def find_custom_data_type(*args):
  """
  find_custom_data_type(name) -> int
  """
  return _idaapi.find_custom_data_type(*args)

def find_custom_data_format(*args):
  """
  find_custom_data_format(name) -> int
  """
  return _idaapi.find_custom_data_format(*args)

def set_cmt(*args):
  """
  set_cmt(ea, comm, rptble) -> bool
  """
  return _idaapi.set_cmt(*args)

def get_cmt(*args):
  """
  get_cmt(ea, rptble) -> ssize_t
  """
  return _idaapi.get_cmt(*args)

def append_cmt(*args):
  """
  append_cmt(ea, str, rptble) -> bool
  """
  return _idaapi.append_cmt(*args)

def find_byte(*args):
  """
  find_byte(sEA, size, value, bin_search_flags) -> ea_t
  """
  return _idaapi.find_byte(*args)

def find_byter(*args):
  """
  find_byter(sEA, size, value, bin_search_flags) -> ea_t
  """
  return _idaapi.find_byter(*args)

def bin_search(*args):
  """
  bin_search(startEA, endEA, image, mask, len, step, flags) -> ea_t
  """
  return _idaapi.bin_search(*args)
BIN_SEARCH_FORWARD = _idaapi.BIN_SEARCH_FORWARD
BIN_SEARCH_BACKWARD = _idaapi.BIN_SEARCH_BACKWARD
BIN_SEARCH_CASE = _idaapi.BIN_SEARCH_CASE
BIN_SEARCH_NOCASE = _idaapi.BIN_SEARCH_NOCASE
BIN_SEARCH_NOBREAK = _idaapi.BIN_SEARCH_NOBREAK

def equal_bytes(*args):
  """
  equal_bytes(ea, image, mask, len, sense_case) -> bool
  """
  return _idaapi.equal_bytes(*args)
class hidden_area_t(area_t):
    """
    Proxy of C++ hidden_area_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    description = _swig_property(_idaapi.hidden_area_t_description_get, _idaapi.hidden_area_t_description_set)
    header = _swig_property(_idaapi.hidden_area_t_header_get, _idaapi.hidden_area_t_header_set)
    footer = _swig_property(_idaapi.hidden_area_t_footer_get, _idaapi.hidden_area_t_footer_set)
    visible = _swig_property(_idaapi.hidden_area_t_visible_get, _idaapi.hidden_area_t_visible_set)
    color = _swig_property(_idaapi.hidden_area_t_color_get, _idaapi.hidden_area_t_color_set)
    def __init__(self, *args):
        """
        __init__(self) -> hidden_area_t
        """
        this = _idaapi.new_hidden_area_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_hidden_area_t
    __del__ = lambda self : None;
hidden_area_t_swigregister = _idaapi.hidden_area_t_swigregister
hidden_area_t_swigregister(hidden_area_t)


def update_hidden_area(*args):
  """
  update_hidden_area(ha) -> bool
  """
  return _idaapi.update_hidden_area(*args)

def add_hidden_area(*args):
  """
  add_hidden_area(ea1, ea2, description, header, footer, color) -> bool
  """
  return _idaapi.add_hidden_area(*args)

def get_hidden_area(*args):
  """
  get_hidden_area(ea) -> hidden_area_t
  """
  return _idaapi.get_hidden_area(*args)

def getn_hidden_area(*args):
  """
  getn_hidden_area(n) -> hidden_area_t
  """
  return _idaapi.getn_hidden_area(*args)

def get_hidden_area_qty(*args):
  """
  get_hidden_area_qty() -> int
  """
  return _idaapi.get_hidden_area_qty(*args)

def get_hidden_area_num(*args):
  """
  get_hidden_area_num(ea) -> int
  """
  return _idaapi.get_hidden_area_num(*args)

def get_prev_hidden_area(*args):
  """
  get_prev_hidden_area(ea) -> hidden_area_t
  """
  return _idaapi.get_prev_hidden_area(*args)

def get_next_hidden_area(*args):
  """
  get_next_hidden_area(ea) -> hidden_area_t
  """
  return _idaapi.get_next_hidden_area(*args)

def del_hidden_area(*args):
  """
  del_hidden_area(ea) -> bool
  """
  return _idaapi.del_hidden_area(*args)

def doExtra(*args):
  """
  doExtra(ea) -> bool
  """
  return _idaapi.doExtra(*args)

def noExtra(*args):
  """
  noExtra(ea) -> bool
  """
  return _idaapi.noExtra(*args)

def get_data_type_size(*args):
  """
  get_data_type_size(F, ti) -> asize_t
  """
  return _idaapi.get_data_type_size(*args)

def f_isUnknown(*args):
  """
  f_isUnknown(F, arg2) -> bool
  """
  return _idaapi.f_isUnknown(*args)

def get_typeinfo(*args):
  """
  get_typeinfo(ea, n, flags, buf) -> opinfo_t
  """
  return _idaapi.get_typeinfo(*args)

def set_typeinfo(*args):
  """
  set_typeinfo(ea, n, flag, ti) -> bool
  """
  return _idaapi.set_typeinfo(*args)

def set_stroff_path(*args):
  """
  set_stroff_path(ea, n, path, plen, delta) -> bool
  """
  return _idaapi.set_stroff_path(*args)

def del_stroff_path(*args):
  """
  del_stroff_path(ea, n) -> bool
  """
  return _idaapi.del_stroff_path(*args)

def del_enum_id(*args):
  """
  del_enum_id(ea, n)
  """
  return _idaapi.del_enum_id(*args)

def enum_encode(*args):
  """
  enum_encode(id, serial) -> uval_t
  """
  return _idaapi.enum_encode(*args)

def enum_decode(*args):
  """
  enum_decode(code) -> enum_t
  """
  return _idaapi.enum_decode(*args)

def visit_patched_bytes(*args):
  """
  visit_patched_bytes(ea1, ea2, py_callable) -> int


  Enumerates patched bytes in the given range and invokes a callable
  @param ea1: start address
  @param ea2: end address
  @param callable: a Python callable with the following prototype:
                   callable(ea, fpos, org_val, patch_val).
                   If the callable returns non-zero then that value will be
                   returned to the caller and the enumeration will be
                   interrupted.
  @return: Zero if the enumeration was successful or the return
           value of the callback if enumeration was interrupted.
  """
  return _idaapi.visit_patched_bytes(*args)

def nextthat(*args):
  """
  nextthat(ea, maxea, callable) -> ea_t


  Find next address with a flag satisfying the function 'testf'.
  Start searching from address 'ea'+1 and inspect bytes up to 'maxea'.
  maxea is not included in the search range.
  
  @param callable: a Python callable with the following prototype:
                   callable(flags). Return True to stop enumeration.
  @return: the found address or BADADDR.
  """
  return _idaapi.nextthat(*args)

def prevthat(*args):
  """
  prevthat(ea, minea, callable) -> ea_t
  """
  return _idaapi.prevthat(*args)

def get_many_bytes(*args):
  """
  get_many_bytes(ea, size) -> PyObject *


  Get the specified number of bytes of the program into the buffer.
  @param ea: program address
  @param size: number of bytes to return
  @return: None or the string buffer
  """
  return _idaapi.get_many_bytes(*args)

def get_ascii_contents2(*args):
  """
  get_ascii_contents2(ea, len, type, flags=0x00000000) -> PyObject *


  Get bytes contents at location, possibly converted.
  It works even if the string has not been created in the database yet.
  
  Note that this will <b>always</b> return a simple string of bytes
  (i.e., a 'str' instance), and not a string of unicode characters.
  
  If you want auto-conversion to unicode strings (that is: real strings),
  you should probably be using the idautils.Strings class.
  
  @param ea: linear address of the string
  @param len: length of the string in bytes (including terminating 0)
  @param type: type of the string. Represents both the character encoding,
               <u>and</u> the 'type' of string at the given location.
  @param flags: combination of ACFOPT_..., to perform output conversion.
  @return: a bytes-filled str object.
  """
  return _idaapi.get_ascii_contents2(*args)

def get_ascii_contents(*args):
  """
  get_ascii_contents(ea, len, type) -> PyObject *


  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.
  
  @param ea: linear address of the string
  @param len: length of the string in bytes (including terminating 0)
  @param type: type of the string
  @return: string contents (not including terminating 0) or None
  """
  return _idaapi.get_ascii_contents(*args)

def register_custom_data_type(*args):
  """
  register_custom_data_type(py_dt) -> int


  Registers a custom data type.
  @param dt: an instance of the data_type_t class
  @return:
      < 0 if failed to register
      > 0 data type id
  """
  return _idaapi.register_custom_data_type(*args)

def unregister_custom_data_type(*args):
  """
  unregister_custom_data_type(dtid) -> bool


  Unregisters a custom data type.
  @param dtid: the data type id
  @return: Boolean
  """
  return _idaapi.unregister_custom_data_type(*args)

def register_custom_data_format(*args):
  """
  register_custom_data_format(dtid, py_df) -> int


  Registers a custom data format with a given data type.
  @param dtid: data type id
  @param df: an instance of data_format_t
  @return:
      < 0 if failed to register
      > 0 data format id
  """
  return _idaapi.register_custom_data_format(*args)

def unregister_custom_data_format(*args):
  """
  unregister_custom_data_format(dtid, dfid) -> bool


  Unregisters a custom data format
  @param dtid: data type id
  @param dfid: data format id
  @return: Boolean
  """
  return _idaapi.unregister_custom_data_format(*args)

def get_custom_data_format(*args):
  """
  get_custom_data_format(dtid, fid) -> PyObject *


  Returns a dictionary populated with the data format values or None on failure.
  @param dtid: data type id
  @param dfid: data format id
  """
  return _idaapi.get_custom_data_format(*args)

def get_custom_data_type(*args):
  """
  get_custom_data_type(dtid) -> PyObject *


  Returns a dictionary populated with the data type values or None on failure.
  @param dtid: data type id
  """
  return _idaapi.get_custom_data_type(*args)
#<pycode(py_bytes)>
DTP_NODUP = 0x0001

class data_type_t(object):
    """
    Custom data type definition. All data types should inherit from this class.
    """

    def __init__(self, name, value_size = 0, menu_name = None, hotkey = None, asm_keyword = None, props = 0):
        """
        Please refer to bytes.hpp / data_type_t in the SDK
        """
        self.name  = name
        self.props = props
        self.menu_name = menu_name
        self.hotkey = hotkey
        self.asm_keyword = asm_keyword
        self.value_size = value_size

        self.id = -1 # Will be initialized after registration
        """
        Contains the data type id after the data type is registered
        """

    def register(self):
        """
        Registers the data type and returns the type id or < 0 on failure
        """
        return _idaapi.register_custom_data_type(self)

    def unregister(self):
        """
        Unregisters the data type and returns True on success
        """
        # Not registered?
        if self.id < 0:
            return True

        # Try to unregister
        r = _idaapi.unregister_custom_data_type(self.id)

        # Clear the ID
        if r:
            self.id = -1
        return r
#<pydoc>
#    def may_create_at(self, ea, nbytes):
#        """
#        (optional) If this callback is not defined then this means always may create data type at the given ea.
#        @param ea: address of the future item
#        @param nbytes: size of the future item
#        @return: Boolean
#        """
#
#        return False
#
#    def calc_item_size(self, ea, maxsize):
#        """
#        (optional) If this callback is defined it means variable size datatype
#        This function is used to determine size of the (possible) item at 'ea'
#        @param ea: address of the item
#        @param maxsize: maximal size of the item
#        @return: integer
#            Returns: 0-no such item can be created/displayed
#                     this callback is required only for varsize datatypes
#        """
#        return 0
#</pydoc>
# -----------------------------------------------------------------------
# Uncomment the corresponding callbacks in the inherited class
class data_format_t(object):
    """
    Information about a data format
    """
    def __init__(self, name, value_size = 0, menu_name = None, props = 0, hotkey = None, text_width = 0):
        """
        Custom data format definition.
        @param name: Format name, must be unique
        @param menu_name: Visible format name to use in menus
        @param props: properties (currently 0)
        @param hotkey: Hotkey for the corresponding menu item
        @param value_size: size of the value in bytes. 0 means any size is ok
        @text_width: Usual width of the text representation
        """
        self.name = name
        self.menu_name = menu_name
        self.props = props
        self.hotkey = hotkey
        self.value_size = value_size
        self.text_width = text_width

        self.id = -1 # Will be initialized after registration
        """
        contains the format id after the format gets registered
        """

    def register(self, dtid):
        """
        Registers the data format with the given data type id and returns the type id or < 0 on failure
        """
        return _idaapi.register_custom_data_format(dtid, self)

    def unregister(self, dtid):
        """
        Unregisters the data format with the given data type id
        """

        # Not registered?
        if self.id < 0:
            return True

        # Unregister
        r = _idaapi.unregister_custom_data_format(dtid, self.id)

        # Clear the ID
        if r:
            self.id = -1
        return r
#<pydoc>
#    def printf(self, value, current_ea, operand_num, dtid):
#        """
#        Convert a value buffer to colored string.
#
#        @param value: The value to be printed
#        @param current_ea: The ea of the value
#        @param operand_num: The affected operand
#        @param dtid: custom data type id (0-standard built-in data type)
#        @return: a colored string representing the passed 'value' or None on failure
#        """
#        return None
#
#    def scan(self, input, current_ea, operand_num):
#        """
#        Convert from uncolored string 'input' to byte value
#
#        @param input: input string
#        @param current_ea: current address (BADADDR if unknown)
#        @param operand_num: current operand number (-1 if unknown)
#
#        @return: tuple (Boolean, string)
#            - (False, ErrorMessage) if conversion fails
#            - (True, Value buffer) if conversion succeeds
#        """
#        return (False, "Not implemented")
#
#    def analyze(self, current_ea, operand_num):
#        """
#        (optional) Analyze custom data format occurrence.
#        It can be used to create xrefs from the current item.
#
#        @param current_ea: current address (BADADDR if unknown)
#        @param operand_num: current operand number
#        @return: None
#        """
#
#        pass
#</pydoc>
# -----------------------------------------------------------------------
def __walk_types_and_formats(formats, type_action, format_action, installing):
    broken = False
    for f in formats:
        if len(f) == 1:
            if not format_action(f[0], 0):
                broken = True
                break
        else:
            dt  = f[0]
            dfs = f[1:]
            # install data type before installing formats
            if installing and not type_action(dt):
                broken = True
                break
            # process formats using the correct dt.id
            for df in dfs:
                if not format_action(df, dt.id):
                    broken = True
                    break
            # uninstall data type after uninstalling formats
            if not installing and not type_action(dt):
                broken = True
                break
    return not broken

# -----------------------------------------------------------------------
def register_data_types_and_formats(formats):
    """
    Registers multiple data types and formats at once.
    To register one type/format at a time use register_custom_data_type/register_custom_data_format

    It employs a special table of types and formats described below:

    The 'formats' is a list of tuples. If a tuple has one element then it is the format to be registered with dtid=0
    If the tuple has more than one element, then tuple[0] is the data type and tuple[1:] are the data formats. For example:
    many_formats = [
      (pascal_data_type(), pascal_data_format()),
      (simplevm_data_type(), simplevm_data_format()),
      (makedword_data_format(),),
      (simplevm_data_format(),)
    ]
    The first two tuples describe data types and their associated formats.
    The last two tuples describe two data formats to be used with built-in data types.
    """
    def __reg_format(df, dtid):
        df.register(dtid)
        if dtid == 0:
            print "Registered format '%s' with built-in types, ID=%d" % (df.name, df.id)
        else:
            print "   Registered format '%s', ID=%d (dtid=%d)" % (df.name, df.id, dtid)
        return df.id != -1

    def __reg_type(dt):
        dt.register()
        print "Registered type '%s', ID=%d" % (dt.name, dt.id)
        return dt.id != -1
    ok = __walk_types_and_formats(formats, __reg_type, __reg_format, True)
    return 1 if ok else -1

# -----------------------------------------------------------------------
def unregister_data_types_and_formats(formats):
    """
    As opposed to register_data_types_and_formats(), this function
    unregisters multiple data types and formats at once.
    """
    def __unreg_format(df, dtid):
        print "%snregistering format '%s'" % ("U" if dtid == 0 else "   u", df.name)
        df.unregister(dtid)
        return True

    def __unreg_type(dt):
        print "Unregistering type '%s', ID=%d" % (dt.name, dt.id)
        dt.unregister()
        return True
    ok = __walk_types_and_formats(formats, __unreg_type, __unreg_format, False)
    return 1 if ok else -1

#</pycode(py_bytes)>

class bpt_vec_t(object):
    """
    Proxy of C++ qvector<(bpt_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> bpt_vec_t
        __init__(self, x) -> bpt_vec_t
        """
        this = _idaapi.new_bpt_vec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_bpt_vec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.bpt_vec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.bpt_vec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.bpt_vec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> bpt_t
        """
        return _idaapi.bpt_vec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> bpt_t
        front(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> bpt_t
        back(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.bpt_vec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.bpt_vec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.bpt_vec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=bpt_t())
        """
        return _idaapi.bpt_vec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.bpt_vec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.bpt_vec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.bpt_vec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.bpt_vec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.bpt_vec_t_inject(self, *args)

    def begin(self, *args):
        """
        begin(self) -> bpt_t
        begin(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> bpt_t
        end(self) -> bpt_t
        """
        return _idaapi.bpt_vec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> bpt_t
        """
        return _idaapi.bpt_vec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> bpt_t
        erase(self, first, last) -> bpt_t
        """
        return _idaapi.bpt_vec_t_erase(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.bpt_vec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> bpt_t
        """
        return _idaapi.bpt_vec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.bpt_vec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

bpt_vec_t_swigregister = _idaapi.bpt_vec_t_swigregister
bpt_vec_t_swigregister(bpt_vec_t)
power2 = cvar.power2
lowbits = cvar.lowbits


def set_bptloc_string(*args):
  """
  set_bptloc_string(s) -> int
  """
  return _idaapi.set_bptloc_string(*args)

def get_bptloc_string(*args):
  """
  get_bptloc_string(i) -> char const *
  """
  return _idaapi.get_bptloc_string(*args)
BPLT_ABS = _idaapi.BPLT_ABS
BPLT_REL = _idaapi.BPLT_REL
BPLT_SYM = _idaapi.BPLT_SYM
BPLT_SRC = _idaapi.BPLT_SRC
class bpt_location_t(object):
    """
    Proxy of C++ bpt_location_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    info = _swig_property(_idaapi.bpt_location_t_info_get, _idaapi.bpt_location_t_info_set)
    index = _swig_property(_idaapi.bpt_location_t_index_get, _idaapi.bpt_location_t_index_set)
    loctype = _swig_property(_idaapi.bpt_location_t_loctype_get, _idaapi.bpt_location_t_loctype_set)
    def type(self, *args):
        """
        type(self) -> bpt_loctype_t
        """
        return _idaapi.bpt_location_t_type(self, *args)

    def is_empty_path(self, *args):
        """
        is_empty_path(self) -> bool
        """
        return _idaapi.bpt_location_t_is_empty_path(self, *args)

    def path(self, *args):
        """
        path(self) -> char const *
        """
        return _idaapi.bpt_location_t_path(self, *args)

    def symbol(self, *args):
        """
        symbol(self) -> char const *
        """
        return _idaapi.bpt_location_t_symbol(self, *args)

    def lineno(self, *args):
        """
        lineno(self) -> int
        """
        return _idaapi.bpt_location_t_lineno(self, *args)

    def offset(self, *args):
        """
        offset(self) -> uval_t
        """
        return _idaapi.bpt_location_t_offset(self, *args)

    def ea(self, *args):
        """
        ea(self) -> ea_t
        """
        return _idaapi.bpt_location_t_ea(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> bpt_location_t
        """
        this = _idaapi.new_bpt_location_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_abs_bpt(self, *args):
        """
        set_abs_bpt(self, a)
        """
        return _idaapi.bpt_location_t_set_abs_bpt(self, *args)

    def set_src_bpt(self, *args):
        """
        set_src_bpt(self, fn, _lineno)
        """
        return _idaapi.bpt_location_t_set_src_bpt(self, *args)

    def set_sym_bpt(self, *args):
        """
        set_sym_bpt(self, _symbol, _offset=0)
        """
        return _idaapi.bpt_location_t_set_sym_bpt(self, *args)

    def set_rel_bpt(self, *args):
        """
        set_rel_bpt(self, mod, _offset)
        """
        return _idaapi.bpt_location_t_set_rel_bpt(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.bpt_location_t_compare(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.bpt_location_t___ge__(self, *args)

    __swig_destroy__ = _idaapi.delete_bpt_location_t
    __del__ = lambda self : None;
bpt_location_t_swigregister = _idaapi.bpt_location_t_swigregister
bpt_location_t_swigregister(bpt_location_t)

class bpt_t(object):
    """
    Proxy of C++ bpt_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cb = _swig_property(_idaapi.bpt_t_cb_get, _idaapi.bpt_t_cb_set)
    loc = _swig_property(_idaapi.bpt_t_loc_get, _idaapi.bpt_t_loc_set)
    ea = _swig_property(_idaapi.bpt_t_ea_get, _idaapi.bpt_t_ea_set)
    type = _swig_property(_idaapi.bpt_t_type_get, _idaapi.bpt_t_type_set)
    pass_count = _swig_property(_idaapi.bpt_t_pass_count_get, _idaapi.bpt_t_pass_count_set)
    flags = _swig_property(_idaapi.bpt_t_flags_get, _idaapi.bpt_t_flags_set)
    props = _swig_property(_idaapi.bpt_t_props_get, _idaapi.bpt_t_props_set)
    size = _swig_property(_idaapi.bpt_t_size_get, _idaapi.bpt_t_size_set)
    cndidx = _swig_property(_idaapi.bpt_t_cndidx_get, _idaapi.bpt_t_cndidx_set)
    def __init__(self, *args):
        """
        __init__(self) -> bpt_t
        """
        this = _idaapi.new_bpt_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_hwbpt(self, *args):
        """
        is_hwbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_hwbpt(self, *args)

    def enabled(self, *args):
        """
        enabled(self) -> bool
        """
        return _idaapi.bpt_t_enabled(self, *args)

    def is_low_level(self, *args):
        """
        is_low_level(self) -> bool
        """
        return _idaapi.bpt_t_is_low_level(self, *args)

    def badbpt(self, *args):
        """
        badbpt(self) -> bool
        """
        return _idaapi.bpt_t_badbpt(self, *args)

    def listbpt(self, *args):
        """
        listbpt(self) -> bool
        """
        return _idaapi.bpt_t_listbpt(self, *args)

    def is_compiled(self, *args):
        """
        is_compiled(self) -> bool
        """
        return _idaapi.bpt_t_is_compiled(self, *args)

    def is_active(self, *args):
        """
        is_active(self) -> bool
        """
        return _idaapi.bpt_t_is_active(self, *args)

    def is_partially_active(self, *args):
        """
        is_partially_active(self) -> bool
        """
        return _idaapi.bpt_t_is_partially_active(self, *args)

    def is_inactive(self, *args):
        """
        is_inactive(self) -> bool
        """
        return _idaapi.bpt_t_is_inactive(self, *args)

    def is_page_bpt(self, *args):
        """
        is_page_bpt(self) -> bool
        """
        return _idaapi.bpt_t_is_page_bpt(self, *args)

    def get_size(self, *args):
        """
        get_size(self) -> int
        """
        return _idaapi.bpt_t_get_size(self, *args)

    def set_abs_bpt(self, *args):
        """
        set_abs_bpt(self, a)
        """
        return _idaapi.bpt_t_set_abs_bpt(self, *args)

    def set_src_bpt(self, *args):
        """
        set_src_bpt(self, fn, lineno)
        """
        return _idaapi.bpt_t_set_src_bpt(self, *args)

    def set_sym_bpt(self, *args):
        """
        set_sym_bpt(self, sym, o)
        """
        return _idaapi.bpt_t_set_sym_bpt(self, *args)

    def set_rel_bpt(self, *args):
        """
        set_rel_bpt(self, mod, o)
        """
        return _idaapi.bpt_t_set_rel_bpt(self, *args)

    def is_absbpt(self, *args):
        """
        is_absbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_absbpt(self, *args)

    def is_relbpt(self, *args):
        """
        is_relbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_relbpt(self, *args)

    def is_symbpt(self, *args):
        """
        is_symbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_symbpt(self, *args)

    def is_srcbpt(self, *args):
        """
        is_srcbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_srcbpt(self, *args)

    def is_tracemodebpt(self, *args):
        """
        is_tracemodebpt(self) -> bool
        """
        return _idaapi.bpt_t_is_tracemodebpt(self, *args)

    def is_traceonbpt(self, *args):
        """
        is_traceonbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_traceonbpt(self, *args)

    def is_traceoffbpt(self, *args):
        """
        is_traceoffbpt(self) -> bool
        """
        return _idaapi.bpt_t_is_traceoffbpt(self, *args)

    def set_trace_action(self, *args):
        """
        set_trace_action(self, enable, trace_types) -> bool
        """
        return _idaapi.bpt_t_set_trace_action(self, *args)

    condition = _swig_property(_idaapi.bpt_t_condition_get, _idaapi.bpt_t_condition_set)
    elang = _swig_property(_idaapi.bpt_t_elang_get, _idaapi.bpt_t_elang_set)
    __swig_destroy__ = _idaapi.delete_bpt_t
    __del__ = lambda self : None;
bpt_t_swigregister = _idaapi.bpt_t_swigregister
bpt_t_swigregister(bpt_t)
BPT_BRK = _idaapi.BPT_BRK
BPT_TRACE = _idaapi.BPT_TRACE
BPT_UPDMEM = _idaapi.BPT_UPDMEM
BPT_ENABLED = _idaapi.BPT_ENABLED
BPT_LOWCND = _idaapi.BPT_LOWCND
BPT_TRACEON = _idaapi.BPT_TRACEON
BPT_TRACE_INSN = _idaapi.BPT_TRACE_INSN
BPT_TRACE_FUNC = _idaapi.BPT_TRACE_FUNC
BPT_TRACE_BBLK = _idaapi.BPT_TRACE_BBLK
BPT_TRACE_TYPES = _idaapi.BPT_TRACE_TYPES
BKPT_BADBPT = _idaapi.BKPT_BADBPT
BKPT_LISTBPT = _idaapi.BKPT_LISTBPT
BKPT_TRACE = _idaapi.BKPT_TRACE
BKPT_ACTIVE = _idaapi.BKPT_ACTIVE
BKPT_PARTIAL = _idaapi.BKPT_PARTIAL
BKPT_CNDREADY = _idaapi.BKPT_CNDREADY
BKPT_FAKEPEND = _idaapi.BKPT_FAKEPEND
BKPT_PAGE = _idaapi.BKPT_PAGE
BKPT_ELANG_MASK = _idaapi.BKPT_ELANG_MASK
BKPT_ELANG_SHIFT = _idaapi.BKPT_ELANG_SHIFT

MOVBPT_OK = _idaapi.MOVBPT_OK
MOVBPT_NOT_FOUND = _idaapi.MOVBPT_NOT_FOUND
MOVBPT_DEST_BUSY = _idaapi.MOVBPT_DEST_BUSY
MOVBPT_BAD_TYPE = _idaapi.MOVBPT_BAD_TYPE
tev_none = _idaapi.tev_none
tev_insn = _idaapi.tev_insn
tev_call = _idaapi.tev_call
tev_ret = _idaapi.tev_ret
tev_bpt = _idaapi.tev_bpt
tev_mem = _idaapi.tev_mem
tev_event = _idaapi.tev_event
tev_max = _idaapi.tev_max
class tev_info_t(object):
    """
    Proxy of C++ tev_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = _swig_property(_idaapi.tev_info_t_type_get, _idaapi.tev_info_t_type_set)
    tid = _swig_property(_idaapi.tev_info_t_tid_get, _idaapi.tev_info_t_tid_set)
    ea = _swig_property(_idaapi.tev_info_t_ea_get, _idaapi.tev_info_t_ea_set)
    def __init__(self, *args):
        """
        __init__(self) -> tev_info_t
        """
        this = _idaapi.new_tev_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_tev_info_t
    __del__ = lambda self : None;
tev_info_t_swigregister = _idaapi.tev_info_t_swigregister
tev_info_t_swigregister(tev_info_t)

DEC_NOTASK = _idaapi.DEC_NOTASK
DEC_ERROR = _idaapi.DEC_ERROR
DEC_TIMEOUT = _idaapi.DEC_TIMEOUT

def wait_for_next_event(*args):
  """
  wait_for_next_event(wfne, timeout_in_secs) -> dbg_event_code_t
  """
  return _idaapi.wait_for_next_event(*args)
WFNE_ANY = _idaapi.WFNE_ANY
WFNE_SUSP = _idaapi.WFNE_SUSP
WFNE_SILENT = _idaapi.WFNE_SILENT
WFNE_CONT = _idaapi.WFNE_CONT
WFNE_NOWAIT = _idaapi.WFNE_NOWAIT
WFNE_USEC = _idaapi.WFNE_USEC

def get_debug_event(*args):
  """
  get_debug_event() -> debug_event_t
  """
  return _idaapi.get_debug_event(*args)

def set_debugger_options(*args):
  """
  set_debugger_options(options) -> uint
  """
  return _idaapi.set_debugger_options(*args)
DOPT_SEGM_MSGS = _idaapi.DOPT_SEGM_MSGS
DOPT_START_BPT = _idaapi.DOPT_START_BPT
DOPT_THREAD_MSGS = _idaapi.DOPT_THREAD_MSGS
DOPT_THREAD_BPT = _idaapi.DOPT_THREAD_BPT
DOPT_BPT_MSGS = _idaapi.DOPT_BPT_MSGS
DOPT_LIB_MSGS = _idaapi.DOPT_LIB_MSGS
DOPT_LIB_BPT = _idaapi.DOPT_LIB_BPT
DOPT_INFO_MSGS = _idaapi.DOPT_INFO_MSGS
DOPT_INFO_BPT = _idaapi.DOPT_INFO_BPT
DOPT_REAL_MEMORY = _idaapi.DOPT_REAL_MEMORY
DOPT_REDO_STACK = _idaapi.DOPT_REDO_STACK
DOPT_ENTRY_BPT = _idaapi.DOPT_ENTRY_BPT
DOPT_EXCDLG = _idaapi.DOPT_EXCDLG
EXCDLG_NEVER = _idaapi.EXCDLG_NEVER
EXCDLG_UNKNOWN = _idaapi.EXCDLG_UNKNOWN
EXCDLG_ALWAYS = _idaapi.EXCDLG_ALWAYS
DOPT_LOAD_DINFO = _idaapi.DOPT_LOAD_DINFO
DOPT_END_BPT = _idaapi.DOPT_END_BPT
DOPT_TEMP_HWBPT = _idaapi.DOPT_TEMP_HWBPT

def set_remote_debugger(*args):
  """
  set_remote_debugger(host, _pass, port=-1)
  """
  return _idaapi.set_remote_debugger(*args)

def get_process_options(*args):
  """
  get_process_options(path, args, sdir, host, _pass, port)
  """
  return _idaapi.get_process_options(*args)

def set_process_options(*args):
  """
  set_process_options(path, args, sdir, host, _pass, port)
  """
  return _idaapi.set_process_options(*args)

def retrieve_exceptions(*args):
  """
  retrieve_exceptions() -> excvec_t *
  """
  return _idaapi.retrieve_exceptions(*args)

def store_exceptions(*args):
  """
  store_exceptions() -> bool
  """
  return _idaapi.store_exceptions(*args)

def define_exception(*args):
  """
  define_exception(code, name, desc, flags) -> char const *
  """
  return _idaapi.define_exception(*args)

def have_set_options(*args):
  """
  have_set_options(_dbg) -> bool
  """
  return _idaapi.have_set_options(*args)

def set_dbg_options(*args):
  """
    set_dbg_options(_dbg, keyword, pri, value_type, value) -> char const
    set_dbg_options(keyword, pri, value_type, value) -> char const *
    """
  return _idaapi.set_dbg_options(*args)

def set_dbg_default_options(*args):
  """
  set_dbg_default_options(keyword, value_type, value) -> char const *
  """
  return _idaapi.set_dbg_default_options(*args)

def set_int_dbg_options(*args):
  """
  set_int_dbg_options(keyword, value) -> char const *
  """
  return _idaapi.set_int_dbg_options(*args)
class eval_ctx_t(object):
    """
    Proxy of C++ eval_ctx_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _ea) -> eval_ctx_t
        """
        this = _idaapi.new_eval_ctx_t(*args)
        try: self.this.append(this)
        except: self.this = this
    ea = _swig_property(_idaapi.eval_ctx_t_ea_get, _idaapi.eval_ctx_t_ea_set)
    __swig_destroy__ = _idaapi.delete_eval_ctx_t
    __del__ = lambda self : None;
eval_ctx_t_swigregister = _idaapi.eval_ctx_t_swigregister
eval_ctx_t_swigregister(eval_ctx_t)

SRCIT_NONE = _idaapi.SRCIT_NONE
SRCIT_MODULE = _idaapi.SRCIT_MODULE
SRCIT_FUNC = _idaapi.SRCIT_FUNC
SRCIT_STMT = _idaapi.SRCIT_STMT
SRCIT_EXPR = _idaapi.SRCIT_EXPR
SRCIT_STKVAR = _idaapi.SRCIT_STKVAR
SRCIT_REGVAR = _idaapi.SRCIT_REGVAR
SRCIT_RRLVAR = _idaapi.SRCIT_RRLVAR
SRCIT_STTVAR = _idaapi.SRCIT_STTVAR
SRCIT_LOCVAR = _idaapi.SRCIT_LOCVAR
SRCDBG_PROV_VERSION = _idaapi.SRCDBG_PROV_VERSION

def create_source_viewer(*args):
  """
  create_source_viewer(parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t *
  """
  return _idaapi.create_source_viewer(*args)

def get_dbg_byte(*args):
  """
  get_dbg_byte(ea, x) -> bool
  """
  return _idaapi.get_dbg_byte(*args)

def put_dbg_byte(*args):
  """
  put_dbg_byte(ea, x) -> bool
  """
  return _idaapi.put_dbg_byte(*args)

def invalidate_dbgmem_config(*args):
  """
  invalidate_dbgmem_config()
  """
  return _idaapi.invalidate_dbgmem_config(*args)

def invalidate_dbgmem_contents(*args):
  """
  invalidate_dbgmem_contents(ea, size)
  """
  return _idaapi.invalidate_dbgmem_contents(*args)

def is_debugger_on(*args):
  """
  is_debugger_on() -> bool
  """
  return _idaapi.is_debugger_on(*args)

def is_debugger_memory(*args):
  """
  is_debugger_memory(ea) -> bool
  """
  return _idaapi.is_debugger_memory(*args)

def run_requests(*args):
  """
  run_requests() -> bool
  """
  return _idaapi.run_requests(*args)

def get_running_request(*args):
  """
  get_running_request() -> ui_notification_t
  """
  return _idaapi.get_running_request(*args)

def get_running_notification(*args):
  """
  get_running_notification() -> dbg_notification_t
  """
  return _idaapi.get_running_notification(*args)

def clear_requests_queue(*args):
  """
  clear_requests_queue()
  """
  return _idaapi.clear_requests_queue(*args)

def get_process_state(*args):
  """
  get_process_state() -> int
  """
  return _idaapi.get_process_state(*args)

def start_process(*args):
  """
  start_process(path, args, sdir) -> int
  """
  return _idaapi.start_process(*args)

def request_start_process(*args):
  """
  request_start_process(path, args, sdir) -> int
  """
  return _idaapi.request_start_process(*args)

def suspend_process(*args):
  """
  suspend_process() -> bool
  """
  return _idaapi.suspend_process(*args)

def request_suspend_process(*args):
  """
  request_suspend_process() -> bool
  """
  return _idaapi.request_suspend_process(*args)

def continue_process(*args):
  """
  continue_process() -> bool
  """
  return _idaapi.continue_process(*args)

def request_continue_process(*args):
  """
  request_continue_process() -> bool
  """
  return _idaapi.request_continue_process(*args)

def exit_process(*args):
  """
  exit_process() -> bool
  """
  return _idaapi.exit_process(*args)

def request_exit_process(*args):
  """
  request_exit_process() -> bool
  """
  return _idaapi.request_exit_process(*args)

def get_process_qty(*args):
  """
  get_process_qty() -> int
  """
  return _idaapi.get_process_qty(*args)

def get_process_info(*args):
  """
  get_process_info(n, process_info) -> pid_t
  """
  return _idaapi.get_process_info(*args)

def attach_process(*args):
  """
  attach_process(pid, event_id) -> int
  """
  return _idaapi.attach_process(*args)

def request_attach_process(*args):
  """
  request_attach_process(pid, event_id) -> int
  """
  return _idaapi.request_attach_process(*args)

def detach_process(*args):
  """
  detach_process() -> bool
  """
  return _idaapi.detach_process(*args)

def request_detach_process(*args):
  """
  request_detach_process() -> bool
  """
  return _idaapi.request_detach_process(*args)

def get_thread_qty(*args):
  """
  get_thread_qty() -> int
  """
  return _idaapi.get_thread_qty(*args)

def getn_thread(*args):
  """
  getn_thread(n) -> thid_t
  """
  return _idaapi.getn_thread(*args)

def select_thread(*args):
  """
  select_thread(tid) -> bool
  """
  return _idaapi.select_thread(*args)

def request_select_thread(*args):
  """
  request_select_thread(tid) -> bool
  """
  return _idaapi.request_select_thread(*args)

def set_resume_mode(*args):
  """
  set_resume_mode(tid, mode) -> bool
  """
  return _idaapi.set_resume_mode(*args)

def request_set_resume_mode(*args):
  """
  request_set_resume_mode(tid, mode) -> bool
  """
  return _idaapi.request_set_resume_mode(*args)

def step_into(*args):
  """
  step_into() -> bool
  """
  return _idaapi.step_into(*args)

def request_step_into(*args):
  """
  request_step_into() -> bool
  """
  return _idaapi.request_step_into(*args)

def step_over(*args):
  """
  step_over() -> bool
  """
  return _idaapi.step_over(*args)

def request_step_over(*args):
  """
  request_step_over() -> bool
  """
  return _idaapi.request_step_over(*args)

def run_to(*args):
  """
  run_to(ea) -> bool
  """
  return _idaapi.run_to(*args)

def request_run_to(*args):
  """
  request_run_to(ea) -> bool
  """
  return _idaapi.request_run_to(*args)

def step_until_ret(*args):
  """
  step_until_ret() -> bool
  """
  return _idaapi.step_until_ret(*args)

def request_step_until_ret(*args):
  """
  request_step_until_ret() -> bool
  """
  return _idaapi.request_step_until_ret(*args)

def get_reg_val(*args):
  """
  get_reg_val(regname, regval) -> bool
  """
  return _idaapi.get_reg_val(*args)

def request_set_reg_val(*args):
  """
  request_set_reg_val(regname, regval) -> bool
  """
  return _idaapi.request_set_reg_val(*args)

def get_bpt_qty(*args):
  """
  get_bpt_qty() -> int
  """
  return _idaapi.get_bpt_qty(*args)

def getn_bpt(*args):
  """
  getn_bpt(n, bpt) -> bool
  """
  return _idaapi.getn_bpt(*args)

def get_bpt(*args):
  """
  get_bpt(ea, bpt) -> bool
  """
  return _idaapi.get_bpt(*args)

def find_bpt(*args):
  """
  find_bpt(bptloc, bpt) -> bool
  """
  return _idaapi.find_bpt(*args)

def add_bpt(*args):
  """
    add_bpt(ea, size, type) -> bool
    add_bpt(bpt) -> bool
    """
  return _idaapi.add_bpt(*args)

def request_add_bpt(*args):
  """
    request_add_bpt(ea, size, type) -> bool
    request_add_bpt(bpt) -> bool
    """
  return _idaapi.request_add_bpt(*args)

def del_bpt(*args):
  """
    del_bpt(ea) -> bool
    del_bpt(bptloc) -> bool
    """
  return _idaapi.del_bpt(*args)

def request_del_bpt(*args):
  """
    request_del_bpt(ea) -> bool
    request_del_bpt(bptloc) -> bool
    """
  return _idaapi.request_del_bpt(*args)

def update_bpt(*args):
  """
  update_bpt(bpt) -> bool
  """
  return _idaapi.update_bpt(*args)

def enable_bpt(*args):
  """
    enable_bpt(ea, enable) -> bool
    enable_bpt(bptloc, enable) -> bool
    """
  return _idaapi.enable_bpt(*args)

def request_enable_bpt(*args):
  """
    request_enable_bpt(ea, enable) -> bool
    request_enable_bpt(bptloc, enable) -> bool
    """
  return _idaapi.request_enable_bpt(*args)

def set_trace_size(*args):
  """
  set_trace_size(size) -> bool
  """
  return _idaapi.set_trace_size(*args)

def clear_trace(*args):
  """
  clear_trace()
  """
  return _idaapi.clear_trace(*args)

def request_clear_trace(*args):
  """
  request_clear_trace()
  """
  return _idaapi.request_clear_trace(*args)

def is_step_trace_enabled(*args):
  """
  is_step_trace_enabled() -> bool
  """
  return _idaapi.is_step_trace_enabled(*args)

def enable_step_trace(*args):
  """
  enable_step_trace(enable) -> bool
  """
  return _idaapi.enable_step_trace(*args)

def request_enable_step_trace(*args):
  """
  request_enable_step_trace(enable) -> bool
  """
  return _idaapi.request_enable_step_trace(*args)

def get_step_trace_options(*args):
  """
  get_step_trace_options() -> int
  """
  return _idaapi.get_step_trace_options(*args)

def set_step_trace_options(*args):
  """
  set_step_trace_options(options)
  """
  return _idaapi.set_step_trace_options(*args)

def request_set_step_trace_options(*args):
  """
  request_set_step_trace_options(options)
  """
  return _idaapi.request_set_step_trace_options(*args)

def is_insn_trace_enabled(*args):
  """
  is_insn_trace_enabled() -> bool
  """
  return _idaapi.is_insn_trace_enabled(*args)

def enable_insn_trace(*args):
  """
  enable_insn_trace(enable) -> bool
  """
  return _idaapi.enable_insn_trace(*args)

def request_enable_insn_trace(*args):
  """
  request_enable_insn_trace(enable) -> bool
  """
  return _idaapi.request_enable_insn_trace(*args)

def get_insn_trace_options(*args):
  """
  get_insn_trace_options() -> int
  """
  return _idaapi.get_insn_trace_options(*args)

def set_insn_trace_options(*args):
  """
  set_insn_trace_options(options)
  """
  return _idaapi.set_insn_trace_options(*args)

def request_set_insn_trace_options(*args):
  """
  request_set_insn_trace_options(options)
  """
  return _idaapi.request_set_insn_trace_options(*args)

def is_func_trace_enabled(*args):
  """
  is_func_trace_enabled() -> bool
  """
  return _idaapi.is_func_trace_enabled(*args)

def enable_func_trace(*args):
  """
  enable_func_trace(enable) -> bool
  """
  return _idaapi.enable_func_trace(*args)

def request_enable_func_trace(*args):
  """
  request_enable_func_trace(enable) -> bool
  """
  return _idaapi.request_enable_func_trace(*args)

def get_func_trace_options(*args):
  """
  get_func_trace_options() -> int
  """
  return _idaapi.get_func_trace_options(*args)

def set_func_trace_options(*args):
  """
  set_func_trace_options(options)
  """
  return _idaapi.set_func_trace_options(*args)

def request_set_func_trace_options(*args):
  """
  request_set_func_trace_options(options)
  """
  return _idaapi.request_set_func_trace_options(*args)

def set_highlight_trace_options(*args):
  """
  set_highlight_trace_options(hilight, color, diff)
  """
  return _idaapi.set_highlight_trace_options(*args)

def is_bblk_trace_enabled(*args):
  """
  is_bblk_trace_enabled() -> bool
  """
  return _idaapi.is_bblk_trace_enabled(*args)

def enable_bblk_trace(*args):
  """
  enable_bblk_trace(enable) -> bool
  """
  return _idaapi.enable_bblk_trace(*args)

def request_enable_bblk_trace(*args):
  """
  request_enable_bblk_trace(enable) -> bool
  """
  return _idaapi.request_enable_bblk_trace(*args)

def get_bblk_trace_options(*args):
  """
  get_bblk_trace_options() -> int
  """
  return _idaapi.get_bblk_trace_options(*args)

def set_bblk_trace_options(*args):
  """
  set_bblk_trace_options(options)
  """
  return _idaapi.set_bblk_trace_options(*args)

def request_set_bblk_trace_options(*args):
  """
  request_set_bblk_trace_options(options)
  """
  return _idaapi.request_set_bblk_trace_options(*args)

def get_tev_qty(*args):
  """
  get_tev_qty() -> int
  """
  return _idaapi.get_tev_qty(*args)

def get_tev_info(*args):
  """
  get_tev_info(n, tev_info) -> bool
  """
  return _idaapi.get_tev_info(*args)

def get_insn_tev_reg_val(*args):
  """
  get_insn_tev_reg_val(n, regname, regval) -> bool
  """
  return _idaapi.get_insn_tev_reg_val(*args)

def get_insn_tev_reg_mem(*args):
  """
  get_insn_tev_reg_mem(n, memmap) -> bool
  """
  return _idaapi.get_insn_tev_reg_mem(*args)

def get_insn_tev_reg_result(*args):
  """
  get_insn_tev_reg_result(n, regname, regval) -> bool
  """
  return _idaapi.get_insn_tev_reg_result(*args)

def get_call_tev_callee(*args):
  """
  get_call_tev_callee(n) -> ea_t
  """
  return _idaapi.get_call_tev_callee(*args)

def get_ret_tev_return(*args):
  """
  get_ret_tev_return(n) -> ea_t
  """
  return _idaapi.get_ret_tev_return(*args)

def get_bpt_tev_ea(*args):
  """
  get_bpt_tev_ea(n) -> ea_t
  """
  return _idaapi.get_bpt_tev_ea(*args)

def get_tev_memory_info(*args):
  """
  get_tev_memory_info(n, mi) -> bool
  """
  return _idaapi.get_tev_memory_info(*args)

def get_tev_event(*args):
  """
  get_tev_event(n, d) -> bool
  """
  return _idaapi.get_tev_event(*args)

def get_tev_ea(*args):
  """
  get_tev_ea(n) -> ea_t
  """
  return _idaapi.get_tev_ea(*args)

def get_tev_type(*args):
  """
  get_tev_type(n) -> int
  """
  return _idaapi.get_tev_type(*args)

def get_tev_tid(*args):
  """
  get_tev_tid(n) -> int
  """
  return _idaapi.get_tev_tid(*args)

def get_tev_reg_val(*args):
  """
  get_tev_reg_val(n, regname) -> ea_t
  """
  return _idaapi.get_tev_reg_val(*args)

def get_tev_reg_mem_qty(*args):
  """
  get_tev_reg_mem_qty(n) -> int
  """
  return _idaapi.get_tev_reg_mem_qty(*args)

def get_tev_reg_mem_ea(*args):
  """
  get_tev_reg_mem_ea(n, idx) -> ea_t
  """
  return _idaapi.get_tev_reg_mem_ea(*args)

def get_trace_base_address(*args):
  """
  get_trace_base_address() -> ea_t
  """
  return _idaapi.get_trace_base_address(*args)

def load_trace_file(*args):
  """
  load_trace_file(filename) -> bool
  """
  return _idaapi.load_trace_file(*args)

def save_trace_file(*args):
  """
  save_trace_file(filename, description) -> bool
  """
  return _idaapi.save_trace_file(*args)

def is_valid_trace_file(*args):
  """
  is_valid_trace_file(filename) -> bool
  """
  return _idaapi.is_valid_trace_file(*args)

def set_trace_file_desc(*args):
  """
  set_trace_file_desc(filename, description) -> bool
  """
  return _idaapi.set_trace_file_desc(*args)

def get_trace_file_desc(*args):
  """
  get_trace_file_desc(filename) -> bool
  """
  return _idaapi.get_trace_file_desc(*args)

def choose_trace_file(*args):
  """
  choose_trace_file() -> bool
  """
  return _idaapi.choose_trace_file(*args)

def diff_trace_file(*args):
  """
  diff_trace_file(filename) -> bool
  """
  return _idaapi.diff_trace_file(*args)

def set_trace_platform(*args):
  """
  set_trace_platform(platform)
  """
  return _idaapi.set_trace_platform(*args)

def get_trace_platform(*args):
  """
  get_trace_platform() -> char const *
  """
  return _idaapi.get_trace_platform(*args)

def graph_trace(*args):
  """
  graph_trace() -> bool
  """
  return _idaapi.graph_trace(*args)

def set_trace_base_address(*args):
  """
  set_trace_base_address(ea)
  """
  return _idaapi.set_trace_base_address(*args)

def dbg_add_thread(*args):
  """
  dbg_add_thread(tid)
  """
  return _idaapi.dbg_add_thread(*args)

def dbg_del_thread(*args):
  """
  dbg_del_thread(tid)
  """
  return _idaapi.dbg_del_thread(*args)

def dbg_add_tev(*args):
  """
  dbg_add_tev(type, tid, address)
  """
  return _idaapi.dbg_add_tev(*args)

def dbg_add_many_tevs(*args):
  """
  dbg_add_many_tevs(new_tevs) -> bool
  """
  return _idaapi.dbg_add_many_tevs(*args)

def dbg_add_insn_tev(*args):
  """
  dbg_add_insn_tev(tid, ea, save) -> bool
  """
  return _idaapi.dbg_add_insn_tev(*args)

def dbg_add_bpt_tev(*args):
  """
  dbg_add_bpt_tev(tid, ea, bp) -> bool
  """
  return _idaapi.dbg_add_bpt_tev(*args)

def dbg_add_call_tev(*args):
  """
  dbg_add_call_tev(tid, caller, callee)
  """
  return _idaapi.dbg_add_call_tev(*args)

def dbg_add_ret_tev(*args):
  """
  dbg_add_ret_tev(tid, ret_insn, return_to)
  """
  return _idaapi.dbg_add_ret_tev(*args)

def dbg_add_debug_event(*args):
  """
  dbg_add_debug_event(event)
  """
  return _idaapi.dbg_add_debug_event(*args)

def is_reg_integer(*args):
  """
  is_reg_integer(regname) -> bool
  """
  return _idaapi.is_reg_integer(*args)

def is_reg_float(*args):
  """
  is_reg_float(regname) -> bool
  """
  return _idaapi.is_reg_float(*args)

def is_reg_custom(*args):
  """
  is_reg_custom(regname) -> bool
  """
  return _idaapi.is_reg_custom(*args)

def get_first_module(*args):
  """
  get_first_module(modinfo) -> bool
  """
  return _idaapi.get_first_module(*args)

def get_next_module(*args):
  """
  get_next_module(modinfo) -> bool
  """
  return _idaapi.get_next_module(*args)

def bring_debugger_to_front(*args):
  """
  bring_debugger_to_front()
  """
  return _idaapi.bring_debugger_to_front(*args)

def get_current_thread(*args):
  """
  get_current_thread() -> thid_t
  """
  return _idaapi.get_current_thread(*args)

def get_debugger_event_cond(*args):
  """
  get_debugger_event_cond() -> char const *
  """
  return _idaapi.get_debugger_event_cond(*args)

def set_debugger_event_cond(*args):
  """
  set_debugger_event_cond(cond)
  """
  return _idaapi.set_debugger_event_cond(*args)

def load_debugger(*args):
  """
  load_debugger(dbgname, use_remote) -> bool
  """
  return _idaapi.load_debugger(*args)

def suspend_thread(*args):
  """
  suspend_thread(tid) -> int
  """
  return _idaapi.suspend_thread(*args)

def request_suspend_thread(*args):
  """
  request_suspend_thread(tid) -> int
  """
  return _idaapi.request_suspend_thread(*args)

def resume_thread(*args):
  """
  resume_thread(tid) -> int
  """
  return _idaapi.resume_thread(*args)

def request_resume_thread(*args):
  """
  request_resume_thread(tid) -> int
  """
  return _idaapi.request_resume_thread(*args)

def check_bpt(*args):
  """
  check_bpt(ea) -> int
  """
  return _idaapi.check_bpt(*args)

def set_process_state(*args):
  """
  set_process_state(newstate, p_thid, dbginv) -> int
  """
  return _idaapi.set_process_state(*args)

def edit_manual_regions(*args):
  """
  edit_manual_regions()
  """
  return _idaapi.edit_manual_regions(*args)

def enable_manual_regions(*args):
  """
  enable_manual_regions(enable)
  """
  return _idaapi.enable_manual_regions(*args)

def is_debugger_busy(*args):
  """
  is_debugger_busy() -> bool
  """
  return _idaapi.is_debugger_busy(*args)

def hide_all_bpts(*args):
  """
  hide_all_bpts() -> int
  """
  return _idaapi.hide_all_bpts(*args)

def add_virt_module(*args):
  """
  add_virt_module(mod) -> bool
  """
  return _idaapi.add_virt_module(*args)

def del_virt_module(*args):
  """
  del_virt_module(base) -> bool
  """
  return _idaapi.del_virt_module(*args)

def internal_ioctl(*args):
  """
  internal_ioctl(fn, buf, size, poutbuf, poutsize) -> int
  """
  return _idaapi.internal_ioctl(*args)

def read_dbg_memory(*args):
  """
  read_dbg_memory(ea, buffer, size) -> ssize_t
  """
  return _idaapi.read_dbg_memory(*args)

def write_dbg_memory(*args):
  """
  write_dbg_memory(ea, buffer, size) -> ssize_t
  """
  return _idaapi.write_dbg_memory(*args)

def get_reg_vals(*args):
  """
  get_reg_vals(tid, clsmask, values) -> int
  """
  return _idaapi.get_reg_vals(*args)

def set_reg_val(*args):
  """
    set_reg_val(regname, regval) -> bool
    set_reg_val(tid, regidx, value) -> int
    """
  return _idaapi.set_reg_val(*args)

def get_dbg_memory_info(*args):
  """
  get_dbg_memory_info(areas) -> int
  """
  return _idaapi.get_dbg_memory_info(*args)

def set_bpt_group(*args):
  """
  set_bpt_group(bpt, grp_name)
  """
  return _idaapi.set_bpt_group(*args)

def set_bptloc_group(*args):
  """
  set_bptloc_group(bptloc, grp_name) -> bool
  """
  return _idaapi.set_bptloc_group(*args)

def get_bpt_group(*args):
  """
  get_bpt_group(bptloc) -> bool
  """
  return _idaapi.get_bpt_group(*args)

def rename_bptgrp(*args):
  """
  rename_bptgrp(old_name, new_name) -> bool
  """
  return _idaapi.rename_bptgrp(*args)

def del_bptgrp(*args):
  """
  del_bptgrp(name) -> bool
  """
  return _idaapi.del_bptgrp(*args)

def get_grp_bpts(*args):
  """
  get_grp_bpts(bpts, grp_name) -> ssize_t
  """
  return _idaapi.get_grp_bpts(*args)

def get_manual_regions(*args):
  """
  get_manual_regions() -> PyObject *


  Returns the manual memory regions
  @return: list(startEA, endEA, name, sclass, sbase, bitness, perm)
  """
  return _idaapi.get_manual_regions(*args)

def dbg_is_loaded(*args):
  """
  dbg_is_loaded() -> bool


  Checks if a debugger is loaded
  @return: Boolean
  """
  return _idaapi.dbg_is_loaded(*args)

def refresh_debugger_memory(*args):
  """
  refresh_debugger_memory() -> PyObject *


  Refreshes the debugger memory
  @return: Nothing
  """
  return _idaapi.refresh_debugger_memory(*args)
class DBG_Hooks(object):
    """
    Proxy of C++ DBG_Hooks class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _idaapi.delete_DBG_Hooks
    __del__ = lambda self : None;
    def hook(self, *args):
        """
        hook(self) -> bool
        """
        return _idaapi.DBG_Hooks_hook(self, *args)

    def unhook(self, *args):
        """
        unhook(self) -> bool
        """
        return _idaapi.DBG_Hooks_unhook(self, *args)

    def dbg_process_start(self, *args):
        """
        dbg_process_start(self, pid, tid, ea, name, base, size)
        """
        return _idaapi.DBG_Hooks_dbg_process_start(self, *args)

    def dbg_process_exit(self, *args):
        """
        dbg_process_exit(self, pid, tid, ea, exit_code)
        """
        return _idaapi.DBG_Hooks_dbg_process_exit(self, *args)

    def dbg_process_attach(self, *args):
        """
        dbg_process_attach(self, pid, tid, ea, name, base, size)
        """
        return _idaapi.DBG_Hooks_dbg_process_attach(self, *args)

    def dbg_process_detach(self, *args):
        """
        dbg_process_detach(self, pid, tid, ea)
        """
        return _idaapi.DBG_Hooks_dbg_process_detach(self, *args)

    def dbg_thread_start(self, *args):
        """
        dbg_thread_start(self, pid, tid, ea)
        """
        return _idaapi.DBG_Hooks_dbg_thread_start(self, *args)

    def dbg_thread_exit(self, *args):
        """
        dbg_thread_exit(self, pid, tid, ea, exit_code)
        """
        return _idaapi.DBG_Hooks_dbg_thread_exit(self, *args)

    def dbg_library_load(self, *args):
        """
        dbg_library_load(self, pid, tid, ea, name, base, size)
        """
        return _idaapi.DBG_Hooks_dbg_library_load(self, *args)

    def dbg_library_unload(self, *args):
        """
        dbg_library_unload(self, pid, tid, ea, libname)
        """
        return _idaapi.DBG_Hooks_dbg_library_unload(self, *args)

    def dbg_information(self, *args):
        """
        dbg_information(self, pid, tid, ea, info)
        """
        return _idaapi.DBG_Hooks_dbg_information(self, *args)

    def dbg_exception(self, *args):
        """
        dbg_exception(self, pid, tid, ea, code, can_cont, exc_ea, info) -> int
        """
        return _idaapi.DBG_Hooks_dbg_exception(self, *args)

    def dbg_suspend_process(self, *args):
        """
        dbg_suspend_process(self)
        """
        return _idaapi.DBG_Hooks_dbg_suspend_process(self, *args)

    def dbg_bpt(self, *args):
        """
        dbg_bpt(self, tid, breakpoint_ea) -> int
        """
        return _idaapi.DBG_Hooks_dbg_bpt(self, *args)

    def dbg_trace(self, *args):
        """
        dbg_trace(self, tid, ip) -> int
        """
        return _idaapi.DBG_Hooks_dbg_trace(self, *args)

    def dbg_request_error(self, *args):
        """
        dbg_request_error(self, failed_command, failed_dbg_notification)
        """
        return _idaapi.DBG_Hooks_dbg_request_error(self, *args)

    def dbg_step_into(self, *args):
        """
        dbg_step_into(self)
        """
        return _idaapi.DBG_Hooks_dbg_step_into(self, *args)

    def dbg_step_over(self, *args):
        """
        dbg_step_over(self)
        """
        return _idaapi.DBG_Hooks_dbg_step_over(self, *args)

    def dbg_run_to(self, *args):
        """
        dbg_run_to(self, pid, tid, ea)
        """
        return _idaapi.DBG_Hooks_dbg_run_to(self, *args)

    def dbg_step_until_ret(self, *args):
        """
        dbg_step_until_ret(self)
        """
        return _idaapi.DBG_Hooks_dbg_step_until_ret(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> DBG_Hooks
        """
        if self.__class__ == DBG_Hooks:
            _self = None
        else:
            _self = self
        this = _idaapi.new_DBG_Hooks(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_DBG_Hooks(self)
        return weakref_proxy(self)
DBG_Hooks_swigregister = _idaapi.DBG_Hooks_swigregister
DBG_Hooks_swigregister(DBG_Hooks)


def list_bptgrps(*args):
  """
    list_bptgrps(bptgrps) -> size_t
    list_bptgrps() -> PyObject *
    """
  return _idaapi.list_bptgrps(*args)

def move_bpt_to_grp(*args):
  """
  move_bpt_to_grp(bpt, grp_name)


  Sets new group for the breakpoint
  """
  return _idaapi.move_bpt_to_grp(*args)

def internal_get_sreg_base(*args):
  """
  internal_get_sreg_base(tid, sreg_value) -> ea_t


  Get the sreg base, for the given thread.
  
  @return: The sreg base, or BADADDR on failure.
  """
  return _idaapi.internal_get_sreg_base(*args)

def idadir(*args):
  """
  idadir(subdir) -> char const *
  """
  return _idaapi.idadir(*args)

def getsysfile(*args):
  """
  getsysfile(filename, subdir) -> char *
  """
  return _idaapi.getsysfile(*args)
CFG_SUBDIR = _idaapi.CFG_SUBDIR
IDC_SUBDIR = _idaapi.IDC_SUBDIR
IDS_SUBDIR = _idaapi.IDS_SUBDIR
IDP_SUBDIR = _idaapi.IDP_SUBDIR
LDR_SUBDIR = _idaapi.LDR_SUBDIR
SIG_SUBDIR = _idaapi.SIG_SUBDIR
TIL_SUBDIR = _idaapi.TIL_SUBDIR
PLG_SUBDIR = _idaapi.PLG_SUBDIR

def get_user_idadir(*args):
  """
  get_user_idadir() -> char const *
  """
  return _idaapi.get_user_idadir(*args)

def get_special_folder(*args):
  """
  get_special_folder(csidl) -> bool
  """
  return _idaapi.get_special_folder(*args)
CSIDL_APPDATA = _idaapi.CSIDL_APPDATA
CSIDL_LOCAL_APPDATA = _idaapi.CSIDL_LOCAL_APPDATA
CSIDL_PROGRAM_FILES = _idaapi.CSIDL_PROGRAM_FILES
CSIDL_PROGRAM_FILES_COMMON = _idaapi.CSIDL_PROGRAM_FILES_COMMON
CSIDL_PROGRAM_FILESX86 = _idaapi.CSIDL_PROGRAM_FILESX86

def fopenWT(*args):
  """
  fopenWT(file) -> FILE *
  """
  return _idaapi.fopenWT(*args)

def fopenWB(*args):
  """
  fopenWB(file) -> FILE *
  """
  return _idaapi.fopenWB(*args)

def fopenRT(*args):
  """
  fopenRT(file) -> FILE *
  """
  return _idaapi.fopenRT(*args)

def fopenRB(*args):
  """
  fopenRB(file) -> FILE *
  """
  return _idaapi.fopenRB(*args)

def fopenM(*args):
  """
  fopenM(file) -> FILE *
  """
  return _idaapi.fopenM(*args)

def fopenA(*args):
  """
  fopenA(file) -> FILE *
  """
  return _idaapi.fopenA(*args)

def openR(*args):
  """
  openR(file) -> FILE *
  """
  return _idaapi.openR(*args)

def openRT(*args):
  """
  openRT(file) -> FILE *
  """
  return _idaapi.openRT(*args)

def openM(*args):
  """
  openM(file) -> FILE *
  """
  return _idaapi.openM(*args)

def ecreate(*args):
  """
  ecreate(file) -> FILE *
  """
  return _idaapi.ecreate(*args)

def ecreateT(*args):
  """
  ecreateT(file) -> FILE *
  """
  return _idaapi.ecreateT(*args)

def eclose(*args):
  """
  eclose(fp)
  """
  return _idaapi.eclose(*args)

def eseek(*args):
  """
  eseek(fp, pos)
  """
  return _idaapi.eseek(*args)

def eseek64(*args):
  """
  eseek64(fp, pos)
  """
  return _idaapi.eseek64(*args)

def qfsize(*args):
  """
  qfsize(fp) -> uint32
  """
  return _idaapi.qfsize(*args)

def qfsize64(*args):
  """
  qfsize64(fp) -> uint64
  """
  return _idaapi.qfsize64(*args)

def echsize(*args):
  """
  echsize(fp, size)
  """
  return _idaapi.echsize(*args)

def echsize64(*args):
  """
  echsize64(fp, size)
  """
  return _idaapi.echsize64(*args)

def getdspace(*args):
  """
  getdspace(path) -> uint64
  """
  return _idaapi.getdspace(*args)

def call_system(*args):
  """
  call_system(command) -> int
  """
  return _idaapi.call_system(*args)
LINPUT_NONE = _idaapi.LINPUT_NONE
LINPUT_LOCAL = _idaapi.LINPUT_LOCAL
LINPUT_RFILE = _idaapi.LINPUT_RFILE
LINPUT_PROCMEM = _idaapi.LINPUT_PROCMEM
LINPUT_GENERIC = _idaapi.LINPUT_GENERIC

def qlgetz(*args):
  """
  qlgetz(li, fpos) -> char *
  """
  return _idaapi.qlgetz(*args)

def qlgetz64(*args):
  """
  qlgetz64(li, fpos) -> char *
  """
  return _idaapi.qlgetz64(*args)

def qlsize64(*args):
  """
  qlsize64(li) -> int64
  """
  return _idaapi.qlsize64(*args)

def qlseek64(*args):
  """
  qlseek64(li, pos, whence=SEEK_SET) -> qoff64_t
  """
  return _idaapi.qlseek64(*args)

def qltell64(*args):
  """
  qltell64(li) -> int64
  """
  return _idaapi.qltell64(*args)

def open_linput(*args):
  """
  open_linput(file, remote) -> linput_t *
  """
  return _idaapi.open_linput(*args)

def close_linput(*args):
  """
  close_linput(li)
  """
  return _idaapi.close_linput(*args)
class generic_linput_t(object):
    """
    Proxy of C++ generic_linput_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    filesize = _swig_property(_idaapi.generic_linput_t_filesize_get, _idaapi.generic_linput_t_filesize_set)
    blocksize = _swig_property(_idaapi.generic_linput_t_blocksize_get, _idaapi.generic_linput_t_blocksize_set)
    def read(self, *args):
        """
        read(self, off, buffer, nbytes) -> ssize_t
        """
        return _idaapi.generic_linput_t_read(self, *args)

    __swig_destroy__ = _idaapi.delete_generic_linput_t
    __del__ = lambda self : None;
generic_linput_t_swigregister = _idaapi.generic_linput_t_swigregister
generic_linput_t_swigregister(generic_linput_t)

class generic_linput64_t(object):
    """
    Proxy of C++ generic_linput64_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    filesize = _swig_property(_idaapi.generic_linput64_t_filesize_get, _idaapi.generic_linput64_t_filesize_set)
    blocksize = _swig_property(_idaapi.generic_linput64_t_blocksize_get, _idaapi.generic_linput64_t_blocksize_set)
    def read64(self, *args):
        """
        read64(self, off, buffer, nbytes) -> ssize_t
        """
        return _idaapi.generic_linput64_t_read64(self, *args)

    __swig_destroy__ = _idaapi.delete_generic_linput64_t
    __del__ = lambda self : None;
generic_linput64_t_swigregister = _idaapi.generic_linput64_t_swigregister
generic_linput64_t_swigregister(generic_linput64_t)


def create_generic_linput(*args):
  """
  create_generic_linput(gl) -> linput_t *
  """
  return _idaapi.create_generic_linput(*args)

def create_generic_linput64(*args):
  """
  create_generic_linput64(gl) -> linput_t *
  """
  return _idaapi.create_generic_linput64(*args)

def create_bytearray_linput(*args):
  """
  create_bytearray_linput(start, size) -> linput_t *
  """
  return _idaapi.create_bytearray_linput(*args)

def create_memory_linput(*args):
  """
  create_memory_linput(start, size) -> linput_t *
  """
  return _idaapi.create_memory_linput(*args)

def get_linput_type(*args):
  """
  get_linput_type(li) -> linput_type_t
  """
  return _idaapi.get_linput_type(*args)
class linput_buffer_t(object):
    """
    Proxy of C++ linput_buffer_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, linput, size=0) -> linput_buffer_t
        """
        this = _idaapi.new_linput_buffer_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self, *args):
        """
        read(self, buf, n) -> ssize_t
        """
        return _idaapi.linput_buffer_t_read(self, *args)

    def eof(self, *args):
        """
        eof(self) -> bool
        """
        return _idaapi.linput_buffer_t_eof(self, *args)

    __swig_destroy__ = _idaapi.delete_linput_buffer_t
    __del__ = lambda self : None;
linput_buffer_t_swigregister = _idaapi.linput_buffer_t_swigregister
linput_buffer_t_swigregister(linput_buffer_t)

class loader_input_t(object):
    """
    Proxy of C++ loader_input_t class


    A helper class to work with linput_t related functions.
    This class is also used by file loaders scripts.
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __idc_cvt_id__ = _swig_property(_idaapi.loader_input_t___idc_cvt_id___get, _idaapi.loader_input_t___idc_cvt_id___set)
    def __init__(self, *args):
        """
        __init__(self, pycobject=None) -> loader_input_t


        Closes the file
        """
        this = _idaapi.new_loader_input_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def close(self, *args):
        """
        close(self)
        """
        return _idaapi.loader_input_t_close(self, *args)

    __swig_destroy__ = _idaapi.delete_loader_input_t
    __del__ = lambda self : None;
    def open(self, *args):
        """
        open(self, filename, remote=False) -> bool


        Opens a file (or a remote file)
        @return: Boolean
        """
        return _idaapi.loader_input_t_open(self, *args)

    def set_linput(self, *args):
        """
        set_linput(self, linput)


        Links the current loader_input_t instance to a linput_t instance
        """
        return _idaapi.loader_input_t_set_linput(self, *args)

    def from_linput(*args):
        """
        from_linput(linput) -> loader_input_t
        """
        return _idaapi.loader_input_t_from_linput(*args)

    from_linput = staticmethod(from_linput)
    def from_cobject(*args):
        """
        from_cobject(pycobject) -> loader_input_t
        """
        return _idaapi.loader_input_t_from_cobject(*args)

    from_cobject = staticmethod(from_cobject)
    def from_fp(*args):
        """
        from_fp(fp) -> loader_input_t


        A static method to construct an instance from a FILE*
        """
        return _idaapi.loader_input_t_from_fp(*args)

    from_fp = staticmethod(from_fp)
    def get_linput(self, *args):
        """
        get_linput(self) -> linput_t *
        """
        return _idaapi.loader_input_t_get_linput(self, *args)

    def open_memory(self, *args):
        """
        open_memory(self, start, size=0) -> bool


        Create a linput for process memory (By internally calling idaapi.create_memory_linput())
        This linput will use dbg->read_memory() to read data
        @param start: starting address of the input
        @param size: size of the memory area to represent as linput
                    if unknown, may be passed as 0
        """
        return _idaapi.loader_input_t_open_memory(self, *args)

    def seek(self, *args):
        """
        seek(self, pos, whence=SEEK_SET) -> int32


        Set input source position
        @return: the new position (not 0 as fseek!)
        """
        return _idaapi.loader_input_t_seek(self, *args)

    def tell(self, *args):
        """
        tell(self) -> int32


        Returns the current position
        """
        return _idaapi.loader_input_t_tell(self, *args)

    def getz(self, *args):
        """
        getz(self, sz, fpos=-1) -> PyObject *


        Returns a zero terminated string at the given position
        @param sz: maximum size of the string
        @param fpos: if != -1 then seek will be performed before reading
        @return: The string or None on failure.
        """
        return _idaapi.loader_input_t_getz(self, *args)

    def gets(self, *args):
        """
        gets(self, len) -> PyObject *


        Reads a line from the input file. Returns the read line or None
        """
        return _idaapi.loader_input_t_gets(self, *args)

    def read(self, *args):
        """
        read(self, size) -> PyObject *


        Reads from the file. Returns the buffer or None
        """
        return _idaapi.loader_input_t_read(self, *args)

    def opened(self, *args):
        """
        opened(self) -> bool


        Checks if the file is opened or not
        """
        return _idaapi.loader_input_t_opened(self, *args)

    def readbytes(self, *args):
        """
        readbytes(self, size, big_endian) -> PyObject *


        Similar to read() but it respect the endianness
        """
        return _idaapi.loader_input_t_readbytes(self, *args)

    def file2base(self, *args):
        """
        file2base(self, pos, ea1, ea2, patchable) -> int


        Load portion of file into the database
        This function will include (ea1..ea2) into the addressing space of the
        program (make it enabled)
        @param li: pointer ot input source
        @param pos: position in the file
        @param (ea1..ea2): range of destination linear addresses
        @param patchable: should the kernel remember correspondance of
                          file offsets to linear addresses.
        @return: 1-ok,0-read error, a warning is displayed
        """
        return _idaapi.loader_input_t_file2base(self, *args)

    def size(self, *args):
        """
        size(self) -> int32
        """
        return _idaapi.loader_input_t_size(self, *args)

    def filename(self, *args):
        """
        filename(self) -> PyObject *
        """
        return _idaapi.loader_input_t_filename(self, *args)

    def get_char(self, *args):
        """
        get_char(self) -> PyObject *


        Reads a single character from the file. Returns None if EOF or the read character
        """
        return _idaapi.loader_input_t_get_char(self, *args)

loader_input_t_swigregister = _idaapi.loader_input_t_swigregister
loader_input_t_swigregister(loader_input_t)

def loader_input_t_from_linput(*args):
  """
  loader_input_t_from_linput(linput) -> loader_input_t
  """
  return _idaapi.loader_input_t_from_linput(*args)

def loader_input_t_from_cobject(*args):
  """
  loader_input_t_from_cobject(pycobject) -> loader_input_t
  """
  return _idaapi.loader_input_t_from_cobject(*args)

def loader_input_t_from_fp(*args):
  """
  loader_input_t_from_fp(fp) -> loader_input_t
  """
  return _idaapi.loader_input_t_from_fp(*args)


def enumerate_files(*args):
  """
  enumerate_files(path, fname, callback) -> PyObject *


  Enumerate files in the specified directory while the callback returns 0.
  @param path: directory to enumerate files in
  @param fname: mask of file names to enumerate
  @param callback: a callable object that takes the filename as
                   its first argument and it returns 0 to continue
                   enumeration or non-zero to stop enumeration.
  @return:
      None in case of script errors
      tuple(code, fname) : If the callback returns non-zero
  """
  return _idaapi.enumerate_files(*args)
#<pycode(py_diskio)>
def enumerate_system_files(subdir, fname, callback):
    """
    Similar to enumerate_files() however it searches inside IDA directory or its subdirectories
    """
    return enumerate_files(idadir(subdir), fname, callback)
#</pycode(py_diskio)>


def get_entry_qty(*args):
  """
  get_entry_qty() -> size_t
  """
  return _idaapi.get_entry_qty(*args)

def add_entry(*args):
  """
  add_entry(ord, ea, name, makecode) -> bool
  """
  return _idaapi.add_entry(*args)

def get_entry_ordinal(*args):
  """
  get_entry_ordinal(idx) -> uval_t
  """
  return _idaapi.get_entry_ordinal(*args)

def get_entry(*args):
  """
  get_entry(ord) -> ea_t
  """
  return _idaapi.get_entry(*args)

def get_entry_name(*args):
  """
  get_entry_name(ord) -> ssize_t
  """
  return _idaapi.get_entry_name(*args)

def rename_entry(*args):
  """
  rename_entry(ord, name) -> bool
  """
  return _idaapi.rename_entry(*args)
ENUM_FLAGS_FROMTIL = _idaapi.ENUM_FLAGS_FROMTIL
ENUM_FLAGS_WIDTH = _idaapi.ENUM_FLAGS_WIDTH
ENUM_FLAGS_GHOST = _idaapi.ENUM_FLAGS_GHOST

def get_enum_qty(*args):
  """
  get_enum_qty() -> size_t
  """
  return _idaapi.get_enum_qty(*args)

def getn_enum(*args):
  """
  getn_enum(n) -> enum_t
  """
  return _idaapi.getn_enum(*args)

def get_enum_idx(*args):
  """
  get_enum_idx(id) -> uval_t
  """
  return _idaapi.get_enum_idx(*args)

def get_enum(*args):
  """
  get_enum(name) -> enum_t
  """
  return _idaapi.get_enum(*args)

def is_bf(*args):
  """
  is_bf(id) -> bool
  """
  return _idaapi.is_bf(*args)

def is_enum_hidden(*args):
  """
  is_enum_hidden(id) -> bool
  """
  return _idaapi.is_enum_hidden(*args)

def set_enum_hidden(*args):
  """
  set_enum_hidden(id, hidden) -> bool
  """
  return _idaapi.set_enum_hidden(*args)

def is_enum_fromtil(*args):
  """
  is_enum_fromtil(id) -> bool
  """
  return _idaapi.is_enum_fromtil(*args)

def set_enum_fromtil(*args):
  """
  set_enum_fromtil(id, fromtil) -> bool
  """
  return _idaapi.set_enum_fromtil(*args)

def is_ghost_enum(*args):
  """
  is_ghost_enum(id) -> bool
  """
  return _idaapi.is_ghost_enum(*args)

def set_enum_ghost(*args):
  """
  set_enum_ghost(id, ghost) -> bool
  """
  return _idaapi.set_enum_ghost(*args)

def get_enum_name(*args):
  """
  get_enum_name(id) -> ssize_t
  """
  return _idaapi.get_enum_name(*args)

def get_enum_width(*args):
  """
  get_enum_width(id) -> size_t
  """
  return _idaapi.get_enum_width(*args)

def set_enum_width(*args):
  """
  set_enum_width(id, width) -> bool
  """
  return _idaapi.set_enum_width(*args)

def get_enum_cmt(*args):
  """
  get_enum_cmt(id, repeatable) -> ssize_t
  """
  return _idaapi.get_enum_cmt(*args)

def get_enum_size(*args):
  """
  get_enum_size(id) -> size_t
  """
  return _idaapi.get_enum_size(*args)

def get_enum_flag(*args):
  """
  get_enum_flag(id) -> flags_t
  """
  return _idaapi.get_enum_flag(*args)

def get_enum_member_by_name(*args):
  """
  get_enum_member_by_name(name) -> const_t
  """
  return _idaapi.get_enum_member_by_name(*args)

def get_enum_member_value(*args):
  """
  get_enum_member_value(id) -> uval_t
  """
  return _idaapi.get_enum_member_value(*args)

def get_enum_member_enum(*args):
  """
  get_enum_member_enum(id) -> enum_t
  """
  return _idaapi.get_enum_member_enum(*args)

def get_enum_member_bmask(*args):
  """
  get_enum_member_bmask(id) -> bmask_t
  """
  return _idaapi.get_enum_member_bmask(*args)

def get_enum_member(*args):
  """
  get_enum_member(id, value, serial, mask) -> const_t
  """
  return _idaapi.get_enum_member(*args)

def get_first_bmask(*args):
  """
  get_first_bmask(id) -> bmask_t
  """
  return _idaapi.get_first_bmask(*args)

def get_last_bmask(*args):
  """
  get_last_bmask(id) -> bmask_t
  """
  return _idaapi.get_last_bmask(*args)

def get_next_bmask(*args):
  """
  get_next_bmask(id, bmask) -> bmask_t
  """
  return _idaapi.get_next_bmask(*args)

def get_prev_bmask(*args):
  """
  get_prev_bmask(id, bmask) -> bmask_t
  """
  return _idaapi.get_prev_bmask(*args)

def get_first_enum_member(*args):
  """
  get_first_enum_member(id, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_first_enum_member(*args)

def get_last_enum_member(*args):
  """
  get_last_enum_member(id, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_last_enum_member(*args)

def get_next_enum_member(*args):
  """
  get_next_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_next_enum_member(*args)

def get_prev_enum_member(*args):
  """
  get_prev_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_prev_enum_member(*args)

def get_enum_member_name(*args):
  """
  get_enum_member_name(id) -> ssize_t
  """
  return _idaapi.get_enum_member_name(*args)

def get_enum_member_cmt(*args):
  """
  get_enum_member_cmt(id, repeatable) -> ssize_t
  """
  return _idaapi.get_enum_member_cmt(*args)

def get_first_serial_enum_member(*args):
  """
  get_first_serial_enum_member(id, value, bmask) -> const_t
  """
  return _idaapi.get_first_serial_enum_member(*args)

def get_last_serial_enum_member(*args):
  """
  get_last_serial_enum_member(id, value, bmask) -> const_t
  """
  return _idaapi.get_last_serial_enum_member(*args)

def get_next_serial_enum_member(*args):
  """
  get_next_serial_enum_member(first_cid, in_out_serial) -> const_t
  """
  return _idaapi.get_next_serial_enum_member(*args)

def get_prev_serial_enum_member(*args):
  """
  get_prev_serial_enum_member(first_cid, in_out_serial) -> const_t
  """
  return _idaapi.get_prev_serial_enum_member(*args)
class enum_member_visitor_t(object):
    """
    Proxy of C++ enum_member_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_enum_member(self, *args):
        """
        visit_enum_member(self, cid, value) -> int
        """
        return _idaapi.enum_member_visitor_t_visit_enum_member(self, *args)

    __swig_destroy__ = _idaapi.delete_enum_member_visitor_t
    __del__ = lambda self : None;
enum_member_visitor_t_swigregister = _idaapi.enum_member_visitor_t_swigregister
enum_member_visitor_t_swigregister(enum_member_visitor_t)
MAX_ENUM_SERIAL = cvar.MAX_ENUM_SERIAL


def for_all_enum_members(*args):
  """
  for_all_enum_members(id, cv) -> int
  """
  return _idaapi.for_all_enum_members(*args)

def get_enum_member_serial(*args):
  """
  get_enum_member_serial(cid) -> uchar
  """
  return _idaapi.get_enum_member_serial(*args)

def get_enum_type_ordinal(*args):
  """
  get_enum_type_ordinal(id) -> int32
  """
  return _idaapi.get_enum_type_ordinal(*args)

def set_enum_type_ordinal(*args):
  """
  set_enum_type_ordinal(id, ord)
  """
  return _idaapi.set_enum_type_ordinal(*args)

def add_enum(*args):
  """
  add_enum(idx, name, flag) -> enum_t
  """
  return _idaapi.add_enum(*args)

def del_enum(*args):
  """
  del_enum(id)
  """
  return _idaapi.del_enum(*args)

def set_enum_idx(*args):
  """
  set_enum_idx(id, idx) -> bool
  """
  return _idaapi.set_enum_idx(*args)

def set_enum_bf(*args):
  """
  set_enum_bf(id, bf) -> bool
  """
  return _idaapi.set_enum_bf(*args)

def set_enum_name(*args):
  """
  set_enum_name(id, name) -> bool
  """
  return _idaapi.set_enum_name(*args)

def set_enum_cmt(*args):
  """
  set_enum_cmt(id, cmt, repeatable) -> bool
  """
  return _idaapi.set_enum_cmt(*args)

def add_enum_member(*args):
  """
  add_enum_member(id, name, value, bmask=(bmask_t(-1))) -> int
  """
  return _idaapi.add_enum_member(*args)
ENUM_MEMBER_ERROR_NAME = _idaapi.ENUM_MEMBER_ERROR_NAME
ENUM_MEMBER_ERROR_VALUE = _idaapi.ENUM_MEMBER_ERROR_VALUE
ENUM_MEMBER_ERROR_ENUM = _idaapi.ENUM_MEMBER_ERROR_ENUM
ENUM_MEMBER_ERROR_MASK = _idaapi.ENUM_MEMBER_ERROR_MASK
ENUM_MEMBER_ERROR_ILLV = _idaapi.ENUM_MEMBER_ERROR_ILLV

def del_enum_member(*args):
  """
  del_enum_member(id, value, serial, bmask) -> bool
  """
  return _idaapi.del_enum_member(*args)

def set_enum_member_name(*args):
  """
  set_enum_member_name(id, name) -> bool
  """
  return _idaapi.set_enum_member_name(*args)

def set_enum_member_cmt(*args):
  """
  set_enum_member_cmt(id, cmt, repeatable) -> bool
  """
  return _idaapi.set_enum_member_cmt(*args)

def is_one_bit_mask(*args):
  """
  is_one_bit_mask(mask) -> bool
  """
  return _idaapi.is_one_bit_mask(*args)

def get_bmask_node(*args):
  """
  get_bmask_node(id, bmask) -> netnode
  """
  return _idaapi.get_bmask_node(*args)

def set_bmask_name(*args):
  """
  set_bmask_name(id, bmask, name) -> bool
  """
  return _idaapi.set_bmask_name(*args)

def get_bmask_name(*args):
  """
  get_bmask_name(id, bmask) -> ssize_t
  """
  return _idaapi.get_bmask_name(*args)

def set_bmask_cmt(*args):
  """
  set_bmask_cmt(id, bmask, cmt, repeatable) -> bool
  """
  return _idaapi.set_bmask_cmt(*args)

def get_bmask_cmt(*args):
  """
  get_bmask_cmt(id, bmask, repeatable) -> ssize_t
  """
  return _idaapi.get_bmask_cmt(*args)

def add_const(*args):
  """
  add_const(id, name, value, bmask=(bmask_t(-1))) -> int
  """
  return _idaapi.add_const(*args)
CONST_ERROR_NAME = _idaapi.CONST_ERROR_NAME
CONST_ERROR_VALUE = _idaapi.CONST_ERROR_VALUE
CONST_ERROR_ENUM = _idaapi.CONST_ERROR_ENUM
CONST_ERROR_MASK = _idaapi.CONST_ERROR_MASK
CONST_ERROR_ILLV = _idaapi.CONST_ERROR_ILLV

def del_const(*args):
  """
  del_const(id, value, serial, bmask) -> bool
  """
  return _idaapi.del_const(*args)

def set_const_name(*args):
  """
  set_const_name(id, name) -> bool
  """
  return _idaapi.set_const_name(*args)

def set_const_cmt(*args):
  """
  set_const_cmt(id, cmt, repeatable) -> bool
  """
  return _idaapi.set_const_cmt(*args)

def get_const_by_name(*args):
  """
  get_const_by_name(name) -> const_t
  """
  return _idaapi.get_const_by_name(*args)

def get_const_value(*args):
  """
  get_const_value(id) -> uval_t
  """
  return _idaapi.get_const_value(*args)

def get_const_enum(*args):
  """
  get_const_enum(id) -> enum_t
  """
  return _idaapi.get_const_enum(*args)

def get_const_bmask(*args):
  """
  get_const_bmask(id) -> bmask_t
  """
  return _idaapi.get_const_bmask(*args)

def get_const(*args):
  """
  get_const(id, value, serial, mask) -> const_t
  """
  return _idaapi.get_const(*args)

def get_first_const(*args):
  """
  get_first_const(id, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_first_const(*args)

def get_last_const(*args):
  """
  get_last_const(id, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_last_const(*args)

def get_next_const(*args):
  """
  get_next_const(id, value, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_next_const(*args)

def get_prev_const(*args):
  """
  get_prev_const(id, value, bmask=(bmask_t(-1))) -> uval_t
  """
  return _idaapi.get_prev_const(*args)

def get_const_name(*args):
  """
  get_const_name(id) -> ssize_t
  """
  return _idaapi.get_const_name(*args)

def get_const_cmt(*args):
  """
  get_const_cmt(id, repeatable) -> ssize_t
  """
  return _idaapi.get_const_cmt(*args)

def get_first_serial_const(*args):
  """
  get_first_serial_const(id, value, bmask) -> const_t
  """
  return _idaapi.get_first_serial_const(*args)

def get_last_serial_const(*args):
  """
  get_last_serial_const(id, value, bmask) -> const_t
  """
  return _idaapi.get_last_serial_const(*args)

def get_next_serial_const(*args):
  """
  get_next_serial_const(first_cid) -> const_t
  """
  return _idaapi.get_next_serial_const(*args)

def get_prev_serial_const(*args):
  """
  get_prev_serial_const(first_cid) -> const_t
  """
  return _idaapi.get_prev_serial_const(*args)
class const_visitor_t(object):
    """
    Proxy of C++ const_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_const(self, *args):
        """
        visit_const(self, cid, value) -> int
        """
        return _idaapi.const_visitor_t_visit_const(self, *args)

    __swig_destroy__ = _idaapi.delete_const_visitor_t
    __del__ = lambda self : None;
const_visitor_t_swigregister = _idaapi.const_visitor_t_swigregister
const_visitor_t_swigregister(const_visitor_t)


def for_all_consts(*args):
  """
  for_all_consts(id, cv) -> int
  """
  return _idaapi.for_all_consts(*args)

def get_const_serial(*args):
  """
  get_const_serial(cid) -> uchar
  """
  return _idaapi.get_const_serial(*args)

def py_get_call_idc_func(*args):
  """
  py_get_call_idc_func() -> size_t
  """
  return _idaapi.py_get_call_idc_func(*args)

def pyw_register_idc_func(*args):
  """
  pyw_register_idc_func(name, args, py_fp) -> size_t
  """
  return _idaapi.pyw_register_idc_func(*args)

def pyw_unregister_idc_func(*args):
  """
  pyw_unregister_idc_func(ctxptr) -> bool
  """
  return _idaapi.pyw_unregister_idc_func(*args)

def py_set_idc_func_ex(*args):
  """
  py_set_idc_func_ex(name, fp_ptr, args, flags) -> bool
  """
  return _idaapi.py_set_idc_func_ex(*args)

def CompileEx(*args):
  """
  CompileEx(file, del_macros) -> bool
  """
  return _idaapi.CompileEx(*args)

def Compile(*args):
  """
  Compile(file) -> bool
  """
  return _idaapi.Compile(*args)

def calcexpr(*args):
  """
  calcexpr(where, line, rv) -> bool
  """
  return _idaapi.calcexpr(*args)

def calc_idc_expr(*args):
  """
  calc_idc_expr(where, line, rv) -> bool
  """
  return _idaapi.calc_idc_expr(*args)

def CompileLine(*args):
  """
  CompileLine(line) -> bool
  """
  return _idaapi.CompileLine(*args)
IDC_LANG_EXT = _idaapi.IDC_LANG_EXT

def VarInt64(*args):
  """
  VarInt64(v) -> error_t
  """
  return _idaapi.VarInt64(*args)

def VarString2(*args):
  """
  VarString2(v) -> error_t
  """
  return _idaapi.VarString2(*args)

def VarObject(*args):
  """
  VarObject(v, icls=None) -> error_t
  """
  return _idaapi.VarObject(*args)

def VarCopy(*args):
  """
  VarCopy(dst, src) -> error_t
  """
  return _idaapi.VarCopy(*args)

def VarSwap(*args):
  """
  VarSwap(v1, v2)
  """
  return _idaapi.VarSwap(*args)

def VarGetClassName(*args):
  """
  VarGetClassName(obj, name) -> error_t
  """
  return _idaapi.VarGetClassName(*args)

def VarGetAttr(*args):
  """
  VarGetAttr(obj, attr, res, may_use_getattr=False) -> error_t
  """
  return _idaapi.VarGetAttr(*args)

def VarSetAttr(*args):
  """
  VarSetAttr(obj, attr, value, may_use_setattr=False) -> error_t
  """
  return _idaapi.VarSetAttr(*args)

def VarDelAttr(*args):
  """
  VarDelAttr(obj, attr) -> error_t
  """
  return _idaapi.VarDelAttr(*args)

def VarFirstAttr(*args):
  """
  VarFirstAttr(obj) -> char const *
  """
  return _idaapi.VarFirstAttr(*args)

def VarLastAttr(*args):
  """
  VarLastAttr(obj) -> char const *
  """
  return _idaapi.VarLastAttr(*args)

def VarNextAttr(*args):
  """
  VarNextAttr(obj, attr) -> char const *
  """
  return _idaapi.VarNextAttr(*args)

def VarPrevAttr(*args):
  """
  VarPrevAttr(obj, attr) -> char const *
  """
  return _idaapi.VarPrevAttr(*args)

def VarAssign(*args):
  """
  VarAssign(dst, src) -> error_t
  """
  return _idaapi.VarAssign(*args)

def VarMove(*args):
  """
  VarMove(dst, src) -> error_t
  """
  return _idaapi.VarMove(*args)

def VarPrint(*args):
  """
  VarPrint(v, name=None, indent=0) -> bool
  """
  return _idaapi.VarPrint(*args)

def VarGetSlice(*args):
  """
  VarGetSlice(v, i1, i2, res, flags=0) -> error_t
  """
  return _idaapi.VarGetSlice(*args)
VARSLICE_SINGLE = _idaapi.VARSLICE_SINGLE

def VarSetSlice(*args):
  """
  VarSetSlice(v, i1, i2, _in, flags=0) -> error_t
  """
  return _idaapi.VarSetSlice(*args)

def add_idc_class(*args):
  """
  add_idc_class(name, super=None) -> idc_class_t *
  """
  return _idaapi.add_idc_class(*args)

def find_idc_class(*args):
  """
  find_idc_class(name) -> idc_class_t *
  """
  return _idaapi.find_idc_class(*args)

def VarDeref(*args):
  """
  VarDeref(v, vref_flags) -> idc_value_t
  """
  return _idaapi.VarDeref(*args)
VREF_LOOP = _idaapi.VREF_LOOP
VREF_ONCE = _idaapi.VREF_ONCE
VREF_COPY = _idaapi.VREF_COPY

def VarRef(*args):
  """
  VarRef(ref, v) -> bool
  """
  return _idaapi.VarRef(*args)

def add_idc_gvar(*args):
  """
  add_idc_gvar(name) -> idc_value_t
  """
  return _idaapi.add_idc_gvar(*args)

def find_idc_gvar(*args):
  """
  find_idc_gvar(name) -> idc_value_t
  """
  return _idaapi.find_idc_gvar(*args)
class idc_value_t(object):
    """
    Proxy of C++ idc_value_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    vtype = _swig_property(_idaapi.idc_value_t_vtype_get, _idaapi.idc_value_t_vtype_set)
    str = _swig_property(_idaapi.idc_value_t_str_get, _idaapi.idc_value_t_str_set)
    num = _swig_property(_idaapi.idc_value_t_num_get, _idaapi.idc_value_t_num_set)
    e = _swig_property(_idaapi.idc_value_t_e_get, _idaapi.idc_value_t_e_set)
    obj = _swig_property(_idaapi.idc_value_t_obj_get, _idaapi.idc_value_t_obj_set)
    funcidx = _swig_property(_idaapi.idc_value_t_funcidx_get, _idaapi.idc_value_t_funcidx_set)
    pvoid = _swig_property(_idaapi.idc_value_t_pvoid_get, _idaapi.idc_value_t_pvoid_set)
    i64 = _swig_property(_idaapi.idc_value_t_i64_get, _idaapi.idc_value_t_i64_set)
    reserve = _swig_property(_idaapi.idc_value_t_reserve_get, _idaapi.idc_value_t_reserve_set)
    def __init__(self, *args):
        """
        __init__(self, n=0) -> idc_value_t
        __init__(self, r) -> idc_value_t
        __init__(self, _str) -> idc_value_t
        __init__(self, _str) -> idc_value_t
        """
        this = _idaapi.new_idc_value_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idc_value_t
    __del__ = lambda self : None;
    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.idc_value_t_clear(self, *args)

    def qstr(self, *args):
        """
        qstr(self) -> qstring
        qstr(self) -> qstring const &
        """
        return _idaapi.idc_value_t_qstr(self, *args)

    def c_str(self, *args):
        """
        c_str(self) -> char const *
        """
        return _idaapi.idc_value_t_c_str(self, *args)

    def u_str(self, *args):
        """
        u_str(self) -> uchar const *
        """
        return _idaapi.idc_value_t_u_str(self, *args)

    def swap(self, *args):
        """
        swap(self, v)
        """
        return _idaapi.idc_value_t_swap(self, *args)

    def is_zero(self, *args):
        """
        is_zero(self) -> bool
        """
        return _idaapi.idc_value_t_is_zero(self, *args)

    def is_integral(self, *args):
        """
        is_integral(self) -> bool
        """
        return _idaapi.idc_value_t_is_integral(self, *args)

    def is_convertible(self, *args):
        """
        is_convertible(self) -> bool
        """
        return _idaapi.idc_value_t_is_convertible(self, *args)

    def _create_empty_string(self, *args):
        """
        _create_empty_string(self)
        """
        return _idaapi.idc_value_t__create_empty_string(self, *args)

    def _set_string(self, *args):
        """
        _set_string(self, _str)
        _set_string(self, _str, len)
        _set_string(self, _str)
        """
        return _idaapi.idc_value_t__set_string(self, *args)

    def _set_long(self, *args):
        """
        _set_long(self, v)
        """
        return _idaapi.idc_value_t__set_long(self, *args)

    def create_empty_string(self, *args):
        """
        create_empty_string(self)
        """
        return _idaapi.idc_value_t_create_empty_string(self, *args)

    def set_string(self, *args):
        """
        set_string(self, _str, len)
        set_string(self, _str)
        set_string(self, _str)
        """
        return _idaapi.idc_value_t_set_string(self, *args)

    def set_long(self, *args):
        """
        set_long(self, v)
        """
        return _idaapi.idc_value_t_set_long(self, *args)

    def set_pvoid(self, *args):
        """
        set_pvoid(self, p)
        """
        return _idaapi.idc_value_t_set_pvoid(self, *args)

    def set_int64(self, *args):
        """
        set_int64(self, v)
        """
        return _idaapi.idc_value_t_set_int64(self, *args)

    def set_float(self, *args):
        """
        set_float(self, f)
        """
        return _idaapi.idc_value_t_set_float(self, *args)

idc_value_t_swigregister = _idaapi.idc_value_t_swigregister
idc_value_t_swigregister(idc_value_t)
VT_STR = _idaapi.VT_STR
VT_LONG = _idaapi.VT_LONG
VT_FLOAT = _idaapi.VT_FLOAT
VT_WILD = _idaapi.VT_WILD
VT_OBJ = _idaapi.VT_OBJ
VT_FUNC = _idaapi.VT_FUNC
VT_STR2 = _idaapi.VT_STR2
VT_PVOID = _idaapi.VT_PVOID
VT_INT64 = _idaapi.VT_INT64
VT_REF = _idaapi.VT_REF

class idc_global_t(object):
    """
    Proxy of C++ idc_global_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.idc_global_t_name_get, _idaapi.idc_global_t_name_set)
    value = _swig_property(_idaapi.idc_global_t_value_get, _idaapi.idc_global_t_value_set)
    def __init__(self, *args):
        """
        __init__(self) -> idc_global_t
        __init__(self, n) -> idc_global_t
        """
        this = _idaapi.new_idc_global_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idc_global_t
    __del__ = lambda self : None;
idc_global_t_swigregister = _idaapi.idc_global_t_swigregister
idc_global_t_swigregister(idc_global_t)

eExecThrow = _idaapi.eExecThrow

def install_extlang(*args):
  """
  install_extlang(el) -> bool
  """
  return _idaapi.install_extlang(*args)

def remove_extlang(*args):
  """
  remove_extlang(el) -> bool
  """
  return _idaapi.remove_extlang(*args)

def select_extlang(*args):
  """
  select_extlang(el) -> bool
  """
  return _idaapi.select_extlang(*args)

def get_extlang_fileext(*args):
  """
  get_extlang_fileext() -> char const *
  """
  return _idaapi.get_extlang_fileext(*args)

def find_extlang_by_ext(*args):
  """
  find_extlang_by_ext(ext) -> extlang_t const *
  """
  return _idaapi.find_extlang_by_ext(*args)

def find_extlang_by_name(*args):
  """
  find_extlang_by_name(name) -> extlang_t const *
  """
  return _idaapi.find_extlang_by_name(*args)

def get_idcpath(*args):
  """
  get_idcpath() -> char const *
  """
  return _idaapi.get_idcpath(*args)

def set_header_path(*args):
  """
  set_header_path(path, add) -> bool
  """
  return _idaapi.set_header_path(*args)

def get_idc_filename(*args):
  """
  get_idc_filename(file) -> char *
  """
  return _idaapi.get_idc_filename(*args)

def dosysfile(*args):
  """
  dosysfile(complain_if_no_file, file) -> bool
  """
  return _idaapi.dosysfile(*args)

def execute(*args):
  """
  execute(line) -> bool
  """
  return _idaapi.execute(*args)
CPL_DEL_MACROS = _idaapi.CPL_DEL_MACROS
CPL_USE_LABELS = _idaapi.CPL_USE_LABELS
CPL_ONLY_SAFE = _idaapi.CPL_ONLY_SAFE

def extlang_compile_file_exists(*args):
  """
  extlang_compile_file_exists(el=None) -> bool
  """
  return _idaapi.extlang_compile_file_exists(*args)

def compile_script_file(*args):
  """
  compile_script_file(file) -> bool
  """
  return _idaapi.compile_script_file(*args)

def extlang_unload_procmod(*args):
  """
  extlang_unload_procmod(file) -> bool
  """
  return _idaapi.extlang_unload_procmod(*args)

def compile_script_func(*args):
  """
  compile_script_func(name, current_ea, expr) -> bool
  """
  return _idaapi.compile_script_func(*args)

def extlang_set_attr_exists(*args):
  """
  extlang_set_attr_exists() -> bool
  """
  return _idaapi.extlang_set_attr_exists(*args)

def call_idc_method(*args):
  """
  call_idc_method(obj, name, nargs, args, result) -> bool
  """
  return _idaapi.call_idc_method(*args)

def extlang_call_method_exists(*args):
  """
  extlang_call_method_exists() -> bool
  """
  return _idaapi.extlang_call_method_exists(*args)

def call_script_method(*args):
  """
  call_script_method(obj, name, nargs, args, result) -> bool
  """
  return _idaapi.call_script_method(*args)

def extlang_run_statements_exists(*args):
  """
  extlang_run_statements_exists(elang=None) -> bool
  """
  return _idaapi.extlang_run_statements_exists(*args)

def run_statements(*args):
  """
  run_statements(str, elang=None) -> bool
  """
  return _idaapi.run_statements(*args)
#<pycode(py_expr)>
try:
    import types
    import ctypes
    # Callback for IDC func callback (On Windows, we use stdcall)
    # typedef error_t idaapi idc_func_t(idc_value_t *argv,idc_value_t *r);
    _IDCFUNC_CB_T = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)

    # A trampoline function that is called from idcfunc_t that will
    # call the Python callback with the argv and r properly serialized to python
    call_idc_func__ = ctypes.CFUNCTYPE(ctypes.c_long)(_idaapi.py_get_call_idc_func())
except:
    def call_idc_func__(*args):
        warning("IDC extensions need ctypes library in order to work")
        return 0
    try:
        _IDCFUNC_CB_T = CFUNCTYPE(c_int, c_void_p, c_void_p)
    except:
        _IDCFUNC_CB_T = None


# --------------------------------------------------------------------------
EXTFUN_BASE  = 0x0001
"""
requires open database
"""
EXTFUN_NORET = 0x0002
"""
does not return. the interpreter may clean up its state before calling it.
"""
EXTFUN_SAFE  = 0x0004
"""
thread safe function. may be called
"""

# --------------------------------------------------------------------------
class _IdcFunction(object):
    """
    Internal class that calls pyw_call_idc_func() with a context
    """
    def __init__(self, ctxptr):
        self.ctxptr = ctxptr
        # Take a reference to the ctypes callback
        # (note: this will create a circular reference)
        self.cb   = _IDCFUNC_CB_T(self)

    fp_ptr = property(lambda self: ctypes.cast(self.cb, ctypes.c_void_p).value)

    def __call__(self, args, res):
        return call_idc_func__(self.ctxptr, args, res)


# --------------------------------------------------------------------------
# Dictionary to remember IDC function names along with the context pointer
# retrieved by using the internal pyw_register_idc_func()
__IDC_FUNC_CTXS = {}

# --------------------------------------------------------------------------
def 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

    @param name: IDC function name to expose
    @param fp: Python callable that will receive the arguments and return a tuple.
               If this argument is None then the IDC function is unregistered
    @param args: Arguments. A tuple of idaapi.VT_XXX constants
    @param flags: IDC function flags. A combination of EXTFUN_XXX constants

    @return: Boolean.
    """
    global __IDC_FUNC_CTXS

    # Get the context
    f = __IDC_FUNC_CTXS.get(name, None)

    # Unregistering?
    if fp is None:
        # Not registered?
        if f is None:
            return False

        # Break circular reference
        del f.cb

        # Delete the name from the dictionary
        del __IDC_FUNC_CTXS[name]

        # Delete the context and unregister the function
        return _idaapi.pyw_unregister_idc_func(f.ctxptr)

    # Registering a function that is already registered?
    if f is not None:
        # Unregister it first
        set_idc_func_ex(name, None)

    # Convert the tupple argument info to a string
    args = "".join([chr(x) for x in args])

    # Create a context
    ctxptr = _idaapi.pyw_register_idc_func(name, args, fp)
    if ctxptr == 0:
        return False

    # Bind the context with the IdcFunc object
    f = _IdcFunction(ctxptr)

    # Remember the Python context
    __IDC_FUNC_CTXS[name] = f

    # Register IDC function with a callback
    return _idaapi.py_set_idc_func_ex(
                name,
                f.fp_ptr,
                args,
                flags)

#</pycode(py_expr)>

class fixup_data_t(object):
    """
    Proxy of C++ fixup_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = _swig_property(_idaapi.fixup_data_t_type_get, _idaapi.fixup_data_t_type_set)
    sel = _swig_property(_idaapi.fixup_data_t_sel_get, _idaapi.fixup_data_t_sel_set)
    off = _swig_property(_idaapi.fixup_data_t_off_get, _idaapi.fixup_data_t_off_set)
    displacement = _swig_property(_idaapi.fixup_data_t_displacement_get, _idaapi.fixup_data_t_displacement_set)
    def is_custom(self, *args):
        """
        is_custom(self) -> bool
        """
        return _idaapi.fixup_data_t_is_custom(self, *args)

    def get_type(self, *args):
        """
        get_type(self) -> uchar
        """
        return _idaapi.fixup_data_t_get_type(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> fixup_data_t
        """
        this = _idaapi.new_fixup_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_fixup_data_t
    __del__ = lambda self : None;
fixup_data_t_swigregister = _idaapi.fixup_data_t_swigregister
fixup_data_t_swigregister(fixup_data_t)
FIXUP_MASK = _idaapi.FIXUP_MASK
FIXUP_OFF8 = _idaapi.FIXUP_OFF8
FIXUP_OFF16 = _idaapi.FIXUP_OFF16
FIXUP_SEG16 = _idaapi.FIXUP_SEG16
FIXUP_PTR16 = _idaapi.FIXUP_PTR16
FIXUP_OFF32 = _idaapi.FIXUP_OFF32
FIXUP_PTR32 = _idaapi.FIXUP_PTR32
FIXUP_HI8 = _idaapi.FIXUP_HI8
FIXUP_HI16 = _idaapi.FIXUP_HI16
FIXUP_LOW8 = _idaapi.FIXUP_LOW8
FIXUP_LOW16 = _idaapi.FIXUP_LOW16
FIXUP_VHIGH = _idaapi.FIXUP_VHIGH
FIXUP_VLOW = _idaapi.FIXUP_VLOW
FIXUP_OFF64 = _idaapi.FIXUP_OFF64
FIXUP_CUSTOM = _idaapi.FIXUP_CUSTOM
FIXUP_REL = _idaapi.FIXUP_REL
FIXUP_SELFREL = _idaapi.FIXUP_SELFREL
FIXUP_EXTDEF = _idaapi.FIXUP_EXTDEF
FIXUP_UNUSED = _idaapi.FIXUP_UNUSED
FIXUP_CREATED = _idaapi.FIXUP_CREATED


def set_fixup(*args):
  """
  set_fixup(source, fp)
  """
  return _idaapi.set_fixup(*args)

def set_fixup_ex(*args):
  """
  set_fixup_ex(source, fd, offset_base)
  """
  return _idaapi.set_fixup_ex(*args)

def del_fixup(*args):
  """
  del_fixup(source)
  """
  return _idaapi.del_fixup(*args)

def get_fixup(*args):
  """
  get_fixup(source, fd) -> bool
  """
  return _idaapi.get_fixup(*args)

def get_first_fixup_ea(*args):
  """
  get_first_fixup_ea() -> ea_t
  """
  return _idaapi.get_first_fixup_ea(*args)

def get_next_fixup_ea(*args):
  """
  get_next_fixup_ea(ea) -> ea_t
  """
  return _idaapi.get_next_fixup_ea(*args)

def get_prev_fixup_ea(*args):
  """
  get_prev_fixup_ea(ea) -> ea_t
  """
  return _idaapi.get_prev_fixup_ea(*args)

def get_fixup_base(*args):
  """
  get_fixup_base(source, fd) -> ea_t
  """
  return _idaapi.get_fixup_base(*args)

def get_fixup_extdef_ea(*args):
  """
    get_fixup_extdef_ea(source, fd) -> ea_t
    get_fixup_extdef_ea(ea) -> ea_t
    """
  return _idaapi.get_fixup_extdef_ea(*args)

def get_fixup_segdef_sel(*args):
  """
    get_fixup_segdef_sel(fd) -> sel_t
    get_fixup_segdef_sel(ea) -> sel_t
    """
  return _idaapi.get_fixup_segdef_sel(*args)

def get_fixup_desc(*args):
  """
  get_fixup_desc(source, fdp) -> char *
  """
  return _idaapi.get_fixup_desc(*args)

def contains_fixups(*args):
  """
  contains_fixups(ea, size) -> bool
  """
  return _idaapi.contains_fixups(*args)

def gen_fix_fixups(*args):
  """
  gen_fix_fixups(frm, to, size)
  """
  return _idaapi.gen_fix_fixups(*args)
class xreflist_t(object):
    """
    Proxy of C++ qvector<(xreflist_entry_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> xreflist_t
        __init__(self, x) -> xreflist_t
        """
        this = _idaapi.new_xreflist_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_xreflist_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.xreflist_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.xreflist_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.xreflist_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> xreflist_entry_t
        front(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> xreflist_entry_t
        back(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.xreflist_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.xreflist_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.xreflist_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=xreflist_entry_t())
        """
        return _idaapi.xreflist_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.xreflist_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.xreflist_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.xreflist_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.xreflist_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.xreflist_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.xreflist_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.xreflist_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> xreflist_entry_t
        begin(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> xreflist_entry_t
        end(self) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> xreflist_entry_t
        erase(self, first, last) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> xreflist_entry_t
        find(self, x) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.xreflist_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.xreflist_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.xreflist_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.xreflist_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> xreflist_entry_t
        """
        return _idaapi.xreflist_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.xreflist_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

xreflist_t_swigregister = _idaapi.xreflist_t_swigregister
xreflist_t_swigregister(xreflist_t)

class stkpnt_t(object):
    """
    Proxy of C++ stkpnt_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.stkpnt_t_ea_get, _idaapi.stkpnt_t_ea_set)
    spd = _swig_property(_idaapi.stkpnt_t_spd_get, _idaapi.stkpnt_t_spd_set)
    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.stkpnt_t___lt__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> stkpnt_t
        """
        this = _idaapi.new_stkpnt_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_stkpnt_t
    __del__ = lambda self : None;
stkpnt_t_swigregister = _idaapi.stkpnt_t_swigregister
stkpnt_t_swigregister(stkpnt_t)


def add_frame(*args):
  """
  add_frame(pfn, frsize, frregs, argsize) -> bool
  """
  return _idaapi.add_frame(*args)

def del_frame(*args):
  """
  del_frame(pfn) -> bool
  """
  return _idaapi.del_frame(*args)

def set_frame_size(*args):
  """
  set_frame_size(pfn, frsize, frregs, argsize) -> bool
  """
  return _idaapi.set_frame_size(*args)

def get_frame_size(*args):
  """
  get_frame_size(pfn) -> asize_t
  """
  return _idaapi.get_frame_size(*args)

def get_frame_retsize(*args):
  """
  get_frame_retsize(pfn) -> int
  """
  return _idaapi.get_frame_retsize(*args)
FPC_ARGS = _idaapi.FPC_ARGS
FPC_RETADDR = _idaapi.FPC_RETADDR
FPC_SAVREGS = _idaapi.FPC_SAVREGS
FPC_LVARS = _idaapi.FPC_LVARS

def get_frame_part(*args):
  """
  get_frame_part(pfn, part, range)
  """
  return _idaapi.get_frame_part(*args)

def frame_off_args(*args):
  """
  frame_off_args(pfn) -> ea_t
  """
  return _idaapi.frame_off_args(*args)

def frame_off_retaddr(*args):
  """
  frame_off_retaddr(pfn) -> ea_t
  """
  return _idaapi.frame_off_retaddr(*args)

def frame_off_savregs(*args):
  """
  frame_off_savregs(pfn) -> ea_t
  """
  return _idaapi.frame_off_savregs(*args)

def frame_off_lvars(*args):
  """
  frame_off_lvars(pfn) -> ea_t
  """
  return _idaapi.frame_off_lvars(*args)

def is_funcarg_off(*args):
  """
  is_funcarg_off(pfn, frameoff) -> bool
  """
  return _idaapi.is_funcarg_off(*args)

def lvar_off(*args):
  """
  lvar_off(pfn, frameoff) -> sval_t
  """
  return _idaapi.lvar_off(*args)

def get_frame(*args):
  """
    get_frame(pfn) -> struc_t
    get_frame(ea) -> struc_t
    """
  return _idaapi.get_frame(*args)

def update_fpd(*args):
  """
  update_fpd(pfn, fpd) -> bool
  """
  return _idaapi.update_fpd(*args)

def set_purged(*args):
  """
  set_purged(ea, nbytes, override_old_value) -> bool
  """
  return _idaapi.set_purged(*args)

def get_func_by_frame(*args):
  """
  get_func_by_frame(frame_id) -> ea_t
  """
  return _idaapi.get_func_by_frame(*args)
STKVAR_VALID_SIZE = _idaapi.STKVAR_VALID_SIZE

def add_stkvar2(*args):
  """
  add_stkvar2(pfn, name, off, flags, ti, nbytes) -> bool
  """
  return _idaapi.add_stkvar2(*args)

def build_stkvar_name(*args):
  """
  build_stkvar_name(pfn, v) -> char *
  """
  return _idaapi.build_stkvar_name(*args)

def calc_stkvar_struc_offset(*args):
  """
  calc_stkvar_struc_offset(pfn, ea, n) -> ea_t
  """
  return _idaapi.calc_stkvar_struc_offset(*args)

def delete_unreferenced_stkvars(*args):
  """
  delete_unreferenced_stkvars(pfn) -> int
  """
  return _idaapi.delete_unreferenced_stkvars(*args)

def delete_wrong_stkvar_ops(*args):
  """
  delete_wrong_stkvar_ops(pfn) -> int
  """
  return _idaapi.delete_wrong_stkvar_ops(*args)
class regvar_t(area_t):
    """
    Proxy of C++ regvar_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    canon = _swig_property(_idaapi.regvar_t_canon_get, _idaapi.regvar_t_canon_set)
    user = _swig_property(_idaapi.regvar_t_user_get, _idaapi.regvar_t_user_set)
    cmt = _swig_property(_idaapi.regvar_t_cmt_get, _idaapi.regvar_t_cmt_set)
    def __init__(self, *args):
        """
        __init__(self) -> regvar_t
        """
        this = _idaapi.new_regvar_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_regvar_t
    __del__ = lambda self : None;
regvar_t_swigregister = _idaapi.regvar_t_swigregister
regvar_t_swigregister(regvar_t)


def add_regvar(*args):
  """
  add_regvar(pfn, ea1, ea2, canon, user, cmt) -> int
  """
  return _idaapi.add_regvar(*args)
REGVAR_ERROR_OK = _idaapi.REGVAR_ERROR_OK
REGVAR_ERROR_ARG = _idaapi.REGVAR_ERROR_ARG
REGVAR_ERROR_RANGE = _idaapi.REGVAR_ERROR_RANGE
REGVAR_ERROR_NAME = _idaapi.REGVAR_ERROR_NAME

def find_regvar(*args):
  """
    find_regvar(pfn, ea1, ea2, canon, user) -> regvar_t
    find_regvar(pfn, ea, canon) -> regvar_t
    """
  return _idaapi.find_regvar(*args)

def rename_regvar(*args):
  """
  rename_regvar(pfn, v, user) -> int
  """
  return _idaapi.rename_regvar(*args)

def set_regvar_cmt(*args):
  """
  set_regvar_cmt(pfn, v, cmt) -> int
  """
  return _idaapi.set_regvar_cmt(*args)

def del_regvar(*args):
  """
  del_regvar(pfn, ea1, ea2, canon) -> int
  """
  return _idaapi.del_regvar(*args)
class llabel_t(object):
    """
    Proxy of C++ llabel_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.llabel_t_ea_get, _idaapi.llabel_t_ea_set)
    name = _swig_property(_idaapi.llabel_t_name_get, _idaapi.llabel_t_name_set)
    def __init__(self, *args):
        """
        __init__(self) -> llabel_t
        """
        this = _idaapi.new_llabel_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_llabel_t
    __del__ = lambda self : None;
llabel_t_swigregister = _idaapi.llabel_t_swigregister
llabel_t_swigregister(llabel_t)


def add_auto_stkpnt2(*args):
  """
  add_auto_stkpnt2(pfn, ea, delta) -> bool
  """
  return _idaapi.add_auto_stkpnt2(*args)

def add_user_stkpnt(*args):
  """
  add_user_stkpnt(ea, delta) -> bool
  """
  return _idaapi.add_user_stkpnt(*args)

def del_stkpnt(*args):
  """
  del_stkpnt(pfn, ea) -> bool
  """
  return _idaapi.del_stkpnt(*args)

def get_spd(*args):
  """
  get_spd(pfn, ea) -> sval_t
  """
  return _idaapi.get_spd(*args)

def get_effective_spd(*args):
  """
  get_effective_spd(pfn, ea) -> sval_t
  """
  return _idaapi.get_effective_spd(*args)

def get_sp_delta(*args):
  """
  get_sp_delta(pfn, ea) -> sval_t
  """
  return _idaapi.get_sp_delta(*args)

def get_min_spd_ea(*args):
  """
  get_min_spd_ea(pfn) -> ea_t
  """
  return _idaapi.get_min_spd_ea(*args)

def recalc_spd(*args):
  """
  recalc_spd(cur_ea) -> bool
  """
  return _idaapi.recalc_spd(*args)
class xreflist_entry_t(object):
    """
    Proxy of C++ xreflist_entry_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.xreflist_entry_t_ea_get, _idaapi.xreflist_entry_t_ea_set)
    opnum = _swig_property(_idaapi.xreflist_entry_t_opnum_get, _idaapi.xreflist_entry_t_opnum_set)
    type = _swig_property(_idaapi.xreflist_entry_t_type_get, _idaapi.xreflist_entry_t_type_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.xreflist_entry_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.xreflist_entry_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> xreflist_entry_t
        """
        this = _idaapi.new_xreflist_entry_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_xreflist_entry_t
    __del__ = lambda self : None;
xreflist_entry_t_swigregister = _idaapi.xreflist_entry_t_swigregister
xreflist_entry_t_swigregister(xreflist_entry_t)


def build_stkvar_xrefs(*args):
  """
  build_stkvar_xrefs(out, pfn, mptr)
  """
  return _idaapi.build_stkvar_xrefs(*args)

def add_auto_stkpnt(*args):
  """
  add_auto_stkpnt(ea, delta) -> bool
  """
  return _idaapi.add_auto_stkpnt(*args)
class regarg_t(object):
    """
    Proxy of C++ regarg_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    reg = _swig_property(_idaapi.regarg_t_reg_get, _idaapi.regarg_t_reg_set)
    type = _swig_property(_idaapi.regarg_t_type_get, _idaapi.regarg_t_type_set)
    name = _swig_property(_idaapi.regarg_t_name_get, _idaapi.regarg_t_name_set)
    def __init__(self, *args):
        """
        __init__(self) -> regarg_t
        """
        this = _idaapi.new_regarg_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_regarg_t
    __del__ = lambda self : None;
regarg_t_swigregister = _idaapi.regarg_t_swigregister
regarg_t_swigregister(regarg_t)

class func_t(area_t):
    """
    Proxy of C++ func_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.func_t_flags_get, _idaapi.func_t_flags_set)
    def is_far(self, *args):
        """
        is_far(self) -> bool
        """
        return _idaapi.func_t_is_far(self, *args)

    def does_return(self, *args):
        """
        does_return(self) -> bool
        """
        return _idaapi.func_t_does_return(self, *args)

    def analyzed_sp(self, *args):
        """
        analyzed_sp(self) -> bool
        """
        return _idaapi.func_t_analyzed_sp(self, *args)

    frame = _swig_property(_idaapi.func_t_frame_get, _idaapi.func_t_frame_set)
    frsize = _swig_property(_idaapi.func_t_frsize_get, _idaapi.func_t_frsize_set)
    frregs = _swig_property(_idaapi.func_t_frregs_get, _idaapi.func_t_frregs_set)
    argsize = _swig_property(_idaapi.func_t_argsize_get, _idaapi.func_t_argsize_set)
    fpd = _swig_property(_idaapi.func_t_fpd_get, _idaapi.func_t_fpd_set)
    color = _swig_property(_idaapi.func_t_color_get, _idaapi.func_t_color_set)
    pntqty = _swig_property(_idaapi.func_t_pntqty_get, _idaapi.func_t_pntqty_set)
    points = _swig_property(_idaapi.func_t_points_get, _idaapi.func_t_points_set)
    regvarqty = _swig_property(_idaapi.func_t_regvarqty_get, _idaapi.func_t_regvarqty_set)
    regvars = _swig_property(_idaapi.func_t_regvars_get, _idaapi.func_t_regvars_set)
    llabelqty = _swig_property(_idaapi.func_t_llabelqty_get, _idaapi.func_t_llabelqty_set)
    llabels = _swig_property(_idaapi.func_t_llabels_get, _idaapi.func_t_llabels_set)
    regargqty = _swig_property(_idaapi.func_t_regargqty_get, _idaapi.func_t_regargqty_set)
    regargs = _swig_property(_idaapi.func_t_regargs_get, _idaapi.func_t_regargs_set)
    tailqty = _swig_property(_idaapi.func_t_tailqty_get, _idaapi.func_t_tailqty_set)
    tails = _swig_property(_idaapi.func_t_tails_get, _idaapi.func_t_tails_set)
    owner = _swig_property(_idaapi.func_t_owner_get, _idaapi.func_t_owner_set)
    refqty = _swig_property(_idaapi.func_t_refqty_get, _idaapi.func_t_refqty_set)
    referers = _swig_property(_idaapi.func_t_referers_get, _idaapi.func_t_referers_set)
    def __init__(self, *args):
        """
        __init__(self) -> func_t
        """
        this = _idaapi.new_func_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_func_t
    __del__ = lambda self : None;
func_t_swigregister = _idaapi.func_t_swigregister
func_t_swigregister(func_t)
FUNC_NORET = _idaapi.FUNC_NORET
FUNC_FAR = _idaapi.FUNC_FAR
FUNC_LIB = _idaapi.FUNC_LIB
FUNC_STATIC = _idaapi.FUNC_STATIC
FUNC_FRAME = _idaapi.FUNC_FRAME
FUNC_USERFAR = _idaapi.FUNC_USERFAR
FUNC_HIDDEN = _idaapi.FUNC_HIDDEN
FUNC_THUNK = _idaapi.FUNC_THUNK
FUNC_BOTTOMBP = _idaapi.FUNC_BOTTOMBP
FUNC_NORET_PENDING = _idaapi.FUNC_NORET_PENDING
FUNC_SP_READY = _idaapi.FUNC_SP_READY
FUNC_PURGED_OK = _idaapi.FUNC_PURGED_OK
FUNC_TAIL = _idaapi.FUNC_TAIL


def is_func_entry(*args):
  """
  is_func_entry(pfn) -> bool
  """
  return _idaapi.is_func_entry(*args)

def is_func_tail(*args):
  """
  is_func_tail(pfn) -> bool
  """
  return _idaapi.is_func_tail(*args)
class lock_func(object):
    """
    Proxy of C++ lock_func class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _pfn) -> lock_func
        """
        this = _idaapi.new_lock_func(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lock_func
    __del__ = lambda self : None;
lock_func_swigregister = _idaapi.lock_func_swigregister
lock_func_swigregister(lock_func)


def is_func_locked(*args):
  """
  is_func_locked(pfn) -> bool
  """
  return _idaapi.is_func_locked(*args)

def get_func(*args):
  """
  get_func(ea) -> func_t
  """
  return _idaapi.get_func(*args)

def get_func_chunknum(*args):
  """
  get_func_chunknum(pfn, ea) -> int
  """
  return _idaapi.get_func_chunknum(*args)

def func_contains(*args):
  """
  func_contains(pfn, ea) -> bool
  """
  return _idaapi.func_contains(*args)

def getn_func(*args):
  """
  getn_func(n) -> func_t
  """
  return _idaapi.getn_func(*args)

def get_func_qty(*args):
  """
  get_func_qty() -> size_t
  """
  return _idaapi.get_func_qty(*args)

def get_func_num(*args):
  """
  get_func_num(ea) -> int
  """
  return _idaapi.get_func_num(*args)

def get_prev_func(*args):
  """
  get_prev_func(ea) -> func_t
  """
  return _idaapi.get_prev_func(*args)

def get_next_func(*args):
  """
  get_next_func(ea) -> func_t
  """
  return _idaapi.get_next_func(*args)

def get_func_limits(*args):
  """
  get_func_limits(pfn, limits) -> bool
  """
  return _idaapi.get_func_limits(*args)

def set_func_cmt(*args):
  """
  set_func_cmt(fn, cmt, repeatable) -> bool
  """
  return _idaapi.set_func_cmt(*args)

def del_func_cmt(*args):
  """
  del_func_cmt(fn, repeatable)
  """
  return _idaapi.del_func_cmt(*args)

def update_func(*args):
  """
  update_func(fn) -> bool
  """
  return _idaapi.update_func(*args)

def add_func_ex(*args):
  """
  add_func_ex(fn) -> bool
  """
  return _idaapi.add_func_ex(*args)

def add_func(*args):
  """
  add_func(ea1, ea2) -> bool
  """
  return _idaapi.add_func(*args)

def del_func(*args):
  """
  del_func(ea) -> bool
  """
  return _idaapi.del_func(*args)

def func_setstart(*args):
  """
  func_setstart(ea, newstart) -> int
  """
  return _idaapi.func_setstart(*args)
MOVE_FUNC_OK = _idaapi.MOVE_FUNC_OK
MOVE_FUNC_NOCODE = _idaapi.MOVE_FUNC_NOCODE
MOVE_FUNC_BADSTART = _idaapi.MOVE_FUNC_BADSTART
MOVE_FUNC_NOFUNC = _idaapi.MOVE_FUNC_NOFUNC
MOVE_FUNC_REFUSED = _idaapi.MOVE_FUNC_REFUSED

def func_setend(*args):
  """
  func_setend(ea, newend) -> bool
  """
  return _idaapi.func_setend(*args)

def reanalyze_function(*args):
  """
  reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False)
  """
  return _idaapi.reanalyze_function(*args)

def clear_func_struct(*args):
  """
  clear_func_struct(fn)
  """
  return _idaapi.clear_func_struct(*args)

def find_func_bounds(*args):
  """
  find_func_bounds(ea, nfn, flags) -> int
  """
  return _idaapi.find_func_bounds(*args)
FIND_FUNC_NORMAL = _idaapi.FIND_FUNC_NORMAL
FIND_FUNC_DEFINE = _idaapi.FIND_FUNC_DEFINE
FIND_FUNC_IGNOREFN = _idaapi.FIND_FUNC_IGNOREFN
FIND_FUNC_UNDEF = _idaapi.FIND_FUNC_UNDEF
FIND_FUNC_OK = _idaapi.FIND_FUNC_OK
FIND_FUNC_EXIST = _idaapi.FIND_FUNC_EXIST

def get_func_name2(*args):
  """
  get_func_name2(ea) -> ssize_t
  """
  return _idaapi.get_func_name2(*args)

def get_func_bitness(*args):
  """
  get_func_bitness(pfn) -> int
  """
  return _idaapi.get_func_bitness(*args)

def get_func_bits(*args):
  """
  get_func_bits(pfn) -> int
  """
  return _idaapi.get_func_bits(*args)

def get_func_bytes(*args):
  """
  get_func_bytes(pfn) -> int
  """
  return _idaapi.get_func_bytes(*args)

def is_visible_func(*args):
  """
  is_visible_func(pfn) -> bool
  """
  return _idaapi.is_visible_func(*args)

def is_finally_visible_func(*args):
  """
  is_finally_visible_func(pfn) -> bool
  """
  return _idaapi.is_finally_visible_func(*args)

def set_visible_func(*args):
  """
  set_visible_func(pfn, visible)
  """
  return _idaapi.set_visible_func(*args)

def set_func_name_if_jumpfunc(*args):
  """
  set_func_name_if_jumpfunc(fn, oldname) -> int
  """
  return _idaapi.set_func_name_if_jumpfunc(*args)

def calc_thunk_func_target(*args):
  """
  calc_thunk_func_target(fn, fptr) -> ea_t
  """
  return _idaapi.calc_thunk_func_target(*args)

def a2funcoff(*args):
  """
  a2funcoff(ea) -> char *
  """
  return _idaapi.a2funcoff(*args)

def std_gen_func_header(*args):
  """
  std_gen_func_header(pfn)
  """
  return _idaapi.std_gen_func_header(*args)

def func_does_return(*args):
  """
  func_does_return(callee) -> bool
  """
  return _idaapi.func_does_return(*args)

def set_noret_insn(*args):
  """
  set_noret_insn(insn_ea, noret) -> bool
  """
  return _idaapi.set_noret_insn(*args)

def get_fchunk(*args):
  """
  get_fchunk(ea) -> func_t
  """
  return _idaapi.get_fchunk(*args)

def getn_fchunk(*args):
  """
  getn_fchunk(n) -> func_t
  """
  return _idaapi.getn_fchunk(*args)

def get_fchunk_qty(*args):
  """
  get_fchunk_qty() -> size_t
  """
  return _idaapi.get_fchunk_qty(*args)

def get_fchunk_num(*args):
  """
  get_fchunk_num(ea) -> int
  """
  return _idaapi.get_fchunk_num(*args)

def get_prev_fchunk(*args):
  """
  get_prev_fchunk(ea) -> func_t
  """
  return _idaapi.get_prev_fchunk(*args)

def get_next_fchunk(*args):
  """
  get_next_fchunk(ea) -> func_t
  """
  return _idaapi.get_next_fchunk(*args)

def append_func_tail(*args):
  """
  append_func_tail(pfn, ea1, ea2) -> bool
  """
  return _idaapi.append_func_tail(*args)

def remove_func_tail(*args):
  """
  remove_func_tail(pfn, tail_ea) -> bool
  """
  return _idaapi.remove_func_tail(*args)

def set_tail_owner(*args):
  """
  set_tail_owner(fnt, func_start) -> bool
  """
  return _idaapi.set_tail_owner(*args)

def func_tail_iterator_set(*args):
  """
  func_tail_iterator_set(fti, pfn, ea) -> bool
  """
  return _idaapi.func_tail_iterator_set(*args)

def func_tail_iterator_set2(*args):
  """
  func_tail_iterator_set2(fti, pfn, ea) -> bool
  """
  return _idaapi.func_tail_iterator_set2(*args)

def func_tail_iterator_set_ea(*args):
  """
  func_tail_iterator_set_ea(fti, ea) -> bool
  """
  return _idaapi.func_tail_iterator_set_ea(*args)

def func_parent_iterator_set(*args):
  """
  func_parent_iterator_set(fpi, pfn) -> bool
  """
  return _idaapi.func_parent_iterator_set(*args)

def func_parent_iterator_set2(*args):
  """
  func_parent_iterator_set2(fpi, pfn) -> bool
  """
  return _idaapi.func_parent_iterator_set2(*args)

def func_item_iterator_next(*args):
  """
  func_item_iterator_next(fii, testf, ud) -> bool
  """
  return _idaapi.func_item_iterator_next(*args)

def func_item_iterator_prev(*args):
  """
  func_item_iterator_prev(fii, testf, ud) -> bool
  """
  return _idaapi.func_item_iterator_prev(*args)

def func_item_iterator_decode_prev_insn(*args):
  """
  func_item_iterator_decode_prev_insn(fii) -> bool
  """
  return _idaapi.func_item_iterator_decode_prev_insn(*args)

def func_item_iterator_decode_preceding_insn(*args):
  """
  func_item_iterator_decode_preceding_insn(fii, visited, p_farref) -> bool
  """
  return _idaapi.func_item_iterator_decode_preceding_insn(*args)

def f_any(*args):
  """
  f_any(arg1, arg2) -> bool
  """
  return _idaapi.f_any(*args)
class func_tail_iterator_t(object):
    """
    Proxy of C++ func_tail_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> func_tail_iterator_t
        __init__(self, _pfn, ea=BADADDR) -> func_tail_iterator_t
        """
        this = _idaapi.new_func_tail_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_func_tail_iterator_t
    __del__ = lambda self : None;
    def set(self, *args):
        """
        set(self, _pfn, ea=BADADDR) -> bool
        """
        return _idaapi.func_tail_iterator_t_set(self, *args)

    def set_ea(self, *args):
        """
        set_ea(self, ea) -> bool
        """
        return _idaapi.func_tail_iterator_t_set_ea(self, *args)

    def set_range(self, *args):
        """
        set_range(self, ea1, ea2) -> bool
        """
        return _idaapi.func_tail_iterator_t_set_range(self, *args)

    def chunk(self, *args):
        """
        chunk(self) -> area_t
        """
        return _idaapi.func_tail_iterator_t_chunk(self, *args)

    def first(self, *args):
        """
        first(self) -> bool
        """
        return _idaapi.func_tail_iterator_t_first(self, *args)

    def last(self, *args):
        """
        last(self) -> bool
        """
        return _idaapi.func_tail_iterator_t_last(self, *args)

    def next(self, *args):
        """
        next(self) -> bool
        """
        return _idaapi.func_tail_iterator_t_next(self, *args)

    def prev(self, *args):
        """
        prev(self) -> bool
        """
        return _idaapi.func_tail_iterator_t_prev(self, *args)

    def main(self, *args):
        """
        main(self) -> bool
        """
        return _idaapi.func_tail_iterator_t_main(self, *args)

func_tail_iterator_t_swigregister = _idaapi.func_tail_iterator_t_swigregister
func_tail_iterator_t_swigregister(func_tail_iterator_t)

class func_item_iterator_t(object):
    """
    Proxy of C++ func_item_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> func_item_iterator_t
        __init__(self, pfn, _ea=BADADDR) -> func_item_iterator_t
        """
        this = _idaapi.new_func_item_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """
        set(self, pfn, _ea=BADADDR) -> bool
        """
        return _idaapi.func_item_iterator_t_set(self, *args)

    def set_range(self, *args):
        """
        set_range(self, ea1, ea2) -> bool
        """
        return _idaapi.func_item_iterator_t_set_range(self, *args)

    def first(self, *args):
        """
        first(self) -> bool
        """
        return _idaapi.func_item_iterator_t_first(self, *args)

    def last(self, *args):
        """
        last(self) -> bool
        """
        return _idaapi.func_item_iterator_t_last(self, *args)

    def current(self, *args):
        """
        current(self) -> ea_t
        """
        return _idaapi.func_item_iterator_t_current(self, *args)

    def chunk(self, *args):
        """
        chunk(self) -> area_t
        """
        return _idaapi.func_item_iterator_t_chunk(self, *args)

    def next(self, *args):
        """
        next(self, func, ud) -> bool
        """
        return _idaapi.func_item_iterator_t_next(self, *args)

    def prev(self, *args):
        """
        prev(self, func, ud) -> bool
        """
        return _idaapi.func_item_iterator_t_prev(self, *args)

    def next_addr(self, *args):
        """
        next_addr(self) -> bool
        """
        return _idaapi.func_item_iterator_t_next_addr(self, *args)

    def next_head(self, *args):
        """
        next_head(self) -> bool
        """
        return _idaapi.func_item_iterator_t_next_head(self, *args)

    def next_code(self, *args):
        """
        next_code(self) -> bool
        """
        return _idaapi.func_item_iterator_t_next_code(self, *args)

    def next_data(self, *args):
        """
        next_data(self) -> bool
        """
        return _idaapi.func_item_iterator_t_next_data(self, *args)

    def next_not_tail(self, *args):
        """
        next_not_tail(self) -> bool
        """
        return _idaapi.func_item_iterator_t_next_not_tail(self, *args)

    def prev_addr(self, *args):
        """
        prev_addr(self) -> bool
        """
        return _idaapi.func_item_iterator_t_prev_addr(self, *args)

    def prev_head(self, *args):
        """
        prev_head(self) -> bool
        """
        return _idaapi.func_item_iterator_t_prev_head(self, *args)

    def prev_code(self, *args):
        """
        prev_code(self) -> bool
        """
        return _idaapi.func_item_iterator_t_prev_code(self, *args)

    def prev_data(self, *args):
        """
        prev_data(self) -> bool
        """
        return _idaapi.func_item_iterator_t_prev_data(self, *args)

    def prev_not_tail(self, *args):
        """
        prev_not_tail(self) -> bool
        """
        return _idaapi.func_item_iterator_t_prev_not_tail(self, *args)

    def decode_prev_insn(self, *args):
        """
        decode_prev_insn(self) -> bool
        """
        return _idaapi.func_item_iterator_t_decode_prev_insn(self, *args)

    def decode_preceding_insn(self, *args):
        """
        decode_preceding_insn(self, visited, p_farref) -> bool
        """
        return _idaapi.func_item_iterator_t_decode_preceding_insn(self, *args)

    __swig_destroy__ = _idaapi.delete_func_item_iterator_t
    __del__ = lambda self : None;
func_item_iterator_t_swigregister = _idaapi.func_item_iterator_t_swigregister
func_item_iterator_t_swigregister(func_item_iterator_t)

class func_parent_iterator_t(object):
    """
    Proxy of C++ func_parent_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> func_parent_iterator_t
        __init__(self, _fnt) -> func_parent_iterator_t
        """
        this = _idaapi.new_func_parent_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_func_parent_iterator_t
    __del__ = lambda self : None;
    def set(self, *args):
        """
        set(self, _fnt) -> bool
        """
        return _idaapi.func_parent_iterator_t_set(self, *args)

    def parent(self, *args):
        """
        parent(self) -> ea_t
        """
        return _idaapi.func_parent_iterator_t_parent(self, *args)

    def first(self, *args):
        """
        first(self) -> bool
        """
        return _idaapi.func_parent_iterator_t_first(self, *args)

    def last(self, *args):
        """
        last(self) -> bool
        """
        return _idaapi.func_parent_iterator_t_last(self, *args)

    def next(self, *args):
        """
        next(self) -> bool
        """
        return _idaapi.func_parent_iterator_t_next(self, *args)

    def prev(self, *args):
        """
        prev(self) -> bool
        """
        return _idaapi.func_parent_iterator_t_prev(self, *args)

    def reset_fnt(self, *args):
        """
        reset_fnt(self, _fnt)
        """
        return _idaapi.func_parent_iterator_t_reset_fnt(self, *args)

func_parent_iterator_t_swigregister = _idaapi.func_parent_iterator_t_swigregister
func_parent_iterator_t_swigregister(func_parent_iterator_t)


def get_prev_func_addr(*args):
  """
  get_prev_func_addr(pfn, ea) -> ea_t
  """
  return _idaapi.get_prev_func_addr(*args)

def get_next_func_addr(*args):
  """
  get_next_func_addr(pfn, ea) -> ea_t
  """
  return _idaapi.get_next_func_addr(*args)

def read_regargs(*args):
  """
  read_regargs(pfn)
  """
  return _idaapi.read_regargs(*args)

def add_regarg2(*args):
  """
  add_regarg2(pfn, reg, tif, name)
  """
  return _idaapi.add_regarg2(*args)
IDASGN_OK = _idaapi.IDASGN_OK
IDASGN_BADARG = _idaapi.IDASGN_BADARG
IDASGN_APPLIED = _idaapi.IDASGN_APPLIED
IDASGN_CURRENT = _idaapi.IDASGN_CURRENT
IDASGN_PLANNED = _idaapi.IDASGN_PLANNED

def plan_to_apply_idasgn(*args):
  """
  plan_to_apply_idasgn(fname) -> int
  """
  return _idaapi.plan_to_apply_idasgn(*args)

def apply_idasgn(*args):
  """
  apply_idasgn(advance) -> bool
  """
  return _idaapi.apply_idasgn(*args)

def apply_idasgn_to(*args):
  """
  apply_idasgn_to(signame, ea, is_startup) -> int
  """
  return _idaapi.apply_idasgn_to(*args)

def get_idasgn_qty(*args):
  """
  get_idasgn_qty() -> int
  """
  return _idaapi.get_idasgn_qty(*args)

def get_current_idasgn(*args):
  """
  get_current_idasgn() -> int
  """
  return _idaapi.get_current_idasgn(*args)

def calc_idasgn_state(*args):
  """
  calc_idasgn_state(n) -> int
  """
  return _idaapi.calc_idasgn_state(*args)

def del_idasgn(*args):
  """
  del_idasgn(n) -> int
  """
  return _idaapi.del_idasgn(*args)

def get_sig_filename(*args):
  """
  get_sig_filename(signame) -> char *
  """
  return _idaapi.get_sig_filename(*args)

def get_idasgn_title(*args):
  """
  get_idasgn_title(name) -> char *
  """
  return _idaapi.get_idasgn_title(*args)

def apply_startup_sig(*args):
  """
  apply_startup_sig(ea, startup) -> bool
  """
  return _idaapi.apply_startup_sig(*args)

def try_to_add_libfunc(*args):
  """
  try_to_add_libfunc(ea) -> int
  """
  return _idaapi.try_to_add_libfunc(*args)
LIBFUNC_FOUND = _idaapi.LIBFUNC_FOUND
LIBFUNC_NONE = _idaapi.LIBFUNC_NONE
LIBFUNC_DELAY = _idaapi.LIBFUNC_DELAY

def add_regarg(*args):
  """
  add_regarg(pfn, reg, type, name)
  """
  return _idaapi.add_regarg(*args)

def get_func_name(*args):
  """
  get_func_name(ea) -> char *
  """
  return _idaapi.get_func_name(*args)
FUNC_STATICDEF = _idaapi.FUNC_STATICDEF

def get_fchunk_referer(*args):
  """
  get_fchunk_referer(ea, idx) -> ea_t


  """
  return _idaapi.get_fchunk_referer(*args)

def get_idasgn_desc(*args):
  """
  get_idasgn_desc(n) -> PyObject *


  Get information about a signature in the list.
  It returns both: the name of the signature, and names of the
  optional libraries
  
  @param n: number of signature in the list (0..get_idasgn_qty()-1)
  @return: None on failure or tuple(signame, optlibs)
  """
  return _idaapi.get_idasgn_desc(*args)

def get_func_cmt(*args):
  """
  get_func_cmt(fn, repeatable) -> PyObject *


  Retrieve function comment
  @param fn: function instance
  @param repeatable: retrieve repeatable or non-repeatable comments
  @return: None on failure or the comment
  """
  return _idaapi.get_func_cmt(*args)
class funcargvec_t(object):
    """
    Proxy of C++ qvector<(funcarg_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> funcargvec_t
        __init__(self, x) -> funcargvec_t
        """
        this = _idaapi.new_funcargvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_funcargvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.funcargvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.funcargvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.funcargvec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> funcarg_t
        """
        return _idaapi.funcargvec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> funcarg_t
        front(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> funcarg_t
        back(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.funcargvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.funcargvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.funcargvec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=funcarg_t())
        """
        return _idaapi.funcargvec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.funcargvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.funcargvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.funcargvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.funcargvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.funcargvec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.funcargvec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.funcargvec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> funcarg_t
        begin(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> funcarg_t
        end(self) -> funcarg_t
        """
        return _idaapi.funcargvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> funcarg_t
        """
        return _idaapi.funcargvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> funcarg_t
        erase(self, first, last) -> funcarg_t
        """
        return _idaapi.funcargvec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> funcarg_t
        find(self, x) -> funcarg_t
        """
        return _idaapi.funcargvec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.funcargvec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.funcargvec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.funcargvec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.funcargvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> funcarg_t
        """
        return _idaapi.funcargvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.funcargvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

funcargvec_t_swigregister = _idaapi.funcargvec_t_swigregister
funcargvec_t_swigregister(funcargvec_t)

class udtmembervec_t(object):
    """
    Proxy of C++ qvector<(udt_member_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> udtmembervec_t
        __init__(self, x) -> udtmembervec_t
        """
        this = _idaapi.new_udtmembervec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_udtmembervec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.udtmembervec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.udtmembervec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.udtmembervec_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> udt_member_t
        front(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> udt_member_t
        back(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.udtmembervec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.udtmembervec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.udtmembervec_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=udt_member_t())
        """
        return _idaapi.udtmembervec_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.udtmembervec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.udtmembervec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.udtmembervec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.udtmembervec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.udtmembervec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.udtmembervec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.udtmembervec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> udt_member_t
        begin(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> udt_member_t
        end(self) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> udt_member_t
        erase(self, first, last) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> udt_member_t
        find(self, x) -> udt_member_t
        """
        return _idaapi.udtmembervec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.udtmembervec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.udtmembervec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.udtmembervec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.udtmembervec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> udt_member_t
        """
        return _idaapi.udtmembervec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.udtmembervec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

udtmembervec_t_swigregister = _idaapi.udtmembervec_t_swigregister
udtmembervec_t_swigregister(udtmembervec_t)

RESERVED_BYTE = _idaapi.RESERVED_BYTE

def is_type_const(*args):
  """
  is_type_const(t) -> bool
  """
  return _idaapi.is_type_const(*args)

def is_type_volatile(*args):
  """
  is_type_volatile(t) -> bool
  """
  return _idaapi.is_type_volatile(*args)

def get_base_type(*args):
  """
  get_base_type(t) -> type_t
  """
  return _idaapi.get_base_type(*args)

def get_type_flags(*args):
  """
  get_type_flags(t) -> type_t
  """
  return _idaapi.get_type_flags(*args)

def get_full_type(*args):
  """
  get_full_type(t) -> type_t
  """
  return _idaapi.get_full_type(*args)

def is_typeid_last(*args):
  """
  is_typeid_last(t) -> bool
  """
  return _idaapi.is_typeid_last(*args)

def is_type_partial(*args):
  """
  is_type_partial(t) -> bool
  """
  return _idaapi.is_type_partial(*args)

def is_type_void(*args):
  """
  is_type_void(t) -> bool
  """
  return _idaapi.is_type_void(*args)

def is_type_unknown(*args):
  """
  is_type_unknown(t) -> bool
  """
  return _idaapi.is_type_unknown(*args)

def is_type_ptr(*args):
  """
  is_type_ptr(t) -> bool
  """
  return _idaapi.is_type_ptr(*args)

def is_type_complex(*args):
  """
  is_type_complex(t) -> bool
  """
  return _idaapi.is_type_complex(*args)

def is_type_func(*args):
  """
  is_type_func(t) -> bool
  """
  return _idaapi.is_type_func(*args)

def is_type_array(*args):
  """
  is_type_array(t) -> bool
  """
  return _idaapi.is_type_array(*args)

def is_type_typedef(*args):
  """
  is_type_typedef(t) -> bool
  """
  return _idaapi.is_type_typedef(*args)

def is_type_sue(*args):
  """
  is_type_sue(t) -> bool
  """
  return _idaapi.is_type_sue(*args)

def is_type_struct(*args):
  """
  is_type_struct(t) -> bool
  """
  return _idaapi.is_type_struct(*args)

def is_type_union(*args):
  """
  is_type_union(t) -> bool
  """
  return _idaapi.is_type_union(*args)

def is_type_struni(*args):
  """
  is_type_struni(t) -> bool
  """
  return _idaapi.is_type_struni(*args)

def is_type_enum(*args):
  """
  is_type_enum(t) -> bool
  """
  return _idaapi.is_type_enum(*args)

def is_type_bitfld(*args):
  """
  is_type_bitfld(t) -> bool
  """
  return _idaapi.is_type_bitfld(*args)

def is_type_int(*args):
  """
  is_type_int(bt) -> bool
  """
  return _idaapi.is_type_int(*args)

def is_type_int128(*args):
  """
  is_type_int128(t) -> bool
  """
  return _idaapi.is_type_int128(*args)

def is_type_int64(*args):
  """
  is_type_int64(t) -> bool
  """
  return _idaapi.is_type_int64(*args)

def is_type_int32(*args):
  """
  is_type_int32(t) -> bool
  """
  return _idaapi.is_type_int32(*args)

def is_type_int16(*args):
  """
  is_type_int16(t) -> bool
  """
  return _idaapi.is_type_int16(*args)

def is_type_char(*args):
  """
  is_type_char(t) -> bool
  """
  return _idaapi.is_type_char(*args)

def is_type_paf(*args):
  """
  is_type_paf(t) -> bool
  """
  return _idaapi.is_type_paf(*args)

def is_type_ptr_or_array(*args):
  """
  is_type_ptr_or_array(t) -> bool
  """
  return _idaapi.is_type_ptr_or_array(*args)

def is_type_floating(*args):
  """
  is_type_floating(t) -> bool
  """
  return _idaapi.is_type_floating(*args)

def is_type_integral(*args):
  """
  is_type_integral(t) -> bool
  """
  return _idaapi.is_type_integral(*args)

def is_type_ext_integral(*args):
  """
  is_type_ext_integral(t) -> bool
  """
  return _idaapi.is_type_ext_integral(*args)

def is_type_arithmetic(*args):
  """
  is_type_arithmetic(t) -> bool
  """
  return _idaapi.is_type_arithmetic(*args)

def is_type_ext_arithmetic(*args):
  """
  is_type_ext_arithmetic(t) -> bool
  """
  return _idaapi.is_type_ext_arithmetic(*args)

def is_type_uint(*args):
  """
  is_type_uint(t) -> bool
  """
  return _idaapi.is_type_uint(*args)

def is_type_uchar(*args):
  """
  is_type_uchar(t) -> bool
  """
  return _idaapi.is_type_uchar(*args)

def is_type_uint16(*args):
  """
  is_type_uint16(t) -> bool
  """
  return _idaapi.is_type_uint16(*args)

def is_type_uint32(*args):
  """
  is_type_uint32(t) -> bool
  """
  return _idaapi.is_type_uint32(*args)

def is_type_uint64(*args):
  """
  is_type_uint64(t) -> bool
  """
  return _idaapi.is_type_uint64(*args)

def is_type_uint128(*args):
  """
  is_type_uint128(t) -> bool
  """
  return _idaapi.is_type_uint128(*args)

def is_type_ldouble(*args):
  """
  is_type_ldouble(t) -> bool
  """
  return _idaapi.is_type_ldouble(*args)

def is_type_double(*args):
  """
  is_type_double(t) -> bool
  """
  return _idaapi.is_type_double(*args)

def is_type_float(*args):
  """
  is_type_float(t) -> bool
  """
  return _idaapi.is_type_float(*args)

def is_type_bool(*args):
  """
  is_type_bool(t) -> bool
  """
  return _idaapi.is_type_bool(*args)
TAH_BYTE = _idaapi.TAH_BYTE
FAH_BYTE = _idaapi.FAH_BYTE
MAX_DECL_ALIGN = _idaapi.MAX_DECL_ALIGN
TAH_HASATTRS = _idaapi.TAH_HASATTRS
TAUDT_UNALIGNED = _idaapi.TAUDT_UNALIGNED
TAUDT_MSSTRUCT = _idaapi.TAUDT_MSSTRUCT
TAUDT_CPPOBJ = _idaapi.TAUDT_CPPOBJ
TAFLD_BASECLASS = _idaapi.TAFLD_BASECLASS
TAFLD_UNALIGNED = _idaapi.TAFLD_UNALIGNED
TAFLD_VIRTBASE = _idaapi.TAFLD_VIRTBASE
TAPTR_PTR32 = _idaapi.TAPTR_PTR32
TAPTR_PTR64 = _idaapi.TAPTR_PTR64
TAPTR_RESTRICT = _idaapi.TAPTR_RESTRICT
TAENUM_64BIT = _idaapi.TAENUM_64BIT
TAH_ALL = _idaapi.TAH_ALL

def is_tah_byte(*args):
  """
  is_tah_byte(t) -> bool
  """
  return _idaapi.is_tah_byte(*args)

def is_sdacl_byte(*args):
  """
  is_sdacl_byte(t) -> bool
  """
  return _idaapi.is_sdacl_byte(*args)
class type_attr_t(object):
    """
    Proxy of C++ type_attr_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    key = _swig_property(_idaapi.type_attr_t_key_get, _idaapi.type_attr_t_key_set)
    value = _swig_property(_idaapi.type_attr_t_value_get, _idaapi.type_attr_t_value_set)
    def __init__(self, *args):
        """
        __init__(self) -> type_attr_t
        """
        this = _idaapi.new_type_attr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_type_attr_t
    __del__ = lambda self : None;
type_attr_t_swigregister = _idaapi.type_attr_t_swigregister
type_attr_t_swigregister(type_attr_t)
TYPE_BASE_MASK = cvar.TYPE_BASE_MASK
TYPE_FLAGS_MASK = cvar.TYPE_FLAGS_MASK
TYPE_MODIF_MASK = cvar.TYPE_MODIF_MASK
TYPE_FULL_MASK = cvar.TYPE_FULL_MASK
BT_UNK = cvar.BT_UNK
BT_VOID = cvar.BT_VOID
BTMT_SIZE0 = cvar.BTMT_SIZE0
BTMT_SIZE12 = cvar.BTMT_SIZE12
BTMT_SIZE48 = cvar.BTMT_SIZE48
BTMT_SIZE128 = cvar.BTMT_SIZE128
BT_INT8 = cvar.BT_INT8
BT_INT16 = cvar.BT_INT16
BT_INT32 = cvar.BT_INT32
BT_INT64 = cvar.BT_INT64
BT_INT128 = cvar.BT_INT128
BT_INT = cvar.BT_INT
BTMT_UNKSIGN = cvar.BTMT_UNKSIGN
BTMT_SIGNED = cvar.BTMT_SIGNED
BTMT_USIGNED = cvar.BTMT_USIGNED
BTMT_UNSIGNED = cvar.BTMT_UNSIGNED
BTMT_CHAR = cvar.BTMT_CHAR
BT_BOOL = cvar.BT_BOOL
BTMT_DEFBOOL = cvar.BTMT_DEFBOOL
BTMT_BOOL1 = cvar.BTMT_BOOL1
BTMT_BOOL2 = cvar.BTMT_BOOL2
BTMT_BOOL4 = cvar.BTMT_BOOL4
BT_FLOAT = cvar.BT_FLOAT
BTMT_FLOAT = cvar.BTMT_FLOAT
BTMT_DOUBLE = cvar.BTMT_DOUBLE
BTMT_LNGDBL = cvar.BTMT_LNGDBL
BTMT_SPECFLT = cvar.BTMT_SPECFLT
_BT_LAST_BASIC = cvar._BT_LAST_BASIC
BT_PTR = cvar.BT_PTR
BTMT_DEFPTR = cvar.BTMT_DEFPTR
BTMT_NEAR = cvar.BTMT_NEAR
BTMT_FAR = cvar.BTMT_FAR
BTMT_CLOSURE = cvar.BTMT_CLOSURE
BT_ARRAY = cvar.BT_ARRAY
BTMT_NONBASED = cvar.BTMT_NONBASED
BTMT_ARRESERV = cvar.BTMT_ARRESERV
BT_FUNC = cvar.BT_FUNC
BTMT_DEFCALL = cvar.BTMT_DEFCALL
BTMT_NEARCALL = cvar.BTMT_NEARCALL
BTMT_FARCALL = cvar.BTMT_FARCALL
BTMT_INTCALL = cvar.BTMT_INTCALL
BT_COMPLEX = cvar.BT_COMPLEX
BTMT_STRUCT = cvar.BTMT_STRUCT
BTMT_UNION = cvar.BTMT_UNION
BTMT_ENUM = cvar.BTMT_ENUM
BTMT_TYPEDEF = cvar.BTMT_TYPEDEF
BT_BITFIELD = cvar.BT_BITFIELD
BTMT_BFLDI8 = cvar.BTMT_BFLDI8
BTMT_BFLDI16 = cvar.BTMT_BFLDI16
BTMT_BFLDI32 = cvar.BTMT_BFLDI32
BTMT_BFLDI64 = cvar.BTMT_BFLDI64
BT_RESERVED = cvar.BT_RESERVED
BTM_CONST = cvar.BTM_CONST
BTM_VOLATILE = cvar.BTM_VOLATILE
BTE_SIZE_MASK = cvar.BTE_SIZE_MASK
BTE_RESERVED = cvar.BTE_RESERVED
BTE_BITFIELD = cvar.BTE_BITFIELD
BTE_OUT_MASK = cvar.BTE_OUT_MASK
BTE_HEX = cvar.BTE_HEX
BTE_CHAR = cvar.BTE_CHAR
BTE_SDEC = cvar.BTE_SDEC
BTE_UDEC = cvar.BTE_UDEC
BTE_ALWAYS = cvar.BTE_ALWAYS
BT_SEGREG = cvar.BT_SEGREG
BT_UNK_BYTE = cvar.BT_UNK_BYTE
BT_UNK_WORD = cvar.BT_UNK_WORD
BT_UNK_DWORD = cvar.BT_UNK_DWORD
BT_UNK_QWORD = cvar.BT_UNK_QWORD
BT_UNK_OWORD = cvar.BT_UNK_OWORD
BT_UNKNOWN = cvar.BT_UNKNOWN
BTF_BYTE = cvar.BTF_BYTE
BTF_UNK = cvar.BTF_UNK
BTF_VOID = cvar.BTF_VOID
BTF_INT8 = cvar.BTF_INT8
BTF_CHAR = cvar.BTF_CHAR
BTF_UCHAR = cvar.BTF_UCHAR
BTF_UINT8 = cvar.BTF_UINT8
BTF_INT16 = cvar.BTF_INT16
BTF_UINT16 = cvar.BTF_UINT16
BTF_INT32 = cvar.BTF_INT32
BTF_UINT32 = cvar.BTF_UINT32
BTF_INT64 = cvar.BTF_INT64
BTF_UINT64 = cvar.BTF_UINT64
BTF_INT128 = cvar.BTF_INT128
BTF_UINT128 = cvar.BTF_UINT128
BTF_INT = cvar.BTF_INT
BTF_UINT = cvar.BTF_UINT
BTF_SINT = cvar.BTF_SINT
BTF_BOOL = cvar.BTF_BOOL
BTF_FLOAT = cvar.BTF_FLOAT
BTF_DOUBLE = cvar.BTF_DOUBLE
BTF_LDOUBLE = cvar.BTF_LDOUBLE
BTF_TBYTE = cvar.BTF_TBYTE
BTF_STRUCT = cvar.BTF_STRUCT
BTF_UNION = cvar.BTF_UNION
BTF_ENUM = cvar.BTF_ENUM
BTF_TYPEDEF = cvar.BTF_TYPEDEF


def append_argloc(*args):
  """
  append_argloc(out, vloc) -> bool
  """
  return _idaapi.append_argloc(*args)

def is_restype_const(*args):
  """
  is_restype_const(til, type) -> bool
  """
  return _idaapi.is_restype_const(*args)

def is_restype_void(*args):
  """
  is_restype_void(til, type) -> bool
  """
  return _idaapi.is_restype_void(*args)

def is_restype_ptr(*args):
  """
  is_restype_ptr(til, type) -> bool
  """
  return _idaapi.is_restype_ptr(*args)

def is_restype_func(*args):
  """
  is_restype_func(til, type) -> bool
  """
  return _idaapi.is_restype_func(*args)

def is_restype_array(*args):
  """
  is_restype_array(til, type) -> bool
  """
  return _idaapi.is_restype_array(*args)

def is_restype_complex(*args):
  """
  is_restype_complex(til, type) -> bool
  """
  return _idaapi.is_restype_complex(*args)

def is_restype_struct(*args):
  """
  is_restype_struct(til, type) -> bool
  """
  return _idaapi.is_restype_struct(*args)

def is_restype_union(*args):
  """
  is_restype_union(til, type) -> bool
  """
  return _idaapi.is_restype_union(*args)

def is_restype_struni(*args):
  """
  is_restype_struni(til, type) -> bool
  """
  return _idaapi.is_restype_struni(*args)

def is_restype_enum(*args):
  """
  is_restype_enum(til, type) -> bool
  """
  return _idaapi.is_restype_enum(*args)

def is_restype_bitfld(*args):
  """
  is_restype_bitfld(til, type) -> bool
  """
  return _idaapi.is_restype_bitfld(*args)

def is_restype_floating(*args):
  """
  is_restype_floating(til, type) -> bool
  """
  return _idaapi.is_restype_floating(*args)
class til_t(object):
    """
    Proxy of C++ til_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.til_t_name_get, _idaapi.til_t_name_set)
    desc = _swig_property(_idaapi.til_t_desc_get, _idaapi.til_t_desc_set)
    nbases = _swig_property(_idaapi.til_t_nbases_get, _idaapi.til_t_nbases_set)
    flags = _swig_property(_idaapi.til_t_flags_get, _idaapi.til_t_flags_set)
    def is_dirty(self, *args):
        """
        is_dirty(self) -> bool
        """
        return _idaapi.til_t_is_dirty(self, *args)

    def set_dirty(self, *args):
        """
        set_dirty(self)
        """
        return _idaapi.til_t_set_dirty(self, *args)

    cc = _swig_property(_idaapi.til_t_cc_get, _idaapi.til_t_cc_set)
    nrefs = _swig_property(_idaapi.til_t_nrefs_get, _idaapi.til_t_nrefs_set)
    nstreams = _swig_property(_idaapi.til_t_nstreams_get, _idaapi.til_t_nstreams_set)
    streams = _swig_property(_idaapi.til_t_streams_get, _idaapi.til_t_streams_set)
    def __init__(self, *args):
        """
        __init__(self) -> til_t
        """
        this = _idaapi.new_til_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def base(self, *args):
        """
        base(self, n) -> til_t
        """
        return _idaapi.til_t_base(self, *args)

    __swig_destroy__ = _idaapi.delete_til_t
    __del__ = lambda self : None;
til_t_swigregister = _idaapi.til_t_swigregister
til_t_swigregister(til_t)
no_sign = cvar.no_sign
type_signed = cvar.type_signed
type_unsigned = cvar.type_unsigned
TIL_ZIP = _idaapi.TIL_ZIP
TIL_MAC = _idaapi.TIL_MAC
TIL_ESI = _idaapi.TIL_ESI
TIL_UNI = _idaapi.TIL_UNI
TIL_ORD = _idaapi.TIL_ORD
TIL_ALI = _idaapi.TIL_ALI
TIL_MOD = _idaapi.TIL_MOD
TIL_STM = _idaapi.TIL_STM


def new_til(*args):
  """
  new_til(name, desc) -> til_t
  """
  return _idaapi.new_til(*args)
TIL_ADD_FAILED = _idaapi.TIL_ADD_FAILED
TIL_ADD_OK = _idaapi.TIL_ADD_OK
TIL_ADD_ALREADY = _idaapi.TIL_ADD_ALREADY

def compact_til(*args):
  """
  compact_til(ti) -> bool
  """
  return _idaapi.compact_til(*args)

def store_til(*args):
  """
  store_til(ti, tildir, name) -> bool
  """
  return _idaapi.store_til(*args)

def free_til(*args):
  """
  free_til(ti)
  """
  return _idaapi.free_til(*args)

def is_code_far(*args):
  """
  is_code_far(cm) -> bool
  """
  return _idaapi.is_code_far(*args)

def is_data_far(*args):
  """
  is_data_far(cm) -> bool
  """
  return _idaapi.is_data_far(*args)
class rrel_t(object):
    """
    Proxy of C++ rrel_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    off = _swig_property(_idaapi.rrel_t_off_get, _idaapi.rrel_t_off_set)
    reg = _swig_property(_idaapi.rrel_t_reg_get, _idaapi.rrel_t_reg_set)
    def __init__(self, *args):
        """
        __init__(self) -> rrel_t
        """
        this = _idaapi.new_rrel_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_rrel_t
    __del__ = lambda self : None;
rrel_t_swigregister = _idaapi.rrel_t_swigregister
rrel_t_swigregister(rrel_t)
CM_MASK = cvar.CM_MASK
CM_UNKNOWN = cvar.CM_UNKNOWN
CM_N8_F16 = cvar.CM_N8_F16
CM_N64 = cvar.CM_N64
CM_N16_F32 = cvar.CM_N16_F32
CM_N32_F48 = cvar.CM_N32_F48
CM_M_MASK = cvar.CM_M_MASK
CM_M_NN = cvar.CM_M_NN
CM_M_FF = cvar.CM_M_FF
CM_M_NF = cvar.CM_M_NF
CM_M_FN = cvar.CM_M_FN
CM_CC_MASK = cvar.CM_CC_MASK
CM_CC_INVALID = cvar.CM_CC_INVALID
CM_CC_UNKNOWN = cvar.CM_CC_UNKNOWN
CM_CC_VOIDARG = cvar.CM_CC_VOIDARG
CM_CC_CDECL = cvar.CM_CC_CDECL
CM_CC_ELLIPSIS = cvar.CM_CC_ELLIPSIS
CM_CC_STDCALL = cvar.CM_CC_STDCALL
CM_CC_PASCAL = cvar.CM_CC_PASCAL
CM_CC_FASTCALL = cvar.CM_CC_FASTCALL
CM_CC_THISCALL = cvar.CM_CC_THISCALL
CM_CC_MANUAL = cvar.CM_CC_MANUAL
CM_CC_SPOILED = cvar.CM_CC_SPOILED
CM_CC_RESERVE4 = cvar.CM_CC_RESERVE4
CM_CC_RESERVE3 = cvar.CM_CC_RESERVE3
CM_CC_SPECIALE = cvar.CM_CC_SPECIALE
CM_CC_SPECIALP = cvar.CM_CC_SPECIALP
CM_CC_SPECIAL = cvar.CM_CC_SPECIAL
BFA_NORET = cvar.BFA_NORET
BFA_PURE = cvar.BFA_PURE
BFA_HIGH = cvar.BFA_HIGH
BFA_STATIC = cvar.BFA_STATIC
BFA_VIRTUAL = cvar.BFA_VIRTUAL
ALOC_NONE = cvar.ALOC_NONE
ALOC_STACK = cvar.ALOC_STACK
ALOC_DIST = cvar.ALOC_DIST
ALOC_REG1 = cvar.ALOC_REG1
ALOC_REG2 = cvar.ALOC_REG2
ALOC_RREL = cvar.ALOC_RREL
ALOC_STATIC = cvar.ALOC_STATIC
ALOC_CUSTOM = cvar.ALOC_CUSTOM

class argloc_t(object):
    """
    Proxy of C++ argloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> argloc_t
        __init__(self, r) -> argloc_t
        """
        this = _idaapi.new_argloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_argloc_t
    __del__ = lambda self : None;
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.argloc_t_swap(self, *args)

    def atype(self, *args):
        """
        atype(self) -> argloc_type_t
        """
        return _idaapi.argloc_t_atype(self, *args)

    def is_reg1(self, *args):
        """
        is_reg1(self) -> bool
        """
        return _idaapi.argloc_t_is_reg1(self, *args)

    def is_reg2(self, *args):
        """
        is_reg2(self) -> bool
        """
        return _idaapi.argloc_t_is_reg2(self, *args)

    def is_reg(self, *args):
        """
        is_reg(self) -> bool
        """
        return _idaapi.argloc_t_is_reg(self, *args)

    def is_rrel(self, *args):
        """
        is_rrel(self) -> bool
        """
        return _idaapi.argloc_t_is_rrel(self, *args)

    def is_ea(self, *args):
        """
        is_ea(self) -> bool
        """
        return _idaapi.argloc_t_is_ea(self, *args)

    def is_stkoff(self, *args):
        """
        is_stkoff(self) -> bool
        """
        return _idaapi.argloc_t_is_stkoff(self, *args)

    def is_scattered(self, *args):
        """
        is_scattered(self) -> bool
        """
        return _idaapi.argloc_t_is_scattered(self, *args)

    def is_fragmented(self, *args):
        """
        is_fragmented(self) -> bool
        """
        return _idaapi.argloc_t_is_fragmented(self, *args)

    def is_custom(self, *args):
        """
        is_custom(self) -> bool
        """
        return _idaapi.argloc_t_is_custom(self, *args)

    def is_badloc(self, *args):
        """
        is_badloc(self) -> bool
        """
        return _idaapi.argloc_t_is_badloc(self, *args)

    def reg1(self, *args):
        """
        reg1(self) -> int
        """
        return _idaapi.argloc_t_reg1(self, *args)

    def regoff(self, *args):
        """
        regoff(self) -> int
        """
        return _idaapi.argloc_t_regoff(self, *args)

    def reg2(self, *args):
        """
        reg2(self) -> int
        """
        return _idaapi.argloc_t_reg2(self, *args)

    def get_reginfo(self, *args):
        """
        get_reginfo(self) -> uint32
        """
        return _idaapi.argloc_t_get_reginfo(self, *args)

    def stkoff(self, *args):
        """
        stkoff(self) -> sval_t
        """
        return _idaapi.argloc_t_stkoff(self, *args)

    def get_ea(self, *args):
        """
        get_ea(self) -> ea_t
        """
        return _idaapi.argloc_t_get_ea(self, *args)

    def scattered(self, *args):
        """
        scattered(self) -> scattered_aloc_t
        scattered(self) -> scattered_aloc_t
        """
        return _idaapi.argloc_t_scattered(self, *args)

    def get_rrel(self, *args):
        """
        get_rrel(self) -> rrel_t
        get_rrel(self) -> rrel_t
        """
        return _idaapi.argloc_t_get_rrel(self, *args)

    def get_custom(self, *args):
        """
        get_custom(self) -> void *
        """
        return _idaapi.argloc_t_get_custom(self, *args)

    def get_biggest(self, *args):
        """
        get_biggest(self) -> argloc_t::biggest_t
        """
        return _idaapi.argloc_t_get_biggest(self, *args)

    def _set_badloc(self, *args):
        """
        _set_badloc(self)
        """
        return _idaapi.argloc_t__set_badloc(self, *args)

    def _set_reg1(self, *args):
        """
        _set_reg1(self, reg, off=0)
        """
        return _idaapi.argloc_t__set_reg1(self, *args)

    def _set_reg2(self, *args):
        """
        _set_reg2(self, _reg1, _reg2)
        """
        return _idaapi.argloc_t__set_reg2(self, *args)

    def _set_stkoff(self, *args):
        """
        _set_stkoff(self, off)
        """
        return _idaapi.argloc_t__set_stkoff(self, *args)

    def _set_ea(self, *args):
        """
        _set_ea(self, _ea)
        """
        return _idaapi.argloc_t__set_ea(self, *args)

    def _consume_rrel(self, *args):
        """
        _consume_rrel(self, p) -> bool
        """
        return _idaapi.argloc_t__consume_rrel(self, *args)

    def _consume_scattered(self, *args):
        """
        _consume_scattered(self, p) -> bool
        """
        return _idaapi.argloc_t__consume_scattered(self, *args)

    def _set_custom(self, *args):
        """
        _set_custom(self, ct, pdata)
        """
        return _idaapi.argloc_t__set_custom(self, *args)

    def _set_biggest(self, *args):
        """
        _set_biggest(self, ct, data)
        """
        return _idaapi.argloc_t__set_biggest(self, *args)

    def set_reg1(self, *args):
        """
        set_reg1(self, reg, off=0)
        """
        return _idaapi.argloc_t_set_reg1(self, *args)

    def set_reg2(self, *args):
        """
        set_reg2(self, _reg1, _reg2)
        """
        return _idaapi.argloc_t_set_reg2(self, *args)

    def set_stkoff(self, *args):
        """
        set_stkoff(self, off)
        """
        return _idaapi.argloc_t_set_stkoff(self, *args)

    def set_ea(self, *args):
        """
        set_ea(self, _ea)
        """
        return _idaapi.argloc_t_set_ea(self, *args)

    def consume_rrel(self, *args):
        """
        consume_rrel(self, p)
        """
        return _idaapi.argloc_t_consume_rrel(self, *args)

    def consume_scattered(self, *args):
        """
        consume_scattered(self, p)
        """
        return _idaapi.argloc_t_consume_scattered(self, *args)

    def set_badloc(self, *args):
        """
        set_badloc(self)
        """
        return _idaapi.argloc_t_set_badloc(self, *args)

    def calc_offset(self, *args):
        """
        calc_offset(self) -> sval_t
        """
        return _idaapi.argloc_t_calc_offset(self, *args)

    def advance(self, *args):
        """
        advance(self, delta) -> bool
        """
        return _idaapi.argloc_t_advance(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.argloc_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.argloc_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.argloc_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.argloc_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.argloc_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.argloc_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.argloc_t_compare(self, *args)

argloc_t_swigregister = _idaapi.argloc_t_swigregister
argloc_t_swigregister(argloc_t)

class argpart_t(argloc_t):
    """
    Proxy of C++ argpart_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    off = _swig_property(_idaapi.argpart_t_off_get, _idaapi.argpart_t_off_set)
    size = _swig_property(_idaapi.argpart_t_size_get, _idaapi.argpart_t_size_set)
    def __init__(self, *args):
        """
        __init__(self) -> argpart_t
        """
        this = _idaapi.new_argpart_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def bad_offset(self, *args):
        """
        bad_offset(self) -> bool
        """
        return _idaapi.argpart_t_bad_offset(self, *args)

    def bad_size(self, *args):
        """
        bad_size(self) -> bool
        """
        return _idaapi.argpart_t_bad_size(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.argpart_t___lt__(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.argpart_t_swap(self, *args)

    __swig_destroy__ = _idaapi.delete_argpart_t
    __del__ = lambda self : None;
argpart_t_swigregister = _idaapi.argpart_t_swigregister
argpart_t_swigregister(argpart_t)

class scattered_aloc_t(object):
    """
    Proxy of C++ scattered_aloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> scattered_aloc_t
        """
        this = _idaapi.new_scattered_aloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_scattered_aloc_t
    __del__ = lambda self : None;
scattered_aloc_t_swigregister = _idaapi.scattered_aloc_t_swigregister
scattered_aloc_t_swigregister(scattered_aloc_t)


def verify_argloc(*args):
  """
  verify_argloc(vloc, size, gaps) -> int
  """
  return _idaapi.verify_argloc(*args)

def optimize_argloc(*args):
  """
  optimize_argloc(vloc, size, gaps) -> bool
  """
  return _idaapi.optimize_argloc(*args)

def print_argloc(*args):
  """
  print_argloc(vloc, size=0, vflags=0) -> size_t
  """
  return _idaapi.print_argloc(*args)
PRALOC_VERIFY = _idaapi.PRALOC_VERIFY
PRALOC_STKOFF = _idaapi.PRALOC_STKOFF
class aloc_visitor_t(object):
    """
    Proxy of C++ aloc_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_location(self, *args):
        """
        visit_location(self, v, off, size) -> int
        """
        return _idaapi.aloc_visitor_t_visit_location(self, *args)

    __swig_destroy__ = _idaapi.delete_aloc_visitor_t
    __del__ = lambda self : None;
aloc_visitor_t_swigregister = _idaapi.aloc_visitor_t_swigregister
aloc_visitor_t_swigregister(aloc_visitor_t)


def for_all_arglocs(*args):
  """
  for_all_arglocs(vv, vloc, size, off=0) -> int
  """
  return _idaapi.for_all_arglocs(*args)
class const_aloc_visitor_t(object):
    """
    Proxy of C++ const_aloc_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_location(self, *args):
        """
        visit_location(self, v, off, size) -> int
        """
        return _idaapi.const_aloc_visitor_t_visit_location(self, *args)

    __swig_destroy__ = _idaapi.delete_const_aloc_visitor_t
    __del__ = lambda self : None;
const_aloc_visitor_t_swigregister = _idaapi.const_aloc_visitor_t_swigregister
const_aloc_visitor_t_swigregister(const_aloc_visitor_t)


def for_all_const_arglocs(*args):
  """
  for_all_const_arglocs(vv, vloc, size, off=0) -> int
  """
  return _idaapi.for_all_const_arglocs(*args)
ARGREGS_POLICY_UNDEFINED = _idaapi.ARGREGS_POLICY_UNDEFINED
ARGREGS_GP_ONLY = _idaapi.ARGREGS_GP_ONLY
ARGREGS_INDEPENDENT = _idaapi.ARGREGS_INDEPENDENT
ARGREGS_BY_SLOTS = _idaapi.ARGREGS_BY_SLOTS

def callregs_init_regs(*args):
  """
  callregs_init_regs(_this, request)
  """
  return _idaapi.callregs_init_regs(*args)
class callregs_t(object):
    """
    Proxy of C++ callregs_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    policy = _swig_property(_idaapi.callregs_t_policy_get, _idaapi.callregs_t_policy_set)
    nregs = _swig_property(_idaapi.callregs_t_nregs_get, _idaapi.callregs_t_nregs_set)
    gpregs = _swig_property(_idaapi.callregs_t_gpregs_get, _idaapi.callregs_t_gpregs_set)
    fpregs = _swig_property(_idaapi.callregs_t_fpregs_get, _idaapi.callregs_t_fpregs_set)
    def __init__(self, *args):
        """
        __init__(self) -> callregs_t
        __init__(self, request) -> callregs_t
        """
        this = _idaapi.new_callregs_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def init_regs(self, *args):
        """
        init_regs(self, request)
        """
        return _idaapi.callregs_t_init_regs(self, *args)

    def set(self, *args):
        """
        set(self, _policy, gprs, fprs)
        """
        return _idaapi.callregs_t_set(self, *args)

    def reset(self, *args):
        """
        reset(self)
        """
        return _idaapi.callregs_t_reset(self, *args)

    def regcount(*args):
        """
        regcount(request) -> int
        """
        return _idaapi.callregs_t_regcount(*args)

    regcount = staticmethod(regcount)
    def reginds(self, *args):
        """
        reginds(self, gp_ind, fp_ind, r) -> bool
        """
        return _idaapi.callregs_t_reginds(self, *args)

    __swig_destroy__ = _idaapi.delete_callregs_t
    __del__ = lambda self : None;
callregs_t_swigregister = _idaapi.callregs_t_swigregister
callregs_t_swigregister(callregs_t)

def callregs_t_regcount(*args):
  """
  callregs_t_regcount(request) -> int
  """
  return _idaapi.callregs_t_regcount(*args)


def is_user_cc(*args):
  """
  is_user_cc(cm) -> bool
  """
  return _idaapi.is_user_cc(*args)

def is_vararg_cc(*args):
  """
  is_vararg_cc(cm) -> bool
  """
  return _idaapi.is_vararg_cc(*args)

def is_purging_cc(*args):
  """
  is_purging_cc(cm) -> bool
  """
  return _idaapi.is_purging_cc(*args)

def get_comp(*args):
  """
  get_comp(comp) -> comp_t
  """
  return _idaapi.get_comp(*args)

def get_compiler_name(*args):
  """
  get_compiler_name(id) -> char const *
  """
  return _idaapi.get_compiler_name(*args)

def get_compiler_abbr(*args):
  """
  get_compiler_abbr(id) -> char const *
  """
  return _idaapi.get_compiler_abbr(*args)

def get_compilers(*args):
  """
  get_compilers(ids, names, abbrs)
  """
  return _idaapi.get_compilers(*args)

def is_comp_unsure(*args):
  """
  is_comp_unsure(comp) -> comp_t
  """
  return _idaapi.is_comp_unsure(*args)

def default_compiler(*args):
  """
  default_compiler() -> comp_t
  """
  return _idaapi.default_compiler(*args)

def is_gcc(*args):
  """
  is_gcc() -> bool
  """
  return _idaapi.is_gcc(*args)

def is_gcc32(*args):
  """
  is_gcc32() -> bool
  """
  return _idaapi.is_gcc32(*args)

def is_gcc64(*args):
  """
  is_gcc64() -> bool
  """
  return _idaapi.is_gcc64(*args)

def set_compiler(*args):
  """
  set_compiler(cc, flags) -> bool
  """
  return _idaapi.set_compiler(*args)
SETCOMP_OVERRIDE = _idaapi.SETCOMP_OVERRIDE
SETCOMP_ONLY_ID = _idaapi.SETCOMP_ONLY_ID

def set_compiler_id(*args):
  """
  set_compiler_id(id) -> bool
  """
  return _idaapi.set_compiler_id(*args)
MAX_FUNC_ARGS = _idaapi.MAX_FUNC_ARGS
abs_unk = _idaapi.abs_unk
abs_no = _idaapi.abs_no
abs_yes = _idaapi.abs_yes
sc_unk = _idaapi.sc_unk
sc_type = _idaapi.sc_type
sc_ext = _idaapi.sc_ext
sc_stat = _idaapi.sc_stat
sc_reg = _idaapi.sc_reg
sc_auto = _idaapi.sc_auto
sc_friend = _idaapi.sc_friend
sc_virt = _idaapi.sc_virt
HTI_CPP = _idaapi.HTI_CPP
HTI_INT = _idaapi.HTI_INT
HTI_EXT = _idaapi.HTI_EXT
HTI_LEX = _idaapi.HTI_LEX
HTI_UNP = _idaapi.HTI_UNP
HTI_TST = _idaapi.HTI_TST
HTI_FIL = _idaapi.HTI_FIL
HTI_MAC = _idaapi.HTI_MAC
HTI_NWR = _idaapi.HTI_NWR
HTI_NER = _idaapi.HTI_NER
HTI_DCL = _idaapi.HTI_DCL
HTI_NDC = _idaapi.HTI_NDC
HTI_PAK = _idaapi.HTI_PAK
HTI_PAK_SHIFT = _idaapi.HTI_PAK_SHIFT
HTI_PAKDEF = _idaapi.HTI_PAKDEF
HTI_PAK1 = _idaapi.HTI_PAK1
HTI_PAK2 = _idaapi.HTI_PAK2
HTI_PAK4 = _idaapi.HTI_PAK4
HTI_PAK8 = _idaapi.HTI_PAK8
HTI_PAK16 = _idaapi.HTI_PAK16
HTI_HIGH = _idaapi.HTI_HIGH
HTI_LOWER = _idaapi.HTI_LOWER

def parse_decl2(*args):
  """
  parse_decl2(til, decl, name, tif, flags) -> bool
  """
  return _idaapi.parse_decl2(*args)
PT_SIL = _idaapi.PT_SIL
PT_NDC = _idaapi.PT_NDC
PT_TYP = _idaapi.PT_TYP
PT_VAR = _idaapi.PT_VAR
PT_PACKMASK = _idaapi.PT_PACKMASK
PT_HIGH = _idaapi.PT_HIGH
PT_LOWER = _idaapi.PT_LOWER
PT_REPLACE = _idaapi.PT_REPLACE

def convert_pt_flags_to_hti(*args):
  """
  convert_pt_flags_to_hti(pt_flags) -> int
  """
  return _idaapi.convert_pt_flags_to_hti(*args)

def parse_decls(*args):
  """
  parse_decls(til, input, printer, hti_flags) -> int
  """
  return _idaapi.parse_decls(*args)

def print_type3(*args):
  """
  print_type3(ea, prtype_flags) -> bool
  """
  return _idaapi.print_type3(*args)
PRTYPE_1LINE = _idaapi.PRTYPE_1LINE
PRTYPE_MULTI = _idaapi.PRTYPE_MULTI
PRTYPE_TYPE = _idaapi.PRTYPE_TYPE
PRTYPE_PRAGMA = _idaapi.PRTYPE_PRAGMA
PRTYPE_SEMI = _idaapi.PRTYPE_SEMI
PRTYPE_CPP = _idaapi.PRTYPE_CPP
PRTYPE_DEF = _idaapi.PRTYPE_DEF
PRTYPE_NOARGS = _idaapi.PRTYPE_NOARGS
PRTYPE_NOARRS = _idaapi.PRTYPE_NOARRS
PRTYPE_NORES = _idaapi.PRTYPE_NORES
NTF_TYPE = _idaapi.NTF_TYPE
NTF_SYMU = _idaapi.NTF_SYMU
NTF_SYMM = _idaapi.NTF_SYMM
NTF_NOBASE = _idaapi.NTF_NOBASE
NTF_REPLACE = _idaapi.NTF_REPLACE
NTF_UMANGLED = _idaapi.NTF_UMANGLED
NTF_NOCUR = _idaapi.NTF_NOCUR
NTF_64BIT = _idaapi.NTF_64BIT

def set_named_type64(*args):
  """
  set_named_type64(ti, name, ntf_flags, ptr, fields=None, cmt=None, fieldcmts=None, sclass=None, value=None) -> bool
  """
  return _idaapi.set_named_type64(*args)

def del_named_type(*args):
  """
  del_named_type(ti, name, ntf_flags) -> bool
  """
  return _idaapi.del_named_type(*args)

def rename_named_type(*args):
  """
  rename_named_type(ti, frm, to, ntf_flags) -> int
  """
  return _idaapi.rename_named_type(*args)

def first_named_type(*args):
  """
  first_named_type(ti, ntf_flags) -> char const *
  """
  return _idaapi.first_named_type(*args)

def next_named_type(*args):
  """
  next_named_type(ti, name, ntf_flags) -> char const *
  """
  return _idaapi.next_named_type(*args)

def gen_decorate_name3(*args):
  """
  gen_decorate_name3(name, mangle, cc) -> bool
  """
  return _idaapi.gen_decorate_name3(*args)

def calc_c_cpp_name4(*args):
  """
  calc_c_cpp_name4(name, type, ccn_flags) -> ssize_t
  """
  return _idaapi.calc_c_cpp_name4(*args)
CCN_C = _idaapi.CCN_C
CCN_CPP = _idaapi.CCN_CPP

def get_numbered_type(*args):
  """
  get_numbered_type(ti, ordinal, type=None, fields=None, cmt=None, fieldcmts=None, sclass=None) -> bool
  """
  return _idaapi.get_numbered_type(*args)

def alloc_type_ordinals(*args):
  """
  alloc_type_ordinals(ti, qty) -> uint32
  """
  return _idaapi.alloc_type_ordinals(*args)

def alloc_type_ordinal(*args):
  """
  alloc_type_ordinal(ti) -> uint32
  """
  return _idaapi.alloc_type_ordinal(*args)

def get_ordinal_qty(*args):
  """
  get_ordinal_qty(ti) -> uint32
  """
  return _idaapi.get_ordinal_qty(*args)

def set_numbered_type(*args):
  """
  set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> bool
  """
  return _idaapi.set_numbered_type(*args)

def del_numbered_type(*args):
  """
  del_numbered_type(ti, ordinal) -> bool
  """
  return _idaapi.del_numbered_type(*args)

def set_type_alias(*args):
  """
  set_type_alias(ti, src_ordinal, dst_ordinal) -> bool
  """
  return _idaapi.set_type_alias(*args)

def get_alias_target(*args):
  """
  get_alias_target(ti, ordinal) -> uint32
  """
  return _idaapi.get_alias_target(*args)

def get_type_ordinal(*args):
  """
  get_type_ordinal(ti, name) -> int32
  """
  return _idaapi.get_type_ordinal(*args)

def get_numbered_type_name(*args):
  """
  get_numbered_type_name(ti, ordinal) -> char const *
  """
  return _idaapi.get_numbered_type_name(*args)

def create_numbered_type_name(*args):
  """
  create_numbered_type_name(ord) -> size_t
  """
  return _idaapi.create_numbered_type_name(*args)

def create_numbered_type_reference(*args):
  """
  create_numbered_type_reference(out, ord) -> bool
  """
  return _idaapi.create_numbered_type_reference(*args)

def is_ordinal_name(*args):
  """
  is_ordinal_name(name, ord) -> bool
  """
  return _idaapi.is_ordinal_name(*args)

def get_ordinal_from_idb_type(*args):
  """
  get_ordinal_from_idb_type(name, type) -> int
  """
  return _idaapi.get_ordinal_from_idb_type(*args)

def is_autosync(*args):
  """
    is_autosync(name, type) -> bool
    is_autosync(name, tif) -> bool
    """
  return _idaapi.is_autosync(*args)

def get_referred_ordinal(*args):
  """
  get_referred_ordinal(ptype) -> uint32
  """
  return _idaapi.get_referred_ordinal(*args)

def deref_ptr2(*args):
  """
  deref_ptr2(tif, ptr_ea, closure_obj=None) -> bool
  """
  return _idaapi.deref_ptr2(*args)

def remove_tinfo_pointer(*args):
  """
  remove_tinfo_pointer(til, tif, pname) -> bool
  """
  return _idaapi.remove_tinfo_pointer(*args)

def get_stkarg_offset(*args):
  """
  get_stkarg_offset() -> int
  """
  return _idaapi.get_stkarg_offset(*args)

def import_type(*args):
  """
  import_type(til, idx, name, flags=0) -> tid_t
  """
  return _idaapi.import_type(*args)
IMPTYPE_VERBOSE = _idaapi.IMPTYPE_VERBOSE
IMPTYPE_OVERRIDE = _idaapi.IMPTYPE_OVERRIDE
IMPTYPE_LOCAL = _idaapi.IMPTYPE_LOCAL

def add_til2(*args):
  """
  add_til2(name, flags) -> int
  """
  return _idaapi.add_til2(*args)
ADDTIL_DEFAULT = _idaapi.ADDTIL_DEFAULT
ADDTIL_INCOMP = _idaapi.ADDTIL_INCOMP
ADDTIL_SILENT = _idaapi.ADDTIL_SILENT
ADDTIL_FAILED = _idaapi.ADDTIL_FAILED
ADDTIL_OK = _idaapi.ADDTIL_OK
ADDTIL_COMP = _idaapi.ADDTIL_COMP

def del_til(*args):
  """
  del_til(name) -> bool
  """
  return _idaapi.del_til(*args)

def apply_named_type(*args):
  """
  apply_named_type(ea, name) -> bool
  """
  return _idaapi.apply_named_type(*args)

def apply_tinfo2(*args):
  """
  apply_tinfo2(ea, tif, flags) -> bool
  """
  return _idaapi.apply_tinfo2(*args)
TINFO_GUESSED = _idaapi.TINFO_GUESSED
TINFO_DEFINITE = _idaapi.TINFO_DEFINITE
TINFO_DELAYFUNC = _idaapi.TINFO_DELAYFUNC

def apply_cdecl2(*args):
  """
  apply_cdecl2(til, ea, decl, flags=0) -> bool
  """
  return _idaapi.apply_cdecl2(*args)

def apply_callee_tinfo(*args):
  """
  apply_callee_tinfo(caller, tif)
  """
  return _idaapi.apply_callee_tinfo(*args)

def apply_once_tinfo_and_name(*args):
  """
  apply_once_tinfo_and_name(dea, tif, name) -> bool
  """
  return _idaapi.apply_once_tinfo_and_name(*args)

def guess_tinfo2(*args):
  """
  guess_tinfo2(id, tif) -> int
  """
  return _idaapi.guess_tinfo2(*args)
GUESS_FUNC_FAILED = _idaapi.GUESS_FUNC_FAILED
GUESS_FUNC_TRIVIAL = _idaapi.GUESS_FUNC_TRIVIAL
GUESS_FUNC_OK = _idaapi.GUESS_FUNC_OK

def set_c_header_path(*args):
  """
  set_c_header_path(incdir)
  """
  return _idaapi.set_c_header_path(*args)

def get_c_header_path(*args):
  """
  get_c_header_path() -> ssize_t
  """
  return _idaapi.get_c_header_path(*args)

def set_c_macros(*args):
  """
  set_c_macros(macros)
  """
  return _idaapi.set_c_macros(*args)

def get_c_macros(*args):
  """
  get_c_macros() -> ssize_t
  """
  return _idaapi.get_c_macros(*args)

def get_tilpath(*args):
  """
  get_tilpath(tilbuf, tilbufsize) -> char *
  """
  return _idaapi.get_tilpath(*args)

def get_idainfo_by_type3(*args):
  """
  get_idainfo_by_type3(tif, psize, pflags, mt, alsize=None) -> bool
  """
  return _idaapi.get_idainfo_by_type3(*args)
STI_PCHAR = _idaapi.STI_PCHAR
STI_PUCHAR = _idaapi.STI_PUCHAR
STI_PCCHAR = _idaapi.STI_PCCHAR
STI_PCUCHAR = _idaapi.STI_PCUCHAR
STI_PBYTE = _idaapi.STI_PBYTE
STI_PINT = _idaapi.STI_PINT
STI_PUINT = _idaapi.STI_PUINT
STI_PVOID = _idaapi.STI_PVOID
STI_PPVOID = _idaapi.STI_PPVOID
STI_PCVOID = _idaapi.STI_PCVOID
STI_ACHAR = _idaapi.STI_ACHAR
STI_AUCHAR = _idaapi.STI_AUCHAR
STI_ACCHAR = _idaapi.STI_ACCHAR
STI_ACUCHAR = _idaapi.STI_ACUCHAR
STI_FPURGING = _idaapi.STI_FPURGING
STI_FDELOP = _idaapi.STI_FDELOP
STI_MSGSEND = _idaapi.STI_MSGSEND
STI_AEABI_LCMP = _idaapi.STI_AEABI_LCMP
STI_AEABI_ULCMP = _idaapi.STI_AEABI_ULCMP
STI_DONT_USE = _idaapi.STI_DONT_USE
STI_LAST = _idaapi.STI_LAST
GTD_CALC_LAYOUT = _idaapi.GTD_CALC_LAYOUT
GTD_NO_LAYOUT = _idaapi.GTD_NO_LAYOUT
GTD_DEL_BITFLDS = _idaapi.GTD_DEL_BITFLDS
GTD_CALC_ARGLOCS = _idaapi.GTD_CALC_ARGLOCS
GTD_NO_ARGLOCS = _idaapi.GTD_NO_ARGLOCS
GTS_NESTED = _idaapi.GTS_NESTED
GTS_BASECLASS = _idaapi.GTS_BASECLASS
TERR_OK = _idaapi.TERR_OK
TERR_SAVE = _idaapi.TERR_SAVE
TERR_SERIALIZE = _idaapi.TERR_SERIALIZE
TERR_TOOLONGNAME = _idaapi.TERR_TOOLONGNAME
SUDT_SORT = _idaapi.SUDT_SORT
SUDT_ALIGN = _idaapi.SUDT_ALIGN
SUDT_GAPS = _idaapi.SUDT_GAPS
SUDT_UNEX = _idaapi.SUDT_UNEX
SUDT_FAST = _idaapi.SUDT_FAST
SUDT_CONST = _idaapi.SUDT_CONST
SUDT_VOLATILE = _idaapi.SUDT_VOLATILE
SUDT_TRUNC = _idaapi.SUDT_TRUNC

def copy_tinfo_t(*args):
  """
  copy_tinfo_t(_this, r)
  """
  return _idaapi.copy_tinfo_t(*args)

def clear_tinfo_t(*args):
  """
  clear_tinfo_t(_this)
  """
  return _idaapi.clear_tinfo_t(*args)

def create_tinfo(*args):
  """
  create_tinfo(_this, bt, bt2, ptr) -> bool
  """
  return _idaapi.create_tinfo(*args)

def verify_tinfo(*args):
  """
  verify_tinfo(typid) -> int
  """
  return _idaapi.verify_tinfo(*args)

def get_tinfo_details(*args):
  """
  get_tinfo_details(typid, bt2, buf) -> bool
  """
  return _idaapi.get_tinfo_details(*args)

def get_tinfo_size(*args):
  """
  get_tinfo_size(typid, p_effalign, gts_code) -> size_t
  """
  return _idaapi.get_tinfo_size(*args)

def get_tinfo_pdata(*args):
  """
  get_tinfo_pdata(typid, outptr, what) -> size_t
  """
  return _idaapi.get_tinfo_pdata(*args)

def get_tinfo_property(*args):
  """
  get_tinfo_property(typid, gta_prop) -> size_t
  """
  return _idaapi.get_tinfo_property(*args)

def set_tinfo_property(*args):
  """
  set_tinfo_property(tif, sta_prop, x) -> size_t
  """
  return _idaapi.set_tinfo_property(*args)

def serialize_tinfo(*args):
  """
  serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool
  """
  return _idaapi.serialize_tinfo(*args)

def deserialize_tinfo(*args):
  """
  deserialize_tinfo(tif, til, ptype, pfields, pfldcmts) -> bool
  """
  return _idaapi.deserialize_tinfo(*args)

def find_tinfo_udt_member(*args):
  """
  find_tinfo_udt_member(typid, strmem_flags, udm) -> int
  """
  return _idaapi.find_tinfo_udt_member(*args)

def print_tinfo(*args):
  """
  print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> bool
  """
  return _idaapi.print_tinfo(*args)

def dstr_tinfo(*args):
  """
  dstr_tinfo(tif) -> char const *
  """
  return _idaapi.dstr_tinfo(*args)

def visit_subtypes(*args):
  """
  visit_subtypes(visitor, out, tif, name, cmt) -> int
  """
  return _idaapi.visit_subtypes(*args)

def compare_tinfo(*args):
  """
  compare_tinfo(t1, t2, tcflags) -> bool
  """
  return _idaapi.compare_tinfo(*args)

def lexcompare_tinfo(*args):
  """
  lexcompare_tinfo(t1, t2, arg3) -> int
  """
  return _idaapi.lexcompare_tinfo(*args)

def get_stock_tinfo(*args):
  """
  get_stock_tinfo(tif, id) -> bool
  """
  return _idaapi.get_stock_tinfo(*args)

def read_tinfo_bitfield_value(*args):
  """
  read_tinfo_bitfield_value(typid, v, bitoff) -> uint64
  """
  return _idaapi.read_tinfo_bitfield_value(*args)

def write_tinfo_bitfield_value(*args):
  """
  write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64
  """
  return _idaapi.write_tinfo_bitfield_value(*args)

def get_tinfo_attr(*args):
  """
  get_tinfo_attr(typid, key, bv, all_attrs) -> bool
  """
  return _idaapi.get_tinfo_attr(*args)

def set_tinfo_attr(*args):
  """
  set_tinfo_attr(tif, ta, may_overwrite) -> bool
  """
  return _idaapi.set_tinfo_attr(*args)

def del_tinfo_attr(*args):
  """
  del_tinfo_attr(tif, key) -> bool
  """
  return _idaapi.del_tinfo_attr(*args)

def get_tinfo_attrs(*args):
  """
  get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool
  """
  return _idaapi.get_tinfo_attrs(*args)

def set_tinfo_attrs(*args):
  """
  set_tinfo_attrs(tif, ta) -> bool
  """
  return _idaapi.set_tinfo_attrs(*args)

def score_tinfo(*args):
  """
  score_tinfo(tif) -> uint32
  """
  return _idaapi.score_tinfo(*args)

def save_tinfo(*args):
  """
  save_tinfo(til, ord, name, ntf_flags, tif) -> tinfo_code_t
  """
  return _idaapi.save_tinfo(*args)
class tinfo_t(object):
    """
    Proxy of C++ tinfo_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, decl_type=BT_UNK) -> tinfo_t
        __init__(self, r) -> tinfo_t
        """
        this = _idaapi.new_tinfo_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.tinfo_t_clear(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.tinfo_t_swap(self, *args)

    def get_named_type(self, *args):
        """
        get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool
        """
        return _idaapi.tinfo_t_get_named_type(self, *args)

    def get_numbered_type(self, *args):
        """
        get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool
        """
        return _idaapi.tinfo_t_get_numbered_type(self, *args)

    def serialize(self, *args):
        """
        serialize(self, type, fields=None, fldcmts=None, sudt_flags=0x0010|0x0100) -> bool
        """
        return _idaapi.tinfo_t_serialize(self, *args)

    def is_correct(self, *args):
        """
        is_correct(self) -> bool
        """
        return _idaapi.tinfo_t_is_correct(self, *args)

    def get_realtype(self, *args):
        """
        get_realtype(self, full=False) -> type_t
        """
        return _idaapi.tinfo_t_get_realtype(self, *args)

    def get_decltype(self, *args):
        """
        get_decltype(self) -> type_t
        """
        return _idaapi.tinfo_t_get_decltype(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.tinfo_t_empty(self, *args)

    def present(self, *args):
        """
        present(self) -> bool
        """
        return _idaapi.tinfo_t_present(self, *args)

    def get_size(self, *args):
        """
        get_size(self, p_effalign=None, gts_code=0) -> size_t
        """
        return _idaapi.tinfo_t_get_size(self, *args)

    def get_unpadded_size(self, *args):
        """
        get_unpadded_size(self) -> size_t
        """
        return _idaapi.tinfo_t_get_unpadded_size(self, *args)

    def get_sign(self, *args):
        """
        get_sign(self) -> type_sign_t
        """
        return _idaapi.tinfo_t_get_sign(self, *args)

    def is_signed(self, *args):
        """
        is_signed(self) -> bool
        """
        return _idaapi.tinfo_t_is_signed(self, *args)

    def is_unsigned(self, *args):
        """
        is_unsigned(self) -> bool
        """
        return _idaapi.tinfo_t_is_unsigned(self, *args)

    def get_declalign(self, *args):
        """
        get_declalign(self) -> uchar
        """
        return _idaapi.tinfo_t_get_declalign(self, *args)

    def set_declalign(self, *args):
        """
        set_declalign(self, declalign) -> bool
        """
        return _idaapi.tinfo_t_set_declalign(self, *args)

    def is_typeref(self, *args):
        """
        is_typeref(self) -> bool
        """
        return _idaapi.tinfo_t_is_typeref(self, *args)

    def has_details(self, *args):
        """
        has_details(self) -> bool
        """
        return _idaapi.tinfo_t_has_details(self, *args)

    def get_type_name(self, *args):
        """
        get_type_name(self, name) -> bool
        """
        return _idaapi.tinfo_t_get_type_name(self, *args)

    def get_final_type_name(self, *args):
        """
        get_final_type_name(self, name) -> bool
        """
        return _idaapi.tinfo_t_get_final_type_name(self, *args)

    def get_next_type_name(self, *args):
        """
        get_next_type_name(self, name) -> bool
        """
        return _idaapi.tinfo_t_get_next_type_name(self, *args)

    def get_ordinal(self, *args):
        """
        get_ordinal(self) -> uint32
        """
        return _idaapi.tinfo_t_get_ordinal(self, *args)

    def get_final_ordinal(self, *args):
        """
        get_final_ordinal(self) -> uint32
        """
        return _idaapi.tinfo_t_get_final_ordinal(self, *args)

    def get_til(self, *args):
        """
        get_til(self) -> til_t
        """
        return _idaapi.tinfo_t_get_til(self, *args)

    def is_from_subtil(self, *args):
        """
        is_from_subtil(self) -> bool
        """
        return _idaapi.tinfo_t_is_from_subtil(self, *args)

    def is_forward_decl(self, *args):
        """
        is_forward_decl(self) -> bool
        """
        return _idaapi.tinfo_t_is_forward_decl(self, *args)

    def is_decl_const(self, *args):
        """
        is_decl_const(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_const(self, *args)

    def is_decl_volatile(self, *args):
        """
        is_decl_volatile(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_volatile(self, *args)

    def is_decl_void(self, *args):
        """
        is_decl_void(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_void(self, *args)

    def is_decl_partial(self, *args):
        """
        is_decl_partial(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_partial(self, *args)

    def is_decl_unknown(self, *args):
        """
        is_decl_unknown(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_unknown(self, *args)

    def is_decl_last(self, *args):
        """
        is_decl_last(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_last(self, *args)

    def is_decl_ptr(self, *args):
        """
        is_decl_ptr(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_ptr(self, *args)

    def is_decl_array(self, *args):
        """
        is_decl_array(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_array(self, *args)

    def is_decl_func(self, *args):
        """
        is_decl_func(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_func(self, *args)

    def is_decl_complex(self, *args):
        """
        is_decl_complex(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_complex(self, *args)

    def is_decl_typedef(self, *args):
        """
        is_decl_typedef(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_typedef(self, *args)

    def is_decl_sue(self, *args):
        """
        is_decl_sue(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_sue(self, *args)

    def is_decl_struct(self, *args):
        """
        is_decl_struct(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_struct(self, *args)

    def is_decl_union(self, *args):
        """
        is_decl_union(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_union(self, *args)

    def is_decl_udt(self, *args):
        """
        is_decl_udt(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_udt(self, *args)

    def is_decl_enum(self, *args):
        """
        is_decl_enum(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_enum(self, *args)

    def is_decl_bitfield(self, *args):
        """
        is_decl_bitfield(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_bitfield(self, *args)

    def is_decl_int128(self, *args):
        """
        is_decl_int128(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_int128(self, *args)

    def is_decl_int64(self, *args):
        """
        is_decl_int64(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_int64(self, *args)

    def is_decl_int32(self, *args):
        """
        is_decl_int32(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_int32(self, *args)

    def is_decl_int16(self, *args):
        """
        is_decl_int16(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_int16(self, *args)

    def is_decl_char(self, *args):
        """
        is_decl_char(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_char(self, *args)

    def is_decl_uint(self, *args):
        """
        is_decl_uint(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uint(self, *args)

    def is_decl_uchar(self, *args):
        """
        is_decl_uchar(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uchar(self, *args)

    def is_decl_uint16(self, *args):
        """
        is_decl_uint16(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uint16(self, *args)

    def is_decl_uint32(self, *args):
        """
        is_decl_uint32(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uint32(self, *args)

    def is_decl_uint64(self, *args):
        """
        is_decl_uint64(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uint64(self, *args)

    def is_decl_uint128(self, *args):
        """
        is_decl_uint128(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_uint128(self, *args)

    def is_decl_ldouble(self, *args):
        """
        is_decl_ldouble(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_ldouble(self, *args)

    def is_decl_double(self, *args):
        """
        is_decl_double(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_double(self, *args)

    def is_decl_float(self, *args):
        """
        is_decl_float(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_float(self, *args)

    def is_decl_floating(self, *args):
        """
        is_decl_floating(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_floating(self, *args)

    def is_decl_bool(self, *args):
        """
        is_decl_bool(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_bool(self, *args)

    def is_decl_paf(self, *args):
        """
        is_decl_paf(self) -> bool
        """
        return _idaapi.tinfo_t_is_decl_paf(self, *args)

    def is_well_defined(self, *args):
        """
        is_well_defined(self) -> bool
        """
        return _idaapi.tinfo_t_is_well_defined(self, *args)

    def is_const(self, *args):
        """
        is_const(self) -> bool
        """
        return _idaapi.tinfo_t_is_const(self, *args)

    def is_volatile(self, *args):
        """
        is_volatile(self) -> bool
        """
        return _idaapi.tinfo_t_is_volatile(self, *args)

    def is_void(self, *args):
        """
        is_void(self) -> bool
        """
        return _idaapi.tinfo_t_is_void(self, *args)

    def is_partial(self, *args):
        """
        is_partial(self) -> bool
        """
        return _idaapi.tinfo_t_is_partial(self, *args)

    def is_unknown(self, *args):
        """
        is_unknown(self) -> bool
        """
        return _idaapi.tinfo_t_is_unknown(self, *args)

    def is_ptr(self, *args):
        """
        is_ptr(self) -> bool
        """
        return _idaapi.tinfo_t_is_ptr(self, *args)

    def is_array(self, *args):
        """
        is_array(self) -> bool
        """
        return _idaapi.tinfo_t_is_array(self, *args)

    def is_func(self, *args):
        """
        is_func(self) -> bool
        """
        return _idaapi.tinfo_t_is_func(self, *args)

    def is_complex(self, *args):
        """
        is_complex(self) -> bool
        """
        return _idaapi.tinfo_t_is_complex(self, *args)

    def is_struct(self, *args):
        """
        is_struct(self) -> bool
        """
        return _idaapi.tinfo_t_is_struct(self, *args)

    def is_union(self, *args):
        """
        is_union(self) -> bool
        """
        return _idaapi.tinfo_t_is_union(self, *args)

    def is_udt(self, *args):
        """
        is_udt(self) -> bool
        """
        return _idaapi.tinfo_t_is_udt(self, *args)

    def is_enum(self, *args):
        """
        is_enum(self) -> bool
        """
        return _idaapi.tinfo_t_is_enum(self, *args)

    def is_sue(self, *args):
        """
        is_sue(self) -> bool
        """
        return _idaapi.tinfo_t_is_sue(self, *args)

    def is_bitfield(self, *args):
        """
        is_bitfield(self) -> bool
        """
        return _idaapi.tinfo_t_is_bitfield(self, *args)

    def is_int128(self, *args):
        """
        is_int128(self) -> bool
        """
        return _idaapi.tinfo_t_is_int128(self, *args)

    def is_int64(self, *args):
        """
        is_int64(self) -> bool
        """
        return _idaapi.tinfo_t_is_int64(self, *args)

    def is_int32(self, *args):
        """
        is_int32(self) -> bool
        """
        return _idaapi.tinfo_t_is_int32(self, *args)

    def is_int16(self, *args):
        """
        is_int16(self) -> bool
        """
        return _idaapi.tinfo_t_is_int16(self, *args)

    def is_char(self, *args):
        """
        is_char(self) -> bool
        """
        return _idaapi.tinfo_t_is_char(self, *args)

    def is_uint(self, *args):
        """
        is_uint(self) -> bool
        """
        return _idaapi.tinfo_t_is_uint(self, *args)

    def is_uchar(self, *args):
        """
        is_uchar(self) -> bool
        """
        return _idaapi.tinfo_t_is_uchar(self, *args)

    def is_uint16(self, *args):
        """
        is_uint16(self) -> bool
        """
        return _idaapi.tinfo_t_is_uint16(self, *args)

    def is_uint32(self, *args):
        """
        is_uint32(self) -> bool
        """
        return _idaapi.tinfo_t_is_uint32(self, *args)

    def is_uint64(self, *args):
        """
        is_uint64(self) -> bool
        """
        return _idaapi.tinfo_t_is_uint64(self, *args)

    def is_uint128(self, *args):
        """
        is_uint128(self) -> bool
        """
        return _idaapi.tinfo_t_is_uint128(self, *args)

    def is_ldouble(self, *args):
        """
        is_ldouble(self) -> bool
        """
        return _idaapi.tinfo_t_is_ldouble(self, *args)

    def is_double(self, *args):
        """
        is_double(self) -> bool
        """
        return _idaapi.tinfo_t_is_double(self, *args)

    def is_float(self, *args):
        """
        is_float(self) -> bool
        """
        return _idaapi.tinfo_t_is_float(self, *args)

    def is_bool(self, *args):
        """
        is_bool(self) -> bool
        """
        return _idaapi.tinfo_t_is_bool(self, *args)

    def is_paf(self, *args):
        """
        is_paf(self) -> bool
        """
        return _idaapi.tinfo_t_is_paf(self, *args)

    def is_ptr_or_array(self, *args):
        """
        is_ptr_or_array(self) -> bool
        """
        return _idaapi.tinfo_t_is_ptr_or_array(self, *args)

    def is_integral(self, *args):
        """
        is_integral(self) -> bool
        """
        return _idaapi.tinfo_t_is_integral(self, *args)

    def is_ext_integral(self, *args):
        """
        is_ext_integral(self) -> bool
        """
        return _idaapi.tinfo_t_is_ext_integral(self, *args)

    def is_floating(self, *args):
        """
        is_floating(self) -> bool
        """
        return _idaapi.tinfo_t_is_floating(self, *args)

    def is_arithmetic(self, *args):
        """
        is_arithmetic(self) -> bool
        """
        return _idaapi.tinfo_t_is_arithmetic(self, *args)

    def is_ext_arithmetic(self, *args):
        """
        is_ext_arithmetic(self) -> bool
        """
        return _idaapi.tinfo_t_is_ext_arithmetic(self, *args)

    def is_scalar(self, *args):
        """
        is_scalar(self) -> bool
        """
        return _idaapi.tinfo_t_is_scalar(self, *args)

    def get_ptr_details(self, *args):
        """
        get_ptr_details(self, pi) -> bool
        """
        return _idaapi.tinfo_t_get_ptr_details(self, *args)

    def get_array_details(self, *args):
        """
        get_array_details(self, ai) -> bool
        """
        return _idaapi.tinfo_t_get_array_details(self, *args)

    def get_enum_details(self, *args):
        """
        get_enum_details(self, ei) -> bool
        """
        return _idaapi.tinfo_t_get_enum_details(self, *args)

    def get_bitfield_details(self, *args):
        """
        get_bitfield_details(self, bi) -> bool
        """
        return _idaapi.tinfo_t_get_bitfield_details(self, *args)

    def get_udt_details(self, *args):
        """
        get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool
        """
        return _idaapi.tinfo_t_get_udt_details(self, *args)

    def get_func_details(self, *args):
        """
        get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool
        """
        return _idaapi.tinfo_t_get_func_details(self, *args)

    def is_funcptr(self, *args):
        """
        is_funcptr(self) -> bool
        """
        return _idaapi.tinfo_t_is_funcptr(self, *args)

    def get_ptrarr_objsize(self, *args):
        """
        get_ptrarr_objsize(self) -> int
        """
        return _idaapi.tinfo_t_get_ptrarr_objsize(self, *args)

    def get_ptrarr_object(self, *args):
        """
        get_ptrarr_object(self) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_ptrarr_object(self, *args)

    def get_pointed_object(self, *args):
        """
        get_pointed_object(self) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_pointed_object(self, *args)

    def is_pvoid(self, *args):
        """
        is_pvoid(self) -> bool
        """
        return _idaapi.tinfo_t_is_pvoid(self, *args)

    def get_array_element(self, *args):
        """
        get_array_element(self) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_array_element(self, *args)

    def get_array_nelems(self, *args):
        """
        get_array_nelems(self) -> int
        """
        return _idaapi.tinfo_t_get_array_nelems(self, *args)

    def get_nth_arg(self, *args):
        """
        get_nth_arg(self, n) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_nth_arg(self, *args)

    def get_rettype(self, *args):
        """
        get_rettype(self) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_rettype(self, *args)

    def get_nargs(self, *args):
        """
        get_nargs(self) -> int
        """
        return _idaapi.tinfo_t_get_nargs(self, *args)

    def is_user_cc(self, *args):
        """
        is_user_cc(self) -> bool
        """
        return _idaapi.tinfo_t_is_user_cc(self, *args)

    def is_vararg_cc(self, *args):
        """
        is_vararg_cc(self) -> bool
        """
        return _idaapi.tinfo_t_is_vararg_cc(self, *args)

    def is_purging_cc(self, *args):
        """
        is_purging_cc(self) -> bool
        """
        return _idaapi.tinfo_t_is_purging_cc(self, *args)

    def calc_purged_bytes(self, *args):
        """
        calc_purged_bytes(self) -> int
        """
        return _idaapi.tinfo_t_calc_purged_bytes(self, *args)

    def is_high_func(self, *args):
        """
        is_high_func(self) -> bool
        """
        return _idaapi.tinfo_t_is_high_func(self, *args)

    def find_udt_member(self, *args):
        """
        find_udt_member(self, strmem_flags, udm) -> int
        """
        return _idaapi.tinfo_t_find_udt_member(self, *args)

    def get_udt_nmembers(self, *args):
        """
        get_udt_nmembers(self) -> int
        """
        return _idaapi.tinfo_t_get_udt_nmembers(self, *args)

    def is_empty_udt(self, *args):
        """
        is_empty_udt(self) -> bool
        """
        return _idaapi.tinfo_t_is_empty_udt(self, *args)

    def is_small_udt(self, *args):
        """
        is_small_udt(self) -> bool
        """
        return _idaapi.tinfo_t_is_small_udt(self, *args)

    def is_one_fpval(self, *args):
        """
        is_one_fpval(self) -> bool
        """
        return _idaapi.tinfo_t_is_one_fpval(self, *args)

    def is_sse_type(self, *args):
        """
        is_sse_type(self) -> bool
        """
        return _idaapi.tinfo_t_is_sse_type(self, *args)

    def get_enum_base_type(self, *args):
        """
        get_enum_base_type(self) -> type_t
        """
        return _idaapi.tinfo_t_get_enum_base_type(self, *args)

    def get_onemember_type(self, *args):
        """
        get_onemember_type(self) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_onemember_type(self, *args)

    def calc_score(self, *args):
        """
        calc_score(self) -> uint32
        """
        return _idaapi.tinfo_t_calc_score(self, *args)

    def _print(self, *args):
        """
        _print(self, name=None, prtype_flags=0x0000, indent=0, cmtindent=0, prefix=None, cmt=None) -> bool
        """
        return _idaapi.tinfo_t__print(self, *args)

    def dstr(self, *args):
        """
        dstr(self) -> char const *
        """
        return _idaapi.tinfo_t_dstr(self, *args)

    def get_attrs(self, *args):
        """
        get_attrs(self, tav, all_attrs=False) -> bool
        """
        return _idaapi.tinfo_t_get_attrs(self, *args)

    def get_attr(self, *args):
        """
        get_attr(self, key, bv, all_attrs=True) -> bool
        """
        return _idaapi.tinfo_t_get_attr(self, *args)

    def set_attrs(self, *args):
        """
        set_attrs(self, tav) -> bool
        """
        return _idaapi.tinfo_t_set_attrs(self, *args)

    def set_attr(self, *args):
        """
        set_attr(self, ta, may_overwrite=True) -> bool
        """
        return _idaapi.tinfo_t_set_attr(self, *args)

    def del_attrs(self, *args):
        """
        del_attrs(self)
        """
        return _idaapi.tinfo_t_del_attrs(self, *args)

    def del_attr(self, *args):
        """
        del_attr(self, key) -> bool
        """
        return _idaapi.tinfo_t_del_attr(self, *args)

    def create_simple_type(self, *args):
        """
        create_simple_type(self, decl_type) -> bool
        """
        return _idaapi.tinfo_t_create_simple_type(self, *args)

    def create_ptr(self, *args):
        """
        create_ptr(self, p, decl_type=BT_PTR) -> bool
        create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool
        """
        return _idaapi.tinfo_t_create_ptr(self, *args)

    def create_array(self, *args):
        """
        create_array(self, p, decl_type=BT_ARRAY) -> bool
        create_array(self, tif, nelems=0, base=0, decl_type=BT_ARRAY) -> bool
        """
        return _idaapi.tinfo_t_create_array(self, *args)

    def create_typedef(self, *args):
        """
        create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool
        create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True)
        create_typedef(self, til, ord, decl_type=BTF_TYPEDEF)
        """
        return _idaapi.tinfo_t_create_typedef(self, *args)

    def create_bitfield(self, *args):
        """
        create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool
        create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool
        """
        return _idaapi.tinfo_t_create_bitfield(self, *args)

    def create_udt(self, *args):
        """
        create_udt(self, p, decl_type) -> bool
        """
        return _idaapi.tinfo_t_create_udt(self, *args)

    def create_enum(self, *args):
        """
        create_enum(self, p, decl_type=BTF_ENUM) -> bool
        """
        return _idaapi.tinfo_t_create_enum(self, *args)

    def create_func(self, *args):
        """
        create_func(self, p, decl_type=BT_FUNC) -> bool
        """
        return _idaapi.tinfo_t_create_func(self, *args)

    def set_numbered_type(self, *args):
        """
        set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t
        """
        return _idaapi.tinfo_t_set_numbered_type(self, *args)

    def create_forward_decl(self, *args):
        """
        create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> bool
        """
        return _idaapi.tinfo_t_create_forward_decl(self, *args)

    def get_stock(*args):
        """
        get_stock(id) -> tinfo_t
        """
        return _idaapi.tinfo_t_get_stock(*args)

    get_stock = staticmethod(get_stock)
    def convert_array_to_ptr(self, *args):
        """
        convert_array_to_ptr(self) -> bool
        """
        return _idaapi.tinfo_t_convert_array_to_ptr(self, *args)

    def remove_ptr_or_array(self, *args):
        """
        remove_ptr_or_array(self) -> bool
        """
        return _idaapi.tinfo_t_remove_ptr_or_array(self, *args)

    def change_sign(self, *args):
        """
        change_sign(self, sign) -> bool
        """
        return _idaapi.tinfo_t_change_sign(self, *args)

    def calc_udt_aligns(self, *args):
        """
        calc_udt_aligns(self, sudt_flags=0x0004) -> bool
        """
        return _idaapi.tinfo_t_calc_udt_aligns(self, *args)

    def read_bitfield_value(self, *args):
        """
        read_bitfield_value(self, v, bitoff) -> uint64
        """
        return _idaapi.tinfo_t_read_bitfield_value(self, *args)

    def write_bitfield_value(self, *args):
        """
        write_bitfield_value(self, dst, v, bitoff) -> uint64
        """
        return _idaapi.tinfo_t_write_bitfield_value(self, *args)

    def get_modifiers(self, *args):
        """
        get_modifiers(self) -> type_t
        """
        return _idaapi.tinfo_t_get_modifiers(self, *args)

    def set_modifiers(self, *args):
        """
        set_modifiers(self, mod)
        """
        return _idaapi.tinfo_t_set_modifiers(self, *args)

    def set_const(self, *args):
        """
        set_const(self)
        """
        return _idaapi.tinfo_t_set_const(self, *args)

    def set_volatile(self, *args):
        """
        set_volatile(self)
        """
        return _idaapi.tinfo_t_set_volatile(self, *args)

    def clr_const(self, *args):
        """
        clr_const(self)
        """
        return _idaapi.tinfo_t_clr_const(self, *args)

    def clr_volatile(self, *args):
        """
        clr_volatile(self)
        """
        return _idaapi.tinfo_t_clr_volatile(self, *args)

    def clr_const_volatile(self, *args):
        """
        clr_const_volatile(self)
        """
        return _idaapi.tinfo_t_clr_const_volatile(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.tinfo_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.tinfo_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.tinfo_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.tinfo_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.tinfo_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.tinfo_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.tinfo_t_compare(self, *args)

    def compare_with(self, *args):
        """
        compare_with(self, r, tcflags=0) -> bool
        """
        return _idaapi.tinfo_t_compare_with(self, *args)

    def equals_to(self, *args):
        """
        equals_to(self, r) -> bool
        """
        return _idaapi.tinfo_t_equals_to(self, *args)

    def is_castable_to(self, *args):
        """
        is_castable_to(self, target) -> bool
        """
        return _idaapi.tinfo_t_is_castable_to(self, *args)

    def is_manually_castable_to(self, *args):
        """
        is_manually_castable_to(self, target) -> bool
        """
        return _idaapi.tinfo_t_is_manually_castable_to(self, *args)

    def deserialize(self, *args):
        """
        deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool
        deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool
        deserialize(self, til, type, fields, cmts=None) -> bool
        deserialize(self, til, _type, _fields, _cmts=None) -> bool
        """
        return _idaapi.tinfo_t_deserialize(self, *args)

    __swig_destroy__ = _idaapi.delete_tinfo_t
    __del__ = lambda self : None;
tinfo_t_swigregister = _idaapi.tinfo_t_swigregister
tinfo_t_swigregister(tinfo_t)
C_PC_TINY = cvar.C_PC_TINY
C_PC_SMALL = cvar.C_PC_SMALL
C_PC_COMPACT = cvar.C_PC_COMPACT
C_PC_MEDIUM = cvar.C_PC_MEDIUM
C_PC_LARGE = cvar.C_PC_LARGE
C_PC_HUGE = cvar.C_PC_HUGE
C_PC_FLAT = cvar.C_PC_FLAT
COMP_MASK = cvar.COMP_MASK
COMP_UNK = cvar.COMP_UNK
COMP_MS = cvar.COMP_MS
COMP_BC = cvar.COMP_BC
COMP_WATCOM = cvar.COMP_WATCOM
COMP_GNU = cvar.COMP_GNU
COMP_VISAGE = cvar.COMP_VISAGE
COMP_BP = cvar.COMP_BP
COMP_UNSURE = cvar.COMP_UNSURE
BADSIZE = cvar.BADSIZE
BADORD = cvar.BADORD
FIRST_NONTRIVIAL_TYPID = cvar.FIRST_NONTRIVIAL_TYPID
TYPID_ISREF = cvar.TYPID_ISREF
TYPID_SHIFT = cvar.TYPID_SHIFT

def remove_pointer(*args):
  """
  remove_pointer(tif) -> tinfo_t
  """
  return _idaapi.remove_pointer(*args)
STRMEM_MASK = _idaapi.STRMEM_MASK
STRMEM_OFFSET = _idaapi.STRMEM_OFFSET
STRMEM_INDEX = _idaapi.STRMEM_INDEX
STRMEM_AUTO = _idaapi.STRMEM_AUTO
STRMEM_NAME = _idaapi.STRMEM_NAME
STRMEM_TYPE = _idaapi.STRMEM_TYPE
STRMEM_SIZE = _idaapi.STRMEM_SIZE
STRMEM_MINS = _idaapi.STRMEM_MINS
STRMEM_MAXS = _idaapi.STRMEM_MAXS
STRMEM_ANON = _idaapi.STRMEM_ANON
STRMEM_CASTABLE_TO = _idaapi.STRMEM_CASTABLE_TO

def tinfo_t_get_stock(*args):
  """
  tinfo_t_get_stock(id) -> tinfo_t
  """
  return _idaapi.tinfo_t_get_stock(*args)
TCMP_EQUAL = _idaapi.TCMP_EQUAL
TCMP_IGNMODS = _idaapi.TCMP_IGNMODS
TCMP_AUTOCAST = _idaapi.TCMP_AUTOCAST
TCMP_MANCAST = _idaapi.TCMP_MANCAST
TCMP_CALL = _idaapi.TCMP_CALL
TCMP_DELPTR = _idaapi.TCMP_DELPTR
TCMP_DECL = _idaapi.TCMP_DECL


def guess_func_cc(*args):
  """
  guess_func_cc(fti, npurged, cc_flags) -> cm_t
  """
  return _idaapi.guess_func_cc(*args)

def dump_func_type_data(*args):
  """
  dump_func_type_data(fti, praloc_bits) -> bool
  """
  return _idaapi.dump_func_type_data(*args)
class ptr_type_data_t(object):
    """
    Proxy of C++ ptr_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    obj_type = _swig_property(_idaapi.ptr_type_data_t_obj_type_get, _idaapi.ptr_type_data_t_obj_type_set)
    closure = _swig_property(_idaapi.ptr_type_data_t_closure_get, _idaapi.ptr_type_data_t_closure_set)
    based_ptr_size = _swig_property(_idaapi.ptr_type_data_t_based_ptr_size_get, _idaapi.ptr_type_data_t_based_ptr_size_set)
    taptr_bits = _swig_property(_idaapi.ptr_type_data_t_taptr_bits_get, _idaapi.ptr_type_data_t_taptr_bits_set)
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.ptr_type_data_t_swap(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.ptr_type_data_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.ptr_type_data_t___ne__(self, *args)

    def is_code_ptr(self, *args):
        """
        is_code_ptr(self) -> bool
        """
        return _idaapi.ptr_type_data_t_is_code_ptr(self, *args)

    def __init__(self, *args):
        """
        __init__(self, c=tinfo_t(), bps=0) -> ptr_type_data_t
        """
        this = _idaapi.new_ptr_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ptr_type_data_t
    __del__ = lambda self : None;
ptr_type_data_t_swigregister = _idaapi.ptr_type_data_t_swigregister
ptr_type_data_t_swigregister(ptr_type_data_t)

class array_type_data_t(object):
    """
    Proxy of C++ array_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    elem_type = _swig_property(_idaapi.array_type_data_t_elem_type_get, _idaapi.array_type_data_t_elem_type_set)
    base = _swig_property(_idaapi.array_type_data_t_base_get, _idaapi.array_type_data_t_base_set)
    nelems = _swig_property(_idaapi.array_type_data_t_nelems_get, _idaapi.array_type_data_t_nelems_set)
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.array_type_data_t_swap(self, *args)

    def __init__(self, *args):
        """
        __init__(self, b=0, n=0) -> array_type_data_t
        """
        this = _idaapi.new_array_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_array_type_data_t
    __del__ = lambda self : None;
array_type_data_t_swigregister = _idaapi.array_type_data_t_swigregister
array_type_data_t_swigregister(array_type_data_t)

class funcarg_t(object):
    """
    Proxy of C++ funcarg_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    argloc = _swig_property(_idaapi.funcarg_t_argloc_get, _idaapi.funcarg_t_argloc_set)
    name = _swig_property(_idaapi.funcarg_t_name_get, _idaapi.funcarg_t_name_set)
    cmt = _swig_property(_idaapi.funcarg_t_cmt_get, _idaapi.funcarg_t_cmt_set)
    type = _swig_property(_idaapi.funcarg_t_type_get, _idaapi.funcarg_t_type_set)
    flags = _swig_property(_idaapi.funcarg_t_flags_get, _idaapi.funcarg_t_flags_set)
    def __init__(self, *args):
        """
        __init__(self) -> funcarg_t
        """
        this = _idaapi.new_funcarg_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.funcarg_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.funcarg_t___ne__(self, *args)

    __swig_destroy__ = _idaapi.delete_funcarg_t
    __del__ = lambda self : None;
funcarg_t_swigregister = _idaapi.funcarg_t_swigregister
funcarg_t_swigregister(funcarg_t)
FAI_HIDDEN = _idaapi.FAI_HIDDEN
FAI_RETPTR = _idaapi.FAI_RETPTR
FAI_STRUCT = _idaapi.FAI_STRUCT
FAI_ARRAY = _idaapi.FAI_ARRAY
TA_ORG_TYPEDEF = _idaapi.TA_ORG_TYPEDEF
TA_ORG_ARRDIM = _idaapi.TA_ORG_ARRDIM

class func_type_data_t(funcargvec_t):
    """
    Proxy of C++ func_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.func_type_data_t_flags_get, _idaapi.func_type_data_t_flags_set)
    rettype = _swig_property(_idaapi.func_type_data_t_rettype_get, _idaapi.func_type_data_t_rettype_set)
    retloc = _swig_property(_idaapi.func_type_data_t_retloc_get, _idaapi.func_type_data_t_retloc_set)
    stkargs = _swig_property(_idaapi.func_type_data_t_stkargs_get, _idaapi.func_type_data_t_stkargs_set)
    spoiled = _swig_property(_idaapi.func_type_data_t_spoiled_get, _idaapi.func_type_data_t_spoiled_set)
    cc = _swig_property(_idaapi.func_type_data_t_cc_get, _idaapi.func_type_data_t_cc_set)
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.func_type_data_t_swap(self, *args)

    def is_high(self, *args):
        """
        is_high(self) -> bool
        """
        return _idaapi.func_type_data_t_is_high(self, *args)

    def get_call_method(self, *args):
        """
        get_call_method(self) -> int
        """
        return _idaapi.func_type_data_t_get_call_method(self, *args)

    def is_vararg_cc(self, *args):
        """
        is_vararg_cc(self) -> bool
        """
        return _idaapi.func_type_data_t_is_vararg_cc(self, *args)

    def guess_cc(self, *args):
        """
        guess_cc(self, purged, cc_flags) -> cm_t
        """
        return _idaapi.func_type_data_t_guess_cc(self, *args)

    def dump(self, *args):
        """
        dump(self, praloc_bits=0x02) -> bool
        """
        return _idaapi.func_type_data_t_dump(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> func_type_data_t
        """
        this = _idaapi.new_func_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_func_type_data_t
    __del__ = lambda self : None;
func_type_data_t_swigregister = _idaapi.func_type_data_t_swigregister
func_type_data_t_swigregister(func_type_data_t)
FTI_SPOILED = _idaapi.FTI_SPOILED
FTI_NORET = _idaapi.FTI_NORET
FTI_PURE = _idaapi.FTI_PURE
FTI_HIGH = _idaapi.FTI_HIGH
FTI_STATIC = _idaapi.FTI_STATIC
FTI_VIRTUAL = _idaapi.FTI_VIRTUAL
FTI_CALLTYPE = _idaapi.FTI_CALLTYPE
FTI_DEFCALL = _idaapi.FTI_DEFCALL
FTI_NEARCALL = _idaapi.FTI_NEARCALL
FTI_FARCALL = _idaapi.FTI_FARCALL
FTI_INTCALL = _idaapi.FTI_INTCALL
FTI_ARGLOCS = _idaapi.FTI_ARGLOCS
FTI_ALL = _idaapi.FTI_ALL
CC_CDECL_OK = _idaapi.CC_CDECL_OK
CC_ALLOW_ARGPERM = _idaapi.CC_ALLOW_ARGPERM
CC_ALLOW_REGHOLES = _idaapi.CC_ALLOW_REGHOLES
CC_HAS_ELLIPSIS = _idaapi.CC_HAS_ELLIPSIS

class enum_member_t(object):
    """
    Proxy of C++ enum_member_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.enum_member_t_name_get, _idaapi.enum_member_t_name_set)
    cmt = _swig_property(_idaapi.enum_member_t_cmt_get, _idaapi.enum_member_t_cmt_set)
    value = _swig_property(_idaapi.enum_member_t_value_get, _idaapi.enum_member_t_value_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.enum_member_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.enum_member_t___ne__(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.enum_member_t_swap(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> enum_member_t
        """
        this = _idaapi.new_enum_member_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_enum_member_t
    __del__ = lambda self : None;
enum_member_t_swigregister = _idaapi.enum_member_t_swigregister
enum_member_t_swigregister(enum_member_t)

class enum_type_data_t(object):
    """
    Proxy of C++ enum_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    group_sizes = _swig_property(_idaapi.enum_type_data_t_group_sizes_get, _idaapi.enum_type_data_t_group_sizes_set)
    taenum_bits = _swig_property(_idaapi.enum_type_data_t_taenum_bits_get, _idaapi.enum_type_data_t_taenum_bits_set)
    bte = _swig_property(_idaapi.enum_type_data_t_bte_get, _idaapi.enum_type_data_t_bte_set)
    def __init__(self, *args):
        """
        __init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t
        """
        this = _idaapi.new_enum_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_64bit(self, *args):
        """
        is_64bit(self) -> bool
        """
        return _idaapi.enum_type_data_t_is_64bit(self, *args)

    def is_hex(self, *args):
        """
        is_hex(self) -> bool
        """
        return _idaapi.enum_type_data_t_is_hex(self, *args)

    def is_char(self, *args):
        """
        is_char(self) -> bool
        """
        return _idaapi.enum_type_data_t_is_char(self, *args)

    def is_sdec(self, *args):
        """
        is_sdec(self) -> bool
        """
        return _idaapi.enum_type_data_t_is_sdec(self, *args)

    def is_udec(self, *args):
        """
        is_udec(self) -> bool
        """
        return _idaapi.enum_type_data_t_is_udec(self, *args)

    def calc_nbytes(self, *args):
        """
        calc_nbytes(self) -> int
        """
        return _idaapi.enum_type_data_t_calc_nbytes(self, *args)

    def calc_mask(self, *args):
        """
        calc_mask(self) -> uint64
        """
        return _idaapi.enum_type_data_t_calc_mask(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.enum_type_data_t_swap(self, *args)

    __swig_destroy__ = _idaapi.delete_enum_type_data_t
    __del__ = lambda self : None;
enum_type_data_t_swigregister = _idaapi.enum_type_data_t_swigregister
enum_type_data_t_swigregister(enum_type_data_t)

class typedef_type_data_t(object):
    """
    Proxy of C++ typedef_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    til = _swig_property(_idaapi.typedef_type_data_t_til_get, _idaapi.typedef_type_data_t_til_set)
    is_ordref = _swig_property(_idaapi.typedef_type_data_t_is_ordref_get, _idaapi.typedef_type_data_t_is_ordref_set)
    resolve = _swig_property(_idaapi.typedef_type_data_t_resolve_get, _idaapi.typedef_type_data_t_resolve_set)
    def __init__(self, *args):
        """
        __init__(self, _til, _name, _resolve=False) -> typedef_type_data_t
        __init__(self, _til, ord, _resolve=False) -> typedef_type_data_t
        """
        this = _idaapi.new_typedef_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.typedef_type_data_t_swap(self, *args)

    __swig_destroy__ = _idaapi.delete_typedef_type_data_t
    __del__ = lambda self : None;
typedef_type_data_t_swigregister = _idaapi.typedef_type_data_t_swigregister
typedef_type_data_t_swigregister(typedef_type_data_t)

class udt_member_t(object):
    """
    Proxy of C++ udt_member_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    offset = _swig_property(_idaapi.udt_member_t_offset_get, _idaapi.udt_member_t_offset_set)
    size = _swig_property(_idaapi.udt_member_t_size_get, _idaapi.udt_member_t_size_set)
    name = _swig_property(_idaapi.udt_member_t_name_get, _idaapi.udt_member_t_name_set)
    cmt = _swig_property(_idaapi.udt_member_t_cmt_get, _idaapi.udt_member_t_cmt_set)
    type = _swig_property(_idaapi.udt_member_t_type_get, _idaapi.udt_member_t_type_set)
    effalign = _swig_property(_idaapi.udt_member_t_effalign_get, _idaapi.udt_member_t_effalign_set)
    tafld_bits = _swig_property(_idaapi.udt_member_t_tafld_bits_get, _idaapi.udt_member_t_tafld_bits_set)
    fda = _swig_property(_idaapi.udt_member_t_fda_get, _idaapi.udt_member_t_fda_set)
    def __init__(self, *args):
        """
        __init__(self) -> udt_member_t
        """
        this = _idaapi.new_udt_member_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_bitfield(self, *args):
        """
        is_bitfield(self) -> bool
        """
        return _idaapi.udt_member_t_is_bitfield(self, *args)

    def is_zero_bitfield(self, *args):
        """
        is_zero_bitfield(self) -> bool
        """
        return _idaapi.udt_member_t_is_zero_bitfield(self, *args)

    def is_unaligned(self, *args):
        """
        is_unaligned(self) -> bool
        """
        return _idaapi.udt_member_t_is_unaligned(self, *args)

    def is_baseclass(self, *args):
        """
        is_baseclass(self) -> bool
        """
        return _idaapi.udt_member_t_is_baseclass(self, *args)

    def is_virtbase(self, *args):
        """
        is_virtbase(self) -> bool
        """
        return _idaapi.udt_member_t_is_virtbase(self, *args)

    def set_unaligned(self, *args):
        """
        set_unaligned(self)
        """
        return _idaapi.udt_member_t_set_unaligned(self, *args)

    def set_baseclass(self, *args):
        """
        set_baseclass(self)
        """
        return _idaapi.udt_member_t_set_baseclass(self, *args)

    def set_virtbase(self, *args):
        """
        set_virtbase(self)
        """
        return _idaapi.udt_member_t_set_virtbase(self, *args)

    def clr_unaligned(self, *args):
        """
        clr_unaligned(self)
        """
        return _idaapi.udt_member_t_clr_unaligned(self, *args)

    def clr_baseclass(self, *args):
        """
        clr_baseclass(self)
        """
        return _idaapi.udt_member_t_clr_baseclass(self, *args)

    def clr_virtbase(self, *args):
        """
        clr_virtbase(self)
        """
        return _idaapi.udt_member_t_clr_virtbase(self, *args)

    def begin(self, *args):
        """
        begin(self) -> uint64
        """
        return _idaapi.udt_member_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> uint64
        """
        return _idaapi.udt_member_t_end(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.udt_member_t___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.udt_member_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.udt_member_t___ne__(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.udt_member_t_swap(self, *args)

    __swig_destroy__ = _idaapi.delete_udt_member_t
    __del__ = lambda self : None;
udt_member_t_swigregister = _idaapi.udt_member_t_swigregister
udt_member_t_swigregister(udt_member_t)

class udt_type_data_t(udtmembervec_t):
    """
    Proxy of C++ udt_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    total_size = _swig_property(_idaapi.udt_type_data_t_total_size_get, _idaapi.udt_type_data_t_total_size_set)
    unpadded_size = _swig_property(_idaapi.udt_type_data_t_unpadded_size_get, _idaapi.udt_type_data_t_unpadded_size_set)
    effalign = _swig_property(_idaapi.udt_type_data_t_effalign_get, _idaapi.udt_type_data_t_effalign_set)
    taudt_bits = _swig_property(_idaapi.udt_type_data_t_taudt_bits_get, _idaapi.udt_type_data_t_taudt_bits_set)
    sda = _swig_property(_idaapi.udt_type_data_t_sda_get, _idaapi.udt_type_data_t_sda_set)
    pack = _swig_property(_idaapi.udt_type_data_t_pack_get, _idaapi.udt_type_data_t_pack_set)
    is_union = _swig_property(_idaapi.udt_type_data_t_is_union_get, _idaapi.udt_type_data_t_is_union_set)
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.udt_type_data_t_swap(self, *args)

    def is_unaligned(self, *args):
        """
        is_unaligned(self) -> bool
        """
        return _idaapi.udt_type_data_t_is_unaligned(self, *args)

    def is_msstruct(self, *args):
        """
        is_msstruct(self) -> bool
        """
        return _idaapi.udt_type_data_t_is_msstruct(self, *args)

    def is_cppobj(self, *args):
        """
        is_cppobj(self) -> bool
        """
        return _idaapi.udt_type_data_t_is_cppobj(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> udt_type_data_t
        """
        this = _idaapi.new_udt_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_udt_type_data_t
    __del__ = lambda self : None;
udt_type_data_t_swigregister = _idaapi.udt_type_data_t_swigregister
udt_type_data_t_swigregister(udt_type_data_t)

class bitfield_type_data_t(object):
    """
    Proxy of C++ bitfield_type_data_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nbytes = _swig_property(_idaapi.bitfield_type_data_t_nbytes_get, _idaapi.bitfield_type_data_t_nbytes_set)
    width = _swig_property(_idaapi.bitfield_type_data_t_width_get, _idaapi.bitfield_type_data_t_width_set)
    is_unsigned = _swig_property(_idaapi.bitfield_type_data_t_is_unsigned_get, _idaapi.bitfield_type_data_t_is_unsigned_set)
    def __init__(self, *args):
        """
        __init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t
        """
        this = _idaapi.new_bitfield_type_data_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.bitfield_type_data_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.bitfield_type_data_t_compare(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.bitfield_type_data_t_swap(self, *args)

    __swig_destroy__ = _idaapi.delete_bitfield_type_data_t
    __del__ = lambda self : None;
bitfield_type_data_t_swigregister = _idaapi.bitfield_type_data_t_swigregister
bitfield_type_data_t_swigregister(bitfield_type_data_t)

class type_mods_t(object):
    """
    Proxy of C++ type_mods_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = _swig_property(_idaapi.type_mods_t_type_get, _idaapi.type_mods_t_type_set)
    name = _swig_property(_idaapi.type_mods_t_name_get, _idaapi.type_mods_t_name_set)
    cmt = _swig_property(_idaapi.type_mods_t_cmt_get, _idaapi.type_mods_t_cmt_set)
    flags = _swig_property(_idaapi.type_mods_t_flags_get, _idaapi.type_mods_t_flags_set)
    def __init__(self, *args):
        """
        __init__(self) -> type_mods_t
        """
        this = _idaapi.new_type_mods_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.type_mods_t_clear(self, *args)

    def set_new_type(self, *args):
        """
        set_new_type(self, t)
        """
        return _idaapi.type_mods_t_set_new_type(self, *args)

    def set_new_name(self, *args):
        """
        set_new_name(self, n)
        """
        return _idaapi.type_mods_t_set_new_name(self, *args)

    def set_new_cmt(self, *args):
        """
        set_new_cmt(self, c)
        """
        return _idaapi.type_mods_t_set_new_cmt(self, *args)

    def has_type(self, *args):
        """
        has_type(self) -> bool
        """
        return _idaapi.type_mods_t_has_type(self, *args)

    def has_name(self, *args):
        """
        has_name(self) -> bool
        """
        return _idaapi.type_mods_t_has_name(self, *args)

    def has_cmt(self, *args):
        """
        has_cmt(self) -> bool
        """
        return _idaapi.type_mods_t_has_cmt(self, *args)

    def has_info(self, *args):
        """
        has_info(self) -> bool
        """
        return _idaapi.type_mods_t_has_info(self, *args)

    __swig_destroy__ = _idaapi.delete_type_mods_t
    __del__ = lambda self : None;
type_mods_t_swigregister = _idaapi.type_mods_t_swigregister
type_mods_t_swigregister(type_mods_t)
TVIS_TYPE = _idaapi.TVIS_TYPE
TVIS_NAME = _idaapi.TVIS_NAME
TVIS_CMT = _idaapi.TVIS_CMT

class tinfo_visitor_t(object):
    """
    Proxy of C++ tinfo_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    state = _swig_property(_idaapi.tinfo_visitor_t_state_get, _idaapi.tinfo_visitor_t_state_set)
    def visit_type(self, *args):
        """
        visit_type(self, out, tif, name, cmt) -> int
        """
        return _idaapi.tinfo_visitor_t_visit_type(self, *args)

    def prune_now(self, *args):
        """
        prune_now(self)
        """
        return _idaapi.tinfo_visitor_t_prune_now(self, *args)

    def apply_to(self, *args):
        """
        apply_to(self, tif, out=None, name=None, cmt=None) -> int
        """
        return _idaapi.tinfo_visitor_t_apply_to(self, *args)

    __swig_destroy__ = _idaapi.delete_tinfo_visitor_t
    __del__ = lambda self : None;
tinfo_visitor_t_swigregister = _idaapi.tinfo_visitor_t_swigregister
tinfo_visitor_t_swigregister(tinfo_visitor_t)
TVST_PRUNE = _idaapi.TVST_PRUNE
TVST_DEF = _idaapi.TVST_DEF

class regobj_t(object):
    """
    Proxy of C++ regobj_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    regidx = _swig_property(_idaapi.regobj_t_regidx_get, _idaapi.regobj_t_regidx_set)
    relocate = _swig_property(_idaapi.regobj_t_relocate_get, _idaapi.regobj_t_relocate_set)
    value = _swig_property(_idaapi.regobj_t_value_get, _idaapi.regobj_t_value_set)
    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.regobj_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> regobj_t
        """
        this = _idaapi.new_regobj_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_regobj_t
    __del__ = lambda self : None;
regobj_t_swigregister = _idaapi.regobj_t_swigregister
regobj_t_swigregister(regobj_t)

class regobjs_t(object):
    """
    Proxy of C++ regobjs_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> regobjs_t
        """
        this = _idaapi.new_regobjs_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_regobjs_t
    __del__ = lambda self : None;
regobjs_t_swigregister = _idaapi.regobjs_t_swigregister
regobjs_t_swigregister(regobjs_t)


def unpack_idcobj_from_idb(*args):
  """
  unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t
  """
  return _idaapi.unpack_idcobj_from_idb(*args)
PIO_NOATTR_FAIL = _idaapi.PIO_NOATTR_FAIL
PIO_IGNORE_PTRS = _idaapi.PIO_IGNORE_PTRS

def unpack_idcobj_from_bv(*args):
  """
  unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t
  """
  return _idaapi.unpack_idcobj_from_bv(*args)

def pack_idcobj_to_idb(*args):
  """
  pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t
  """
  return _idaapi.pack_idcobj_to_idb(*args)

def pack_idcobj_to_bv(*args):
  """
  pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t
  """
  return _idaapi.pack_idcobj_to_bv(*args)
class get_strmem_t(object):
    """
    Proxy of C++ get_strmem_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.get_strmem_t_flags_get, _idaapi.get_strmem_t_flags_set)
    index = _swig_property(_idaapi.get_strmem_t_index_get, _idaapi.get_strmem_t_index_set)
    offset = _swig_property(_idaapi.get_strmem_t_offset_get, _idaapi.get_strmem_t_offset_set)
    delta = _swig_property(_idaapi.get_strmem_t_delta_get, _idaapi.get_strmem_t_delta_set)
    name = _swig_property(_idaapi.get_strmem_t_name_get, _idaapi.get_strmem_t_name_set)
    ftype = _swig_property(_idaapi.get_strmem_t_ftype_get, _idaapi.get_strmem_t_ftype_set)
    fnames = _swig_property(_idaapi.get_strmem_t_fnames_get, _idaapi.get_strmem_t_fnames_set)
    sname = _swig_property(_idaapi.get_strmem_t_sname_get, _idaapi.get_strmem_t_sname_set)
    def __init__(self, *args):
        """
        __init__(self) -> get_strmem_t
        """
        this = _idaapi.new_get_strmem_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_get_strmem_t
    __del__ = lambda self : None;
get_strmem_t_swigregister = _idaapi.get_strmem_t_swigregister
get_strmem_t_swigregister(get_strmem_t)


def get_strmem2(*args):
  """
  get_strmem2(til, type, fields, info) -> bool
  """
  return _idaapi.get_strmem2(*args)

def apply_tinfo_to_stkarg(*args):
  """
  apply_tinfo_to_stkarg(x, v, tif, name) -> bool
  """
  return _idaapi.apply_tinfo_to_stkarg(*args)

def gen_use_arg_tinfos(*args):
  """
  gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot)
  """
  return _idaapi.gen_use_arg_tinfos(*args)
UTP_ENUM = _idaapi.UTP_ENUM
UTP_STRUCT = _idaapi.UTP_STRUCT

def func_has_stkframe_hole(*args):
  """
  func_has_stkframe_hole(ea, fti) -> bool
  """
  return _idaapi.func_has_stkframe_hole(*args)
class lowertype_helper_t(object):
    """
    Proxy of C++ lowertype_helper_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def func_has_stkframe_hole(self, *args):
        """
        func_has_stkframe_hole(self, candidate, candidate_data) -> bool
        """
        return _idaapi.lowertype_helper_t_func_has_stkframe_hole(self, *args)

    def get_func_purged_bytes(self, *args):
        """
        get_func_purged_bytes(self, candidate, candidate_data) -> int
        """
        return _idaapi.lowertype_helper_t_get_func_purged_bytes(self, *args)

    __swig_destroy__ = _idaapi.delete_lowertype_helper_t
    __del__ = lambda self : None;
lowertype_helper_t_swigregister = _idaapi.lowertype_helper_t_swigregister
lowertype_helper_t_swigregister(lowertype_helper_t)

class ida_lowertype_helper_t(lowertype_helper_t):
    """
    Proxy of C++ ida_lowertype_helper_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _tif, _ea, _pb) -> ida_lowertype_helper_t
        """
        this = _idaapi.new_ida_lowertype_helper_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def func_has_stkframe_hole(self, *args):
        """
        func_has_stkframe_hole(self, candidate, candidate_data) -> bool
        """
        return _idaapi.ida_lowertype_helper_t_func_has_stkframe_hole(self, *args)

    def get_func_purged_bytes(self, *args):
        """
        get_func_purged_bytes(self, candidate, arg3) -> int
        """
        return _idaapi.ida_lowertype_helper_t_get_func_purged_bytes(self, *args)

    __swig_destroy__ = _idaapi.delete_ida_lowertype_helper_t
    __del__ = lambda self : None;
ida_lowertype_helper_t_swigregister = _idaapi.ida_lowertype_helper_t_swigregister
ida_lowertype_helper_t_swigregister(ida_lowertype_helper_t)


def lower_type2(*args):
  """
  lower_type2(til, tif, name=None, helper=None) -> int
  """
  return _idaapi.lower_type2(*args)

def begin_type_updating(*args):
  """
  begin_type_updating(utp)
  """
  return _idaapi.begin_type_updating(*args)

def end_type_updating(*args):
  """
  end_type_updating(utp)
  """
  return _idaapi.end_type_updating(*args)
class valstr_t(object):
    """
    Proxy of C++ valstr_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    oneline = _swig_property(_idaapi.valstr_t_oneline_get, _idaapi.valstr_t_oneline_set)
    length = _swig_property(_idaapi.valstr_t_length_get, _idaapi.valstr_t_length_set)
    members = _swig_property(_idaapi.valstr_t_members_get, _idaapi.valstr_t_members_set)
    info = _swig_property(_idaapi.valstr_t_info_get, _idaapi.valstr_t_info_set)
    props = _swig_property(_idaapi.valstr_t_props_get, _idaapi.valstr_t_props_set)
    def __init__(self, *args):
        """
        __init__(self) -> valstr_t
        """
        this = _idaapi.new_valstr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_valstr_t
    __del__ = lambda self : None;
valstr_t_swigregister = _idaapi.valstr_t_swigregister
valstr_t_swigregister(valstr_t)
VALSTR_OPEN = _idaapi.VALSTR_OPEN

class valstrs_t(object):
    """
    Proxy of C++ valstrs_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> valstrs_t
        """
        this = _idaapi.new_valstrs_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_valstrs_t
    __del__ = lambda self : None;
valstrs_t_swigregister = _idaapi.valstrs_t_swigregister
valstrs_t_swigregister(valstrs_t)

class text_sink_t(object):
    """
    Proxy of C++ text_sink_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def _print(self, *args):
        """
        _print(self, str) -> int
        """
        return _idaapi.text_sink_t__print(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> text_sink_t
        """
        if self.__class__ == text_sink_t:
            _self = None
        else:
            _self = self
        this = _idaapi.new_text_sink_t(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_text_sink_t
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_text_sink_t(self)
        return weakref_proxy(self)
text_sink_t_swigregister = _idaapi.text_sink_t_swigregister
text_sink_t_swigregister(text_sink_t)

PDF_INCL_DEPS = _idaapi.PDF_INCL_DEPS
PDF_DEF_FWD = _idaapi.PDF_DEF_FWD
PDF_DEF_BASE = _idaapi.PDF_DEF_BASE

def calc_number_of_children(*args):
  """
  calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int
  """
  return _idaapi.calc_number_of_children(*args)
PCN_RADIX = _idaapi.PCN_RADIX
PCN_DEC = _idaapi.PCN_DEC
PCN_HEX = _idaapi.PCN_HEX
PCN_OCT = _idaapi.PCN_OCT
PCN_CHR = _idaapi.PCN_CHR
PCN_UNSIGNED = _idaapi.PCN_UNSIGNED
PCN_LZHEX = _idaapi.PCN_LZHEX
PCN_NEGSIGN = _idaapi.PCN_NEGSIGN

def get_enum_member_expr2(*args):
  """
  get_enum_member_expr2(tif, serial, value) -> bool
  """
  return _idaapi.get_enum_member_expr2(*args)
class til_symbol_t(object):
    """
    Proxy of C++ til_symbol_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.til_symbol_t_name_get, _idaapi.til_symbol_t_name_set)
    til = _swig_property(_idaapi.til_symbol_t_til_get, _idaapi.til_symbol_t_til_set)
    def __init__(self, *args):
        """
        __init__(self, n=None, t=None) -> til_symbol_t
        """
        this = _idaapi.new_til_symbol_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_til_symbol_t
    __del__ = lambda self : None;
til_symbol_t_swigregister = _idaapi.til_symbol_t_swigregister
til_symbol_t_swigregister(til_symbol_t)


def choose_named_type2(*args):
  """
  choose_named_type2(root_til, title, ntf_flags, func, sym) -> bool
  """
  return _idaapi.choose_named_type2(*args)

def choose_local_tinfo(*args):
  """
  choose_local_tinfo(ti, title, func, ud) -> uint32
  """
  return _idaapi.choose_local_tinfo(*args)

def choose_local_type(*args):
  """
  choose_local_type(ti, title, func, ud) -> uint32
  """
  return _idaapi.choose_local_type(*args)
class valstrs_deprecated2_t(object):
    """
    Proxy of C++ valstrs_deprecated2_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> valstrs_deprecated2_t
        """
        this = _idaapi.new_valstrs_deprecated2_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_valstrs_deprecated2_t
    __del__ = lambda self : None;
valstrs_deprecated2_t_swigregister = _idaapi.valstrs_deprecated2_t_swigregister
valstrs_deprecated2_t_swigregister(valstrs_deprecated2_t)

class valstrs_deprecated_t(object):
    """
    Proxy of C++ valstrs_deprecated_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> valstrs_deprecated_t
        """
        this = _idaapi.new_valstrs_deprecated_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_valstrs_deprecated_t
    __del__ = lambda self : None;
valstrs_deprecated_t_swigregister = _idaapi.valstrs_deprecated_t_swigregister
valstrs_deprecated_t_swigregister(valstrs_deprecated_t)


def get_scattered_varloc(*args):
  """
  get_scattered_varloc(idx) -> scattered_vloc_t
  """
  return _idaapi.get_scattered_varloc(*args)

def set_scattered_varloc(*args):
  """
  set_scattered_varloc(ptr) -> int
  """
  return _idaapi.set_scattered_varloc(*args)

def copy_varloc(*args):
  """
  copy_varloc(dst, src)
  """
  return _idaapi.copy_varloc(*args)

def cleanup_varloc(*args):
  """
  cleanup_varloc(vloc)
  """
  return _idaapi.cleanup_varloc(*args)
BAD_VARLOC = _idaapi.BAD_VARLOC
class varloc_t(object):
    """
    Proxy of C++ varloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> varloc_t
        __init__(self, r) -> varloc_t
        """
        this = _idaapi.new_varloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_varloc_t
    __del__ = lambda self : None;
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.varloc_t_swap(self, *args)

    def get_value(self, *args):
        """
        get_value(self) -> int32
        """
        return _idaapi.varloc_t_get_value(self, *args)

    def type(self, *args):
        """
        type(self) -> uint32
        """
        return _idaapi.varloc_t_type(self, *args)

    def is_reg1(self, *args):
        """
        is_reg1(self) -> bool
        """
        return _idaapi.varloc_t_is_reg1(self, *args)

    def is_reg2(self, *args):
        """
        is_reg2(self) -> bool
        """
        return _idaapi.varloc_t_is_reg2(self, *args)

    def is_reg(self, *args):
        """
        is_reg(self) -> bool
        """
        return _idaapi.varloc_t_is_reg(self, *args)

    def is_stkoff(self, *args):
        """
        is_stkoff(self) -> bool
        """
        return _idaapi.varloc_t_is_stkoff(self, *args)

    def is_scattered(self, *args):
        """
        is_scattered(self) -> bool
        """
        return _idaapi.varloc_t_is_scattered(self, *args)

    def is_fragmented(self, *args):
        """
        is_fragmented(self) -> bool
        """
        return _idaapi.varloc_t_is_fragmented(self, *args)

    def is_badloc(self, *args):
        """
        is_badloc(self) -> bool
        """
        return _idaapi.varloc_t_is_badloc(self, *args)

    def reg1(self, *args):
        """
        reg1(self) -> int
        """
        return _idaapi.varloc_t_reg1(self, *args)

    def regoff(self, *args):
        """
        regoff(self) -> int
        """
        return _idaapi.varloc_t_regoff(self, *args)

    def reg2(self, *args):
        """
        reg2(self) -> int
        """
        return _idaapi.varloc_t_reg2(self, *args)

    def stkoff(self, *args):
        """
        stkoff(self) -> int
        """
        return _idaapi.varloc_t_stkoff(self, *args)

    def scattered(self, *args):
        """
        scattered(self) -> scattered_vloc_t
        scattered(self) -> scattered_vloc_t
        """
        return _idaapi.varloc_t_scattered(self, *args)

    def _set_badloc(self, *args):
        """
        _set_badloc(self)
        """
        return _idaapi.varloc_t__set_badloc(self, *args)

    def _set_reg1(self, *args):
        """
        _set_reg1(self, reg, off=0)
        """
        return _idaapi.varloc_t__set_reg1(self, *args)

    def _set_reg2(self, *args):
        """
        _set_reg2(self, _reg1, _reg2)
        """
        return _idaapi.varloc_t__set_reg2(self, *args)

    def _set_stkoff(self, *args):
        """
        _set_stkoff(self, off)
        """
        return _idaapi.varloc_t__set_stkoff(self, *args)

    def _consume_scattered(self, *args):
        """
        _consume_scattered(self, p) -> bool
        """
        return _idaapi.varloc_t__consume_scattered(self, *args)

    def set_reg1(self, *args):
        """
        set_reg1(self, reg, off=0)
        """
        return _idaapi.varloc_t_set_reg1(self, *args)

    def set_reg2(self, *args):
        """
        set_reg2(self, _reg1, _reg2)
        """
        return _idaapi.varloc_t_set_reg2(self, *args)

    def set_stkoff(self, *args):
        """
        set_stkoff(self, off)
        """
        return _idaapi.varloc_t_set_stkoff(self, *args)

    def consume_scattered(self, *args):
        """
        consume_scattered(self, p)
        """
        return _idaapi.varloc_t_consume_scattered(self, *args)

    def set_badloc(self, *args):
        """
        set_badloc(self)
        """
        return _idaapi.varloc_t_set_badloc(self, *args)

    def calc_offset(self, *args):
        """
        calc_offset(self) -> int
        """
        return _idaapi.varloc_t_calc_offset(self, *args)

    def advance(self, *args):
        """
        advance(self, delta) -> bool
        """
        return _idaapi.varloc_t_advance(self, *args)

varloc_t_swigregister = _idaapi.varloc_t_swigregister
varloc_t_swigregister(varloc_t)

class varpart_t(varloc_t):
    """
    Proxy of C++ varpart_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    off = _swig_property(_idaapi.varpart_t_off_get, _idaapi.varpart_t_off_set)
    size = _swig_property(_idaapi.varpart_t_size_get, _idaapi.varpart_t_size_set)
    def __init__(self, *args):
        """
        __init__(self) -> varpart_t
        """
        this = _idaapi.new_varpart_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def bad_offset(self, *args):
        """
        bad_offset(self) -> bool
        """
        return _idaapi.varpart_t_bad_offset(self, *args)

    def bad_size(self, *args):
        """
        bad_size(self) -> bool
        """
        return _idaapi.varpart_t_bad_size(self, *args)

    __swig_destroy__ = _idaapi.delete_varpart_t
    __del__ = lambda self : None;
varpart_t_swigregister = _idaapi.varpart_t_swigregister
varpart_t_swigregister(varpart_t)

class scattered_vloc_t(object):
    """
    Proxy of C++ scattered_vloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> scattered_vloc_t
        """
        this = _idaapi.new_scattered_vloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_scattered_vloc_t
    __del__ = lambda self : None;
scattered_vloc_t_swigregister = _idaapi.scattered_vloc_t_swigregister
scattered_vloc_t_swigregister(scattered_vloc_t)


def add_til(*args):
  """
  add_til(name) -> int
  """
  return _idaapi.add_til(*args)

def is_type_voiddef(*args):
  """
  is_type_voiddef(t) -> bool
  """
  return _idaapi.is_type_voiddef(*args)

def is_type_void_obsolete(*args):
  """
  is_type_void_obsolete(t) -> bool
  """
  return _idaapi.is_type_void_obsolete(*args)

def is_type_unk(*args):
  """
  is_type_unk(t) -> bool
  """
  return _idaapi.is_type_unk(*args)

def is_type_only_size(*args):
  """
  is_type_only_size(t) -> bool
  """
  return _idaapi.is_type_only_size(*args)

def apply_type2(*args):
  """
  apply_type2(ea, rtype, fields, userti) -> bool
  """
  return _idaapi.apply_type2(*args)

def parse_types2(*args):
  """
  parse_types2(input, printer, hti_flags) -> int
  """
  return _idaapi.parse_types2(*args)

def apply_cdecl(*args):
  """
  apply_cdecl(ea, decl) -> bool
  """
  return _idaapi.apply_cdecl(*args)

def til2idb(*args):
  """
  til2idb(idx, name) -> tid_t
  """
  return _idaapi.til2idb(*args)

def get_idainfo_by_type(*args):
  """
  get_idainfo_by_type(rtype, fields, psize, pflags, mt, alsize=None) -> bool
  """
  return _idaapi.get_idainfo_by_type(*args)

def is_resolved_type_struni(*args):
  """
  is_resolved_type_struni(type) -> bool
  """
  return _idaapi.is_resolved_type_struni(*args)

def make_array_type(*args):
  """
  make_array_type(buf, bufsize, type, size) -> bool
  """
  return _idaapi.make_array_type(*args)

def get_func_nargs(*args):
  """
  get_func_nargs(type) -> int
  """
  return _idaapi.get_func_nargs(*args)

def get_strmem(*args):
  """
  get_strmem(til, type, fields, offset, delta, name, ftype=None, fnames=None, sname=None) -> bool
  """
  return _idaapi.get_strmem(*args)

def get_strmem_by_name(*args):
  """
  get_strmem_by_name(til, type, fields, name, offset, ftype=None, fnames=None, sname=None) -> bool
  """
  return _idaapi.get_strmem_by_name(*args)

def calc_argloc_info(*args):
  """
  calc_argloc_info(til, type, arglocs, maxn) -> int
  """
  return _idaapi.calc_argloc_info(*args)
ARGLOC_REG = _idaapi.ARGLOC_REG
ARGLOC_REG2 = _idaapi.ARGLOC_REG2

def is_reg_argloc(*args):
  """
  is_reg_argloc(argloc) -> bool
  """
  return _idaapi.is_reg_argloc(*args)

def is_stack_argloc(*args):
  """
  is_stack_argloc(argloc) -> bool
  """
  return _idaapi.is_stack_argloc(*args)

def is_reg2_argloc(*args):
  """
  is_reg2_argloc(reg_argloc) -> bool
  """
  return _idaapi.is_reg2_argloc(*args)

def get_argloc_r1(*args):
  """
  get_argloc_r1(reg_argloc) -> int
  """
  return _idaapi.get_argloc_r1(*args)

def get_argloc_r2(*args):
  """
  get_argloc_r2(reg_argloc) -> int
  """
  return _idaapi.get_argloc_r2(*args)

def make_old_argloc(*args):
  """
  make_old_argloc(r1, r2) -> argloc_old_t
  """
  return _idaapi.make_old_argloc(*args)

def split_old_argloc(*args):
  """
  split_old_argloc(al, r1, r2)
  """
  return _idaapi.split_old_argloc(*args)

def extract_old_argloc(*args):
  """
    extract_old_argloc(ptr, p1, p2)
    extract_old_argloc(ptr) -> argloc_old_t
    """
  return _idaapi.extract_old_argloc(*args)

def extract_and_convert_old_argloc(*args):
  """
  extract_and_convert_old_argloc(tp) -> uint32
  """
  return _idaapi.extract_and_convert_old_argloc(*args)
NTF_NOIDB = _idaapi.NTF_NOIDB

def build_func_type(*args):
  """
  build_func_type(p_type, p_fields, fi) -> bool
  """
  return _idaapi.build_func_type(*args)
class type_visitor_t(object):
    """
    Proxy of C++ type_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_type(self, *args):
        """
        visit_type(self, type) -> int
        """
        return _idaapi.type_visitor_t_visit_type(self, *args)

    __swig_destroy__ = _idaapi.delete_type_visitor_t
    __del__ = lambda self : None;
type_visitor_t_swigregister = _idaapi.type_visitor_t_swigregister
type_visitor_t_swigregister(type_visitor_t)


def for_all_types(*args):
  """
  for_all_types(ptype, tv) -> int
  """
  return _idaapi.for_all_types(*args)
class type_pair_t(object):
    """
    Proxy of C++ type_pair_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type1 = _swig_property(_idaapi.type_pair_t_type1_get, _idaapi.type_pair_t_type1_set)
    type2 = _swig_property(_idaapi.type_pair_t_type2_get, _idaapi.type_pair_t_type2_set)
    def __init__(self, *args):
        """
        __init__(self) -> type_pair_t
        __init__(self, l) -> type_pair_t
        __init__(self, l, g) -> type_pair_t
        """
        this = _idaapi.new_type_pair_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_type_pair_t
    __del__ = lambda self : None;
type_pair_t_swigregister = _idaapi.type_pair_t_swigregister
type_pair_t_swigregister(type_pair_t)

class type_pair_vec_t(object):
    """
    Proxy of C++ type_pair_vec_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> type_pair_vec_t
        """
        this = _idaapi.new_type_pair_vec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_type_pair_vec_t
    __del__ = lambda self : None;
type_pair_vec_t_swigregister = _idaapi.type_pair_vec_t_swigregister
type_pair_vec_t_swigregister(type_pair_vec_t)


def replace_subtypes(*args):
  """
  replace_subtypes(type, type_pairs) -> int
  """
  return _idaapi.replace_subtypes(*args)
class type_mapper_t(object):
    """
    Proxy of C++ type_mapper_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def map_type(self, *args):
        """
        map_type(self, out, type) -> bool
        """
        return _idaapi.type_mapper_t_map_type(self, *args)

    __swig_destroy__ = _idaapi.delete_type_mapper_t
    __del__ = lambda self : None;
type_mapper_t_swigregister = _idaapi.type_mapper_t_swigregister
type_mapper_t_swigregister(type_mapper_t)


def replace_subtypes2(*args):
  """
  replace_subtypes2(ti, type, mapper) -> int
  """
  return _idaapi.replace_subtypes2(*args)

def calc_max_number_of_children(*args):
  """
  calc_max_number_of_children(ea, til, type, fields=None, dont_deref_ptr=False) -> int
  """
  return _idaapi.calc_max_number_of_children(*args)

def deref_ptr(*args):
  """
  deref_ptr(ti, type, ptr_ea, closure_obj=None) -> bool
  """
  return _idaapi.deref_ptr(*args)

def guess_tinfo(*args):
  """
  guess_tinfo(id, type, fields) -> int
  """
  return _idaapi.guess_tinfo(*args)

def guess_func_tinfo(*args):
  """
  guess_func_tinfo(pfn, type, fields) -> int
  """
  return _idaapi.guess_func_tinfo(*args)

def get_enum_base_type(*args):
  """
  get_enum_base_type(type) -> type_t const *
  """
  return _idaapi.get_enum_base_type(*args)

def set_complex_n(*args):
  """
  set_complex_n(pt, val, is_empty_udt) -> type_t *
  """
  return _idaapi.set_complex_n(*args)

def get_complex_n(*args):
  """
  get_complex_n(ptype, is_empty_udt) -> int
  """
  return _idaapi.get_complex_n(*args)

def append_dt(*args):
  """
  append_dt(type, n) -> bool
  """
  return _idaapi.append_dt(*args)

def append_de(*args):
  """
  append_de(type, n) -> bool
  """
  return _idaapi.append_de(*args)

def append_da(*args):
  """
  append_da(type, n1, n2) -> bool
  """
  return _idaapi.append_da(*args)

def append_name(*args):
  """
  append_name(fields, name) -> bool
  """
  return _idaapi.append_name(*args)

def append_complex_n(*args):
  """
  append_complex_n(type, n, is_empty) -> bool
  """
  return _idaapi.append_complex_n(*args)

def is_castable2(*args):
  """
  is_castable2(til, frm, to) -> bool
  """
  return _idaapi.is_castable2(*args)

def build_array_type(*args):
  """
  build_array_type(outtype, type, size) -> bool
  """
  return _idaapi.build_array_type(*args)

def get_ptr_object_size(*args):
  """
  get_ptr_object_size(til, type) -> ssize_t
  """
  return _idaapi.get_ptr_object_size(*args)

def get_name_of_named_type(*args):
  """
  get_name_of_named_type(ptr) -> bool
  """
  return _idaapi.get_name_of_named_type(*args)

def is_type_scalar2(*args):
  """
  is_type_scalar2(til, type) -> bool
  """
  return _idaapi.is_type_scalar2(*args)

def get_type_sign(*args):
  """
  get_type_sign(til, type) -> type_sign_t
  """
  return _idaapi.get_type_sign(*args)

def get_idainfo_by_type2(*args):
  """
  get_idainfo_by_type2(til, ptype, fields, psize, pflags, mt, alsize=None) -> bool
  """
  return _idaapi.get_idainfo_by_type2(*args)

def apply_tinfo(*args):
  """
  apply_tinfo(til, ea, type, fields, flags) -> bool
  """
  return _idaapi.apply_tinfo(*args)

def parse_decl(*args):
  """
  parse_decl(til, decl, name, type, fields, flags) -> bool
  """
  return _idaapi.parse_decl(*args)

def remove_type_pointer(*args):
  """
  remove_type_pointer(til, ptype, pname) -> bool
  """
  return _idaapi.remove_type_pointer(*args)

def apply_once_type_and_name(*args):
  """
  apply_once_type_and_name(ea, type, name) -> bool
  """
  return _idaapi.apply_once_type_and_name(*args)

def get_func_rettype(*args):
  """
  get_func_rettype(til, type, fields, rettype, retfields=None, p_retloc=None, p_cc=None) -> int
  """
  return _idaapi.get_func_rettype(*args)

def calc_func_nargs(*args):
  """
  calc_func_nargs(til, type) -> int
  """
  return _idaapi.calc_func_nargs(*args)

def get_func_cc(*args):
  """
  get_func_cc(til, p_type, p_fields=None) -> cm_t
  """
  return _idaapi.get_func_cc(*args)

def skip_spoiled_info(*args):
  """
  skip_spoiled_info(ptr) -> type_t const *
  """
  return _idaapi.skip_spoiled_info(*args)

def set_spoils(*args):
  """
  set_spoils(pt, reg, size) -> type_t *
  """
  return _idaapi.set_spoils(*args)

def get_spoil_cnt(*args):
  """
  get_spoil_cnt(t) -> unsigned int
  """
  return _idaapi.get_spoil_cnt(*args)

def is_type_resolvable(*args):
  """
  is_type_resolvable(p, namebuf=None) -> bool
  """
  return _idaapi.is_type_resolvable(*args)

def resolve_typedef2(*args):
  """
  resolve_typedef2(ti, p, fields=None, namebuf=None) -> type_t const *
  """
  return _idaapi.resolve_typedef2(*args)

def get_funcarg_size(*args):
  """
  get_funcarg_size(til, pptr, lp=None) -> size_t
  """
  return _idaapi.get_funcarg_size(*args)

def check_skip_type(*args):
  """
  check_skip_type(ti, ptr) -> bool
  """
  return _idaapi.check_skip_type(*args)

def is_valid_full_type(*args):
  """
  is_valid_full_type(ti, ptr) -> bool
  """
  return _idaapi.is_valid_full_type(*args)

def print_type_to_qstring(*args):
  """
    print_type_to_qstring(prefix, indent, cmtindent, flags, ti, pt, name=None, cmt=None, field_names=None,
        field_cmts=None) -> ssize_t
    """
  return _idaapi.print_type_to_qstring(*args)
class funcarg_info_t(object):
    """
    Proxy of C++ funcarg_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    argloc = _swig_property(_idaapi.funcarg_info_t_argloc_get, _idaapi.funcarg_info_t_argloc_set)
    name = _swig_property(_idaapi.funcarg_info_t_name_get, _idaapi.funcarg_info_t_name_set)
    type = _swig_property(_idaapi.funcarg_info_t_type_get, _idaapi.funcarg_info_t_type_set)
    fields = _swig_property(_idaapi.funcarg_info_t_fields_get, _idaapi.funcarg_info_t_fields_set)
    def __init__(self, *args):
        """
        __init__(self) -> funcarg_info_t
        """
        this = _idaapi.new_funcarg_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_funcarg_info_t
    __del__ = lambda self : None;
funcarg_info_t_swigregister = _idaapi.funcarg_info_t_swigregister
funcarg_info_t_swigregister(funcarg_info_t)

class func_type_info_t(object):
    """
    Proxy of C++ func_type_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.func_type_info_t_flags_get, _idaapi.func_type_info_t_flags_set)
    rettype = _swig_property(_idaapi.func_type_info_t_rettype_get, _idaapi.func_type_info_t_rettype_set)
    retfields = _swig_property(_idaapi.func_type_info_t_retfields_get, _idaapi.func_type_info_t_retfields_set)
    retloc = _swig_property(_idaapi.func_type_info_t_retloc_get, _idaapi.func_type_info_t_retloc_set)
    stkargs = _swig_property(_idaapi.func_type_info_t_stkargs_get, _idaapi.func_type_info_t_stkargs_set)
    spoiled = _swig_property(_idaapi.func_type_info_t_spoiled_get, _idaapi.func_type_info_t_spoiled_set)
    cc = _swig_property(_idaapi.func_type_info_t_cc_get, _idaapi.func_type_info_t_cc_set)
    basetype = _swig_property(_idaapi.func_type_info_t_basetype_get, _idaapi.func_type_info_t_basetype_set)
    def __init__(self, *args):
        """
        __init__(self) -> func_type_info_t
        """
        this = _idaapi.new_func_type_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_func_type_info_t
    __del__ = lambda self : None;
func_type_info_t_swigregister = _idaapi.func_type_info_t_swigregister
func_type_info_t_swigregister(func_type_info_t)


def build_func_type2(*args):
  """
  build_func_type2(ti, p_type, p_fields, fi) -> bool
  """
  return _idaapi.build_func_type2(*args)

def build_funcarg_info(*args):
  """
  build_funcarg_info(til, type, fields, info, bfi_flags) -> int
  """
  return _idaapi.build_funcarg_info(*args)
BFI_NOCONST = _idaapi.BFI_NOCONST
BFI_NOLOCS = _idaapi.BFI_NOLOCS

def resolve_complex_type2(*args):
  """
  resolve_complex_type2(til, ptype, fields, type_name, bt, N) -> bool
  """
  return _idaapi.resolve_complex_type2(*args)

def calc_varloc_info(*args):
  """
  calc_varloc_info(til, type, varlocs) -> int
  """
  return _idaapi.calc_varloc_info(*args)

def append_varloc(*args):
  """
  append_varloc(out, vloc) -> bool
  """
  return _idaapi.append_varloc(*args)

def extract_varloc(*args):
  """
  extract_varloc(ptype, vloc, is_retval) -> bool
  """
  return _idaapi.extract_varloc(*args)

def skip_varloc(*args):
  """
  skip_varloc(ptype, is_retval=False) -> bool
  """
  return _idaapi.skip_varloc(*args)

def verify_varloc(*args):
  """
  verify_varloc(vloc, size, gaps) -> int
  """
  return _idaapi.verify_varloc(*args)

def optimize_varloc(*args):
  """
  optimize_varloc(vloc, size, gaps) -> bool
  """
  return _idaapi.optimize_varloc(*args)

def print_varloc(*args):
  """
  print_varloc(vloc, size=0, vflags=0) -> size_t
  """
  return _idaapi.print_varloc(*args)
PRVLOC_VERIFY = _idaapi.PRVLOC_VERIFY
PRVLOC_STKOFF = _idaapi.PRVLOC_STKOFF

def convert_varloc_to_argloc(*args):
  """
  convert_varloc_to_argloc(dst, src)
  """
  return _idaapi.convert_varloc_to_argloc(*args)

def convert_argloc_to_varloc(*args):
  """
  convert_argloc_to_varloc(dst, src) -> bool
  """
  return _idaapi.convert_argloc_to_varloc(*args)
class vloc_visitor_t(object):
    """
    Proxy of C++ vloc_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_location(self, *args):
        """
        visit_location(self, v, off, size) -> int
        """
        return _idaapi.vloc_visitor_t_visit_location(self, *args)

    __swig_destroy__ = _idaapi.delete_vloc_visitor_t
    __del__ = lambda self : None;
vloc_visitor_t_swigregister = _idaapi.vloc_visitor_t_swigregister
vloc_visitor_t_swigregister(vloc_visitor_t)


def for_all_varlocs(*args):
  """
  for_all_varlocs(vv, vloc, size, off=0) -> int
  """
  return _idaapi.for_all_varlocs(*args)
class const_vloc_visitor_t(object):
    """
    Proxy of C++ const_vloc_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_location(self, *args):
        """
        visit_location(self, v, off, size) -> int
        """
        return _idaapi.const_vloc_visitor_t_visit_location(self, *args)

    __swig_destroy__ = _idaapi.delete_const_vloc_visitor_t
    __del__ = lambda self : None;
const_vloc_visitor_t_swigregister = _idaapi.const_vloc_visitor_t_swigregister
const_vloc_visitor_t_swigregister(const_vloc_visitor_t)


def for_all_const_varlocs(*args):
  """
  for_all_const_varlocs(vv, vloc, size, off=0) -> int
  """
  return _idaapi.for_all_const_varlocs(*args)

def calc_max_children_qty(*args):
  """
  calc_max_children_qty(ea, tif, dont_deref_ptr=False) -> int
  """
  return _idaapi.calc_max_children_qty(*args)

def guess_func_tinfo2(*args):
  """
  guess_func_tinfo2(pfn, tif) -> int
  """
  return _idaapi.guess_func_tinfo2(*args)

def lower_type(*args):
  """
  lower_type(til, tif, name=None) -> int
  """
  return _idaapi.lower_type(*args)

def print_type2(*args):
  """
  print_type2(ea, prtype_flags) -> bool
  """
  return _idaapi.print_type2(*args)

def idc_parse_decl(*args):
  """
  idc_parse_decl(ti, decl, flags) -> PyObject *
  """
  return _idaapi.idc_parse_decl(*args)

def calc_type_size(*args):
  """
  calc_type_size(ti, tp) -> PyObject *


  Returns the size of a type
  @param ti: Type info. 'idaapi.cvar.idati' can be passed.
  @param tp: type string
  @return:
      - None on failure
      - The size of the type
  """
  return _idaapi.calc_type_size(*args)

def apply_type(*args):
  """
  apply_type(ti, py_type, py_fields, ea, flags) -> bool


  Apply the specified type to the address
  @param ti: Type info library. 'idaapi.cvar.idati' can be used.
  @param py_type: type string
  @param py_fields: fields string (may be empty or None)
  @param ea: the address of the object
  @param flags: combination of TINFO_... constants or 0
  @return: Boolean
  """
  return _idaapi.apply_type(*args)

def print_type(*args):
  """
  print_type(ea, one_line) -> PyObject *


  Returns the type of an item
  @return:
      - None on failure
      - The type string with a semicolon. Can be used directly with idc.SetType()
  """
  return _idaapi.print_type(*args)

def unpack_object_from_idb(*args):
  """
  unpack_object_from_idb(ti, py_type, py_fields, ea, pio_flags=0) -> PyObject *
  """
  return _idaapi.unpack_object_from_idb(*args)

def unpack_object_from_bv(*args):
  """
  unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags=0) -> PyObject *


  Unpacks a buffer into an object.
  Returns the error_t returned by idaapi.pack_object_to_idb
  @param ti: Type info. 'idaapi.cvar.idati' can be passed.
  @param tp: type string
  @param fields: fields string (may be empty or None)
  @param bytes: the bytes to unpack
  @param pio_flags: flags used while unpacking
  @return:
      - tuple(0, err) on failure
      - tuple(1, obj) on success
  """
  return _idaapi.unpack_object_from_bv(*args)

def pack_object_to_idb(*args):
  """
  pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags=0) -> PyObject *


  Write a typed object to the database.
  Raises an exception if wrong parameters were passed or conversion fails
  Returns the error_t returned by idaapi.pack_object_to_idb
  @param ti: Type info. 'idaapi.cvar.idati' can be passed.
  @param tp: type string
  @param fields: fields string (may be empty or None)
  @param ea: ea to be used while packing
  @param pio_flags: flags used while unpacking
  """
  return _idaapi.pack_object_to_idb(*args)

def pack_object_to_bv(*args):
  """
  pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags=0) -> PyObject *


  Packs a typed object to a string
  @param ti: Type info. 'idaapi.cvar.idati' can be passed.
  @param tp: type string
  @param fields: fields string (may be empty or None)
  @param base_ea: base ea used to relocate the pointers in the packed object
  @param pio_flags: flags used while unpacking
  @return:
      tuple(0, err_code) on failure
      tuple(1, packed_buf) on success
  """
  return _idaapi.pack_object_to_bv(*args)

def idc_parse_types(*args):
  """
  idc_parse_types(input, flags) -> int
  """
  return _idaapi.idc_parse_types(*args)

def idc_get_type_raw(*args):
  """
  idc_get_type_raw(ea) -> PyObject *
  """
  return _idaapi.idc_get_type_raw(*args)

def idc_get_local_type_raw(*args):
  """
  idc_get_local_type_raw(ordinal) -> PyObject *
  """
  return _idaapi.idc_get_local_type_raw(*args)

def idc_guess_type(*args):
  """
  idc_guess_type(ea) -> char *
  """
  return _idaapi.idc_guess_type(*args)

def idc_get_type(*args):
  """
  idc_get_type(ea) -> char *
  """
  return _idaapi.idc_get_type(*args)

def idc_set_local_type(*args):
  """
  idc_set_local_type(ordinal, dcl, flags) -> int
  """
  return _idaapi.idc_set_local_type(*args)

def idc_get_local_type(*args):
  """
  idc_get_local_type(ordinal, flags, buf, maxsize) -> int
  """
  return _idaapi.idc_get_local_type(*args)

def idc_print_type(*args):
  """
  idc_print_type(py_type, py_fields, name, flags) -> PyObject *
  """
  return _idaapi.idc_print_type(*args)

def idc_get_local_type_name(*args):
  """
  idc_get_local_type_name(ordinal) -> char
  """
  return _idaapi.idc_get_local_type_name(*args)

def get_named_type(*args):
  """
  get_named_type(til, name, ntf_flags) -> PyObject *


  Get a type data by its name.
  @param til: the type library
  @param name: the type name
  @param ntf_flags: a combination of NTF_* constants
  @return:
      None on failure
      tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success
  """
  return _idaapi.get_named_type(*args)

def get_named_type64(*args):
  """
  get_named_type64(til, name, ntf_flags) -> PyObject *
  """
  return _idaapi.get_named_type64(*args)

def print_decls(*args):
  """
  print_decls(printer, til, py_ordinals, flags) -> int
  """
  return _idaapi.print_decls(*args)

def load_til(*args):
  """
    load_til(tildir, name, errbuf, bufsize) -> til_t
    load_til(tildir, name) -> til_t
    """
  return _idaapi.load_til(*args)

def load_til_header(*args):
  """
    load_til_header(tildir, name, errbuf, bufsize) -> til_t
    load_til_header(tildir, name) -> til_t
    """
  return _idaapi.load_til_header(*args)
#<pycode(py_typeinf)>

def get_type_size0(ti, tp):
    """
    DEPRECATED. Please use calc_type_size instead
    Returns the size of a type
    @param ti: Type info. 'idaapi.cvar.idati' can be passed.
    @param tp: type string
    @return:
        - None on failure
        - The size of the type
    """
    return calc_type_size(ti, tp)

#</pycode(py_typeinf)>


class user_numforms_t(object):
    """
    Proxy of C++ std::map<(operand_locator_t,number_format_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> number_format_t
        """
        return _idaapi.user_numforms_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.user_numforms_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_numforms_t
        """
        this = _idaapi.new_user_numforms_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_numforms_t
    __del__ = lambda self : None;
user_numforms_t_swigregister = _idaapi.user_numforms_t_swigregister
user_numforms_t_swigregister(user_numforms_t)
FTI_CALLSHIFT = cvar.FTI_CALLSHIFT

class lvar_mapping_t(object):
    """
    Proxy of C++ std::map<(lvar_locator_t,lvar_locator_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> lvar_locator_t
        """
        return _idaapi.lvar_mapping_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.lvar_mapping_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> lvar_mapping_t
        """
        this = _idaapi.new_lvar_mapping_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lvar_mapping_t
    __del__ = lambda self : None;
lvar_mapping_t_swigregister = _idaapi.lvar_mapping_t_swigregister
lvar_mapping_t_swigregister(lvar_mapping_t)

class hexwarns_t(object):
    """
    Proxy of C++ qvector<(hexwarn_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> hexwarns_t
        __init__(self, x) -> hexwarns_t
        """
        this = _idaapi.new_hexwarns_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_hexwarns_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.hexwarns_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.hexwarns_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.hexwarns_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> hexwarn_t
        front(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> hexwarn_t
        back(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.hexwarns_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.hexwarns_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.hexwarns_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=hexwarn_t())
        """
        return _idaapi.hexwarns_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.hexwarns_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.hexwarns_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.hexwarns_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.hexwarns_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.hexwarns_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.hexwarns_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.hexwarns_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> hexwarn_t
        begin(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> hexwarn_t
        end(self) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> hexwarn_t
        erase(self, first, last) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> hexwarn_t
        find(self, x) -> hexwarn_t
        """
        return _idaapi.hexwarns_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.hexwarns_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.hexwarns_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.hexwarns_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.hexwarns_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> hexwarn_t
        """
        return _idaapi.hexwarns_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.hexwarns_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

hexwarns_t_swigregister = _idaapi.hexwarns_t_swigregister
hexwarns_t_swigregister(hexwarns_t)

class ctree_items_t(object):
    """
    Proxy of C++ qvector<(p.citem_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> ctree_items_t
        __init__(self, x) -> ctree_items_t
        """
        this = _idaapi.new_ctree_items_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ctree_items_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> citem_t *&
        """
        return _idaapi.ctree_items_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.ctree_items_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.ctree_items_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.ctree_items_t_empty(self, *args)

    def front(self, *args):
        """
        front(self) -> citem_t
        front(self) -> citem_t *&
        """
        return _idaapi.ctree_items_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> citem_t
        back(self) -> citem_t *&
        """
        return _idaapi.ctree_items_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.ctree_items_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.ctree_items_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.ctree_items_t_resize(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.ctree_items_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.ctree_items_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.ctree_items_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.ctree_items_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> citem_t **
        """
        return _idaapi.ctree_items_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.ctree_items_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.ctree_items_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.ctree_items_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qvector< citem_t * >::iterator
        begin(self) -> qvector< citem_t * >::const_iterator
        """
        return _idaapi.ctree_items_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qvector< citem_t * >::iterator
        end(self) -> qvector< citem_t * >::const_iterator
        """
        return _idaapi.ctree_items_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> qvector< citem_t * >::iterator
        """
        return _idaapi.ctree_items_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> qvector< citem_t * >::iterator
        erase(self, first, last) -> qvector< citem_t * >::iterator
        """
        return _idaapi.ctree_items_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> qvector< citem_t * >::iterator
        find(self, x) -> qvector< citem_t * >::const_iterator
        """
        return _idaapi.ctree_items_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.ctree_items_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.ctree_items_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.ctree_items_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.ctree_items_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> citem_t
        """
        return _idaapi.ctree_items_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.ctree_items_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

    def at(self, *args):
        """
        at(self, n) -> citem_t
        """
        return _idaapi.ctree_items_t_at(self, *args)

ctree_items_t_swigregister = _idaapi.ctree_items_t_swigregister
ctree_items_t_swigregister(ctree_items_t)

class user_labels_t(object):
    """
    Proxy of C++ std::map<(int,qstring)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> _qstring< char > &
        """
        return _idaapi.user_labels_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.user_labels_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_labels_t
        """
        this = _idaapi.new_user_labels_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_labels_t
    __del__ = lambda self : None;
user_labels_t_swigregister = _idaapi.user_labels_t_swigregister
user_labels_t_swigregister(user_labels_t)

class user_cmts_t(object):
    """
    Proxy of C++ std::map<(treeloc_t,citem_cmt_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> citem_cmt_t
        """
        return _idaapi.user_cmts_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.user_cmts_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_cmts_t
        """
        this = _idaapi.new_user_cmts_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_cmts_t
    __del__ = lambda self : None;
user_cmts_t_swigregister = _idaapi.user_cmts_t_swigregister
user_cmts_t_swigregister(user_cmts_t)

class user_iflags_t(object):
    """
    Proxy of C++ std::map<(citem_locator_t,int32)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> int &
        """
        return _idaapi.user_iflags_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.user_iflags_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_iflags_t
        """
        this = _idaapi.new_user_iflags_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_iflags_t
    __del__ = lambda self : None;
user_iflags_t_swigregister = _idaapi.user_iflags_t_swigregister
user_iflags_t_swigregister(user_iflags_t)

class user_unions_t(object):
    """
    Proxy of C++ std::map<(ea_t,intvec_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> intvec_t
        """
        return _idaapi.user_unions_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.user_unions_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_unions_t
        """
        this = _idaapi.new_user_unions_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_unions_t
    __del__ = lambda self : None;
user_unions_t_swigregister = _idaapi.user_unions_t_swigregister
user_unions_t_swigregister(user_unions_t)

class cinsnptrvec_t(object):
    """
    Proxy of C++ qvector<(p.cinsn_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> cinsnptrvec_t
        __init__(self, x) -> cinsnptrvec_t
        """
        this = _idaapi.new_cinsnptrvec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cinsnptrvec_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> cinsn_t *&
        """
        return _idaapi.cinsnptrvec_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.cinsnptrvec_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.cinsnptrvec_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.cinsnptrvec_t_empty(self, *args)

    def front(self, *args):
        """
        front(self) -> cinsn_t
        front(self) -> cinsn_t *&
        """
        return _idaapi.cinsnptrvec_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> cinsn_t
        back(self) -> cinsn_t *&
        """
        return _idaapi.cinsnptrvec_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.cinsnptrvec_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.cinsnptrvec_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.cinsnptrvec_t_resize(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.cinsnptrvec_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.cinsnptrvec_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.cinsnptrvec_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.cinsnptrvec_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> cinsn_t **
        """
        return _idaapi.cinsnptrvec_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.cinsnptrvec_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cinsnptrvec_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cinsnptrvec_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qvector< cinsn_t * >::iterator
        begin(self) -> qvector< cinsn_t * >::const_iterator
        """
        return _idaapi.cinsnptrvec_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qvector< cinsn_t * >::iterator
        end(self) -> qvector< cinsn_t * >::const_iterator
        """
        return _idaapi.cinsnptrvec_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> qvector< cinsn_t * >::iterator
        """
        return _idaapi.cinsnptrvec_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> qvector< cinsn_t * >::iterator
        erase(self, first, last) -> qvector< cinsn_t * >::iterator
        """
        return _idaapi.cinsnptrvec_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> qvector< cinsn_t * >::iterator
        find(self, x) -> qvector< cinsn_t * >::const_iterator
        """
        return _idaapi.cinsnptrvec_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.cinsnptrvec_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.cinsnptrvec_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.cinsnptrvec_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.cinsnptrvec_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> cinsn_t
        """
        return _idaapi.cinsnptrvec_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.cinsnptrvec_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

    def at(self, *args):
        """
        at(self, n) -> cinsn_t
        """
        return _idaapi.cinsnptrvec_t_at(self, *args)

cinsnptrvec_t_swigregister = _idaapi.cinsnptrvec_t_swigregister
cinsnptrvec_t_swigregister(cinsnptrvec_t)

class eamap_t(object):
    """
    Proxy of C++ std::map<(ea_t,cinsnptrvec_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> cinsnptrvec_t
        """
        return _idaapi.eamap_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.eamap_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> eamap_t
        """
        this = _idaapi.new_eamap_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_eamap_t
    __del__ = lambda self : None;
eamap_t_swigregister = _idaapi.eamap_t_swigregister
eamap_t_swigregister(eamap_t)

class boundaries_t(object):
    """
    Proxy of C++ std::map<(p.cinsn_t,areaset_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def at(self, *args):
        """
        at(self, _Keyval) -> areaset_t
        """
        return _idaapi.boundaries_t_at(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.boundaries_t_size(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> boundaries_t
        """
        this = _idaapi.new_boundaries_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_boundaries_t
    __del__ = lambda self : None;
boundaries_t_swigregister = _idaapi.boundaries_t_swigregister
boundaries_t_swigregister(boundaries_t)

class cfuncptr_t(object):
    """
    Proxy of C++ qrefcnt_t<(cfunc_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, p) -> cfuncptr_t
        __init__(self, r) -> cfuncptr_t
        """
        this = _idaapi.new_cfuncptr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset(self, *args):
        """
        reset(self)
        """
        return _idaapi.cfuncptr_t_reset(self, *args)

    def __deref__(self, *args):
        """
        __deref__(self) -> cfunc_t
        """
        return _idaapi.cfuncptr_t___deref__(self, *args)

    def __ref__(self, *args):
        """
        __ref__(self) -> cfunc_t
        """
        return _idaapi.cfuncptr_t___ref__(self, *args)

    __swig_destroy__ = _idaapi.delete_cfuncptr_t
    __del__ = lambda self : None;
    entry_ea = _swig_property(_idaapi.cfuncptr_t_entry_ea_get, _idaapi.cfuncptr_t_entry_ea_set)
    mba = _swig_property(_idaapi.cfuncptr_t_mba_get, _idaapi.cfuncptr_t_mba_set)
    body = _swig_property(_idaapi.cfuncptr_t_body_get, _idaapi.cfuncptr_t_body_set)
    argidx = _swig_property(_idaapi.cfuncptr_t_argidx_get)
    maturity = _swig_property(_idaapi.cfuncptr_t_maturity_get, _idaapi.cfuncptr_t_maturity_set)
    user_labels = _swig_property(_idaapi.cfuncptr_t_user_labels_get, _idaapi.cfuncptr_t_user_labels_set)
    user_cmts = _swig_property(_idaapi.cfuncptr_t_user_cmts_get, _idaapi.cfuncptr_t_user_cmts_set)
    numforms = _swig_property(_idaapi.cfuncptr_t_numforms_get, _idaapi.cfuncptr_t_numforms_set)
    user_iflags = _swig_property(_idaapi.cfuncptr_t_user_iflags_get, _idaapi.cfuncptr_t_user_iflags_set)
    user_unions = _swig_property(_idaapi.cfuncptr_t_user_unions_get, _idaapi.cfuncptr_t_user_unions_set)
    refcnt = _swig_property(_idaapi.cfuncptr_t_refcnt_get, _idaapi.cfuncptr_t_refcnt_set)
    statebits = _swig_property(_idaapi.cfuncptr_t_statebits_get, _idaapi.cfuncptr_t_statebits_set)
    hdrlines = _swig_property(_idaapi.cfuncptr_t_hdrlines_get, _idaapi.cfuncptr_t_hdrlines_set)
    treeitems = _swig_property(_idaapi.cfuncptr_t_treeitems_get, _idaapi.cfuncptr_t_treeitems_set)
    def release(self, *args):
        """
        release(self)
        """
        return _idaapi.cfuncptr_t_release(self, *args)

    def build_c_tree(self, *args):
        """
        build_c_tree(self)
        """
        return _idaapi.cfuncptr_t_build_c_tree(self, *args)

    def verify(self, *args):
        """
        verify(self, aul, even_without_debugger)
        """
        return _idaapi.cfuncptr_t_verify(self, *args)

    def print_dcl(self, *args):
        """
        print_dcl(self, buf, bufsize) -> size_t
        """
        return _idaapi.cfuncptr_t_print_dcl(self, *args)

    def print_dcl2(self, *args):
        """
        print_dcl2(self) -> size_t
        """
        return _idaapi.cfuncptr_t_print_dcl2(self, *args)

    def print_func(self, *args):
        """
        print_func(self, vp)
        """
        return _idaapi.cfuncptr_t_print_func(self, *args)

    def get_func_type(self, *args):
        """
        get_func_type(self, type) -> bool
        """
        return _idaapi.cfuncptr_t_get_func_type(self, *args)

    def get_lvars(self, *args):
        """
        get_lvars(self) -> lvars_t
        """
        return _idaapi.cfuncptr_t_get_lvars(self, *args)

    def find_label(self, *args):
        """
        find_label(self, label) -> citem_t
        """
        return _idaapi.cfuncptr_t_find_label(self, *args)

    def remove_unused_labels(self, *args):
        """
        remove_unused_labels(self)
        """
        return _idaapi.cfuncptr_t_remove_unused_labels(self, *args)

    def get_user_cmt(self, *args):
        """
        get_user_cmt(self, loc, rt) -> char const *
        """
        return _idaapi.cfuncptr_t_get_user_cmt(self, *args)

    def set_user_cmt(self, *args):
        """
        set_user_cmt(self, loc, cmt)
        """
        return _idaapi.cfuncptr_t_set_user_cmt(self, *args)

    def get_user_iflags(self, *args):
        """
        get_user_iflags(self, loc) -> int32
        """
        return _idaapi.cfuncptr_t_get_user_iflags(self, *args)

    def set_user_iflags(self, *args):
        """
        set_user_iflags(self, loc, iflags)
        """
        return _idaapi.cfuncptr_t_set_user_iflags(self, *args)

    def has_orphan_cmts(self, *args):
        """
        has_orphan_cmts(self) -> bool
        """
        return _idaapi.cfuncptr_t_has_orphan_cmts(self, *args)

    def del_orphan_cmts(self, *args):
        """
        del_orphan_cmts(self) -> int
        """
        return _idaapi.cfuncptr_t_del_orphan_cmts(self, *args)

    def get_user_union_selection(self, *args):
        """
        get_user_union_selection(self, ea, path) -> bool
        """
        return _idaapi.cfuncptr_t_get_user_union_selection(self, *args)

    def set_user_union_selection(self, *args):
        """
        set_user_union_selection(self, ea, path)
        """
        return _idaapi.cfuncptr_t_set_user_union_selection(self, *args)

    def save_user_labels(self, *args):
        """
        save_user_labels(self)
        """
        return _idaapi.cfuncptr_t_save_user_labels(self, *args)

    def save_user_cmts(self, *args):
        """
        save_user_cmts(self)
        """
        return _idaapi.cfuncptr_t_save_user_cmts(self, *args)

    def save_user_numforms(self, *args):
        """
        save_user_numforms(self)
        """
        return _idaapi.cfuncptr_t_save_user_numforms(self, *args)

    def save_user_iflags(self, *args):
        """
        save_user_iflags(self)
        """
        return _idaapi.cfuncptr_t_save_user_iflags(self, *args)

    def save_user_unions(self, *args):
        """
        save_user_unions(self)
        """
        return _idaapi.cfuncptr_t_save_user_unions(self, *args)

    def get_line_item(self, *args):
        """
        get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
        """
        return _idaapi.cfuncptr_t_get_line_item(self, *args)

    def get_warnings(self, *args):
        """
        get_warnings(self) -> hexwarns_t
        """
        return _idaapi.cfuncptr_t_get_warnings(self, *args)

    def get_eamap(self, *args):
        """
        get_eamap(self) -> eamap_t
        """
        return _idaapi.cfuncptr_t_get_eamap(self, *args)

    def get_boundaries(self, *args):
        """
        get_boundaries(self) -> boundaries_t
        """
        return _idaapi.cfuncptr_t_get_boundaries(self, *args)

    def get_pseudocode(self, *args):
        """
        get_pseudocode(self) -> strvec_t
        """
        return _idaapi.cfuncptr_t_get_pseudocode(self, *args)

    def gather_derefs(self, *args):
        """
        gather_derefs(self, ci, udm=None) -> bool
        """
        return _idaapi.cfuncptr_t_gather_derefs(self, *args)

    def __str__(self, *args):
        """
        __str__(self) -> qstring
        """
        return _idaapi.cfuncptr_t___str__(self, *args)

cfuncptr_t_swigregister = _idaapi.cfuncptr_t_swigregister
cfuncptr_t_swigregister(cfuncptr_t)

class qvector_history_t(object):
    """
    Proxy of C++ qvector<(history_item_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qvector_history_t
        __init__(self, x) -> qvector_history_t
        """
        this = _idaapi.new_qvector_history_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qvector_history_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.qvector_history_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.qvector_history_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.qvector_history_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> history_item_t
        """
        return _idaapi.qvector_history_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> history_item_t
        front(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> history_item_t
        back(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.qvector_history_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.qvector_history_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.qvector_history_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=history_item_t())
        """
        return _idaapi.qvector_history_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.qvector_history_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.qvector_history_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.qvector_history_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.qvector_history_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.qvector_history_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.qvector_history_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.qvector_history_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> history_item_t
        begin(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> history_item_t
        end(self) -> history_item_t
        """
        return _idaapi.qvector_history_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> history_item_t
        """
        return _idaapi.qvector_history_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> history_item_t
        erase(self, first, last) -> history_item_t
        """
        return _idaapi.qvector_history_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> history_item_t
        find(self, x) -> history_item_t
        """
        return _idaapi.qvector_history_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.qvector_history_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.qvector_history_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.qvector_history_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.qvector_history_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> history_item_t
        """
        return _idaapi.qvector_history_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.qvector_history_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

qvector_history_t_swigregister = _idaapi.qvector_history_t_swigregister
qvector_history_t_swigregister(qvector_history_t)

class history_t(qvector_history_t):
    """
    Proxy of C++ qstack<(history_item_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def pop(self, *args):
        """
        pop(self) -> history_item_t
        """
        return _idaapi.history_t_pop(self, *args)

    def top(self, *args):
        """
        top(self) -> history_item_t
        top(self) -> history_item_t
        """
        return _idaapi.history_t_top(self, *args)

    def push(self, *args):
        """
        push(self, v)
        """
        return _idaapi.history_t_push(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> history_t
        """
        this = _idaapi.new_history_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_history_t
    __del__ = lambda self : None;
history_t_swigregister = _idaapi.history_t_swigregister
history_t_swigregister(history_t)

class qlist_cinsn_t_iterator(object):
    """
    Proxy of C++ qlist_cinsn_t_iterator class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cur = _swig_property(_idaapi.qlist_cinsn_t_iterator_cur_get)
    def next(self, *args):
        """
        next(self) -> qlist_cinsn_t_iterator
        """
        return _idaapi.qlist_cinsn_t_iterator_next(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> qlist_cinsn_t_iterator
        """
        this = _idaapi.new_qlist_cinsn_t_iterator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qlist_cinsn_t_iterator
    __del__ = lambda self : None;
qlist_cinsn_t_iterator_swigregister = _idaapi.qlist_cinsn_t_iterator_swigregister
qlist_cinsn_t_iterator_swigregister(qlist_cinsn_t_iterator)

class qvector_lvar_t(object):
    """
    Proxy of C++ qvector<(lvar_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qvector_lvar_t
        __init__(self, x) -> qvector_lvar_t
        """
        this = _idaapi.new_qvector_lvar_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qvector_lvar_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.qvector_lvar_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.qvector_lvar_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.qvector_lvar_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> lvar_t
        front(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> lvar_t
        back(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.qvector_lvar_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.qvector_lvar_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.qvector_lvar_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=lvar_t())
        """
        return _idaapi.qvector_lvar_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.qvector_lvar_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.qvector_lvar_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.qvector_lvar_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.qvector_lvar_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.qvector_lvar_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.qvector_lvar_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.qvector_lvar_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> lvar_t
        begin(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> lvar_t
        end(self) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> lvar_t
        erase(self, first, last) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> lvar_t
        find(self, x) -> lvar_t
        """
        return _idaapi.qvector_lvar_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.qvector_lvar_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.qvector_lvar_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.qvector_lvar_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.qvector_lvar_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> lvar_t
        """
        return _idaapi.qvector_lvar_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.qvector_lvar_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

qvector_lvar_t_swigregister = _idaapi.qvector_lvar_t_swigregister
qvector_lvar_t_swigregister(qvector_lvar_t)

class qlist_cinsn_t(object):
    """
    Proxy of C++ qlist<(cinsn_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qlist_cinsn_t
        __init__(self, x) -> qlist_cinsn_t
        """
        this = _idaapi.new_qlist_cinsn_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qlist_cinsn_t
    __del__ = lambda self : None;
    def swap(self, *args):
        """
        swap(self, x)
        """
        return _idaapi.qlist_cinsn_t_swap(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.qlist_cinsn_t_empty(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.qlist_cinsn_t_size(self, *args)

    def front(self, *args):
        """
        front(self) -> cinsn_t
        front(self) -> cinsn_t
        """
        return _idaapi.qlist_cinsn_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> cinsn_t
        back(self) -> cinsn_t
        """
        return _idaapi.qlist_cinsn_t_back(self, *args)

    def rbegin(self, *args):
        """
        rbegin(self) -> qlist< cinsn_t >::reverse_iterator
        rbegin(self) -> qlist< cinsn_t >::const_reverse_iterator
        """
        return _idaapi.qlist_cinsn_t_rbegin(self, *args)

    def rend(self, *args):
        """
        rend(self) -> qlist< cinsn_t >::reverse_iterator
        rend(self) -> qlist< cinsn_t >::const_reverse_iterator
        """
        return _idaapi.qlist_cinsn_t_rend(self, *args)

    def push_front(self, *args):
        """
        push_front(self, x)
        """
        return _idaapi.qlist_cinsn_t_push_front(self, *args)

    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> cinsn_t
        """
        return _idaapi.qlist_cinsn_t_push_back(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.qlist_cinsn_t_clear(self, *args)

    def pop_front(self, *args):
        """
        pop_front(self)
        """
        return _idaapi.qlist_cinsn_t_pop_front(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.qlist_cinsn_t_pop_back(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, x) -> bool
        """
        return _idaapi.qlist_cinsn_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, x) -> bool
        """
        return _idaapi.qlist_cinsn_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> qlist_cinsn_t_iterator
        """
        return _idaapi.qlist_cinsn_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> qlist_cinsn_t_iterator
        """
        return _idaapi.qlist_cinsn_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, p, x) -> qlist< cinsn_t >::iterator
        insert(self, p) -> cinsn_t
        insert(self, p, x) -> qlist_cinsn_t_iterator
        """
        return _idaapi.qlist_cinsn_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, p)
        erase(self, p1, p2)
        erase(self, p)
        """
        return _idaapi.qlist_cinsn_t_erase(self, *args)

qlist_cinsn_t_swigregister = _idaapi.qlist_cinsn_t_swigregister
qlist_cinsn_t_swigregister(qlist_cinsn_t)

class qvector_carg_t(object):
    """
    Proxy of C++ qvector<(carg_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qvector_carg_t
        __init__(self, x) -> qvector_carg_t
        """
        this = _idaapi.new_qvector_carg_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qvector_carg_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.qvector_carg_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.qvector_carg_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.qvector_carg_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> carg_t
        """
        return _idaapi.qvector_carg_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> carg_t
        front(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> carg_t
        back(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.qvector_carg_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.qvector_carg_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.qvector_carg_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=carg_t())
        """
        return _idaapi.qvector_carg_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.qvector_carg_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.qvector_carg_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.qvector_carg_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.qvector_carg_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.qvector_carg_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.qvector_carg_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.qvector_carg_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> carg_t
        begin(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> carg_t
        end(self) -> carg_t
        """
        return _idaapi.qvector_carg_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> carg_t
        """
        return _idaapi.qvector_carg_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> carg_t
        erase(self, first, last) -> carg_t
        """
        return _idaapi.qvector_carg_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> carg_t
        find(self, x) -> carg_t
        """
        return _idaapi.qvector_carg_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.qvector_carg_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.qvector_carg_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.qvector_carg_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.qvector_carg_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> carg_t
        """
        return _idaapi.qvector_carg_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.qvector_carg_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

qvector_carg_t_swigregister = _idaapi.qvector_carg_t_swigregister
qvector_carg_t_swigregister(qvector_carg_t)

class qvector_ccase_t(object):
    """
    Proxy of C++ qvector<(ccase_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qvector_ccase_t
        __init__(self, x) -> qvector_ccase_t
        """
        this = _idaapi.new_qvector_ccase_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qvector_ccase_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.qvector_ccase_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.qvector_ccase_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.qvector_ccase_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> ccase_t
        front(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> ccase_t
        back(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.qvector_ccase_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.qvector_ccase_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.qvector_ccase_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=ccase_t())
        """
        return _idaapi.qvector_ccase_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.qvector_ccase_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.qvector_ccase_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.qvector_ccase_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.qvector_ccase_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.qvector_ccase_t_inject(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.qvector_ccase_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.qvector_ccase_t___ne__(self, *args)

    def begin(self, *args):
        """
        begin(self) -> ccase_t
        begin(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> ccase_t
        end(self) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> ccase_t
        erase(self, first, last) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_erase(self, *args)

    def find(self, *args):
        """
        find(self, x) -> ccase_t
        find(self, x) -> ccase_t
        """
        return _idaapi.qvector_ccase_t_find(self, *args)

    def has(self, *args):
        """
        has(self, x) -> bool
        """
        return _idaapi.qvector_ccase_t_has(self, *args)

    def add_unique(self, *args):
        """
        add_unique(self, x) -> bool
        """
        return _idaapi.qvector_ccase_t_add_unique(self, *args)

    def _del(self, *args):
        """
        _del(self, x) -> bool
        """
        return _idaapi.qvector_ccase_t__del(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.qvector_ccase_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> ccase_t
        """
        return _idaapi.qvector_ccase_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.qvector_ccase_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

qvector_ccase_t_swigregister = _idaapi.qvector_ccase_t_swigregister
qvector_ccase_t_swigregister(qvector_ccase_t)


def qswap(*args):
  """
  qswap(a, b)
  """
  return _idaapi.qswap(*args)

def init_hexrays_plugin(*args):
  """
  init_hexrays_plugin(flags=0) -> bool
  """
  return _idaapi.init_hexrays_plugin(*args)

def add_custom_viewer_popup_item(*args):
  """
  add_custom_viewer_popup_item(custom_viewer, title, hotkey, custom_viewer_popup_item_callback)
  """
  return _idaapi.add_custom_viewer_popup_item(*args)

def install_hexrays_callback(*args):
  """
  install_hexrays_callback(hx_cblist_callback) -> bool
  """
  return _idaapi.install_hexrays_callback(*args)

def remove_hexrays_callback(*args):
  """
  remove_hexrays_callback(hx_cblist_callback) -> int
  """
  return _idaapi.remove_hexrays_callback(*args)

def _decompile(*args):
  """
  _decompile(pfn, hf) -> cfuncptr_t
  """
  return _idaapi._decompile(*args)
class operand_locator_t(object):
    """
    Proxy of C++ operand_locator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.operand_locator_t_ea_get, _idaapi.operand_locator_t_ea_set)
    opnum = _swig_property(_idaapi.operand_locator_t_opnum_get, _idaapi.operand_locator_t_opnum_set)
    def __init__(self, *args):
        """
        __init__(self) -> operand_locator_t
        __init__(self, _ea, _opnum) -> operand_locator_t
        """
        this = _idaapi.new_operand_locator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.operand_locator_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.operand_locator_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_operand_locator_t
    __del__ = lambda self : None;
operand_locator_t_swigregister = _idaapi.operand_locator_t_swigregister
operand_locator_t_swigregister(operand_locator_t)

class number_format_t(object):
    """
    Proxy of C++ number_format_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flags = _swig_property(_idaapi.number_format_t_flags_get, _idaapi.number_format_t_flags_set)
    opnum = _swig_property(_idaapi.number_format_t_opnum_get, _idaapi.number_format_t_opnum_set)
    props = _swig_property(_idaapi.number_format_t_props_get, _idaapi.number_format_t_props_set)
    serial = _swig_property(_idaapi.number_format_t_serial_get, _idaapi.number_format_t_serial_set)
    org_nbytes = _swig_property(_idaapi.number_format_t_org_nbytes_get, _idaapi.number_format_t_org_nbytes_set)
    type_name = _swig_property(_idaapi.number_format_t_type_name_get, _idaapi.number_format_t_type_name_set)
    def __init__(self, *args):
        """
        __init__(self, _opnum=0) -> number_format_t
        """
        this = _idaapi.new_number_format_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def getRadix(self, *args):
        """
        getRadix(self) -> int
        """
        return _idaapi.number_format_t_getRadix(self, *args)

    def is_fixed(self, *args):
        """
        is_fixed(self) -> bool
        """
        return _idaapi.number_format_t_is_fixed(self, *args)

    def isHex(self, *args):
        """
        isHex(self) -> bool
        """
        return _idaapi.number_format_t_isHex(self, *args)

    def isDec(self, *args):
        """
        isDec(self) -> bool
        """
        return _idaapi.number_format_t_isDec(self, *args)

    def isOct(self, *args):
        """
        isOct(self) -> bool
        """
        return _idaapi.number_format_t_isOct(self, *args)

    def isEnum(self, *args):
        """
        isEnum(self) -> bool
        """
        return _idaapi.number_format_t_isEnum(self, *args)

    def isChar(self, *args):
        """
        isChar(self) -> bool
        """
        return _idaapi.number_format_t_isChar(self, *args)

    def isStroff(self, *args):
        """
        isStroff(self) -> bool
        """
        return _idaapi.number_format_t_isStroff(self, *args)

    def isNum(self, *args):
        """
        isNum(self) -> bool
        """
        return _idaapi.number_format_t_isNum(self, *args)

    def needs_to_be_inverted(self, *args):
        """
        needs_to_be_inverted(self) -> bool
        """
        return _idaapi.number_format_t_needs_to_be_inverted(self, *args)

    __swig_destroy__ = _idaapi.delete_number_format_t
    __del__ = lambda self : None;
number_format_t_swigregister = _idaapi.number_format_t_swigregister
number_format_t_swigregister(number_format_t)
NF_FIXED = _idaapi.NF_FIXED
NF_NEGDONE = _idaapi.NF_NEGDONE
NF_BINVDONE = _idaapi.NF_BINVDONE
NF_NEGATE = _idaapi.NF_NEGATE
NF_BITNOT = _idaapi.NF_BITNOT

class vd_printer_t(object):
    """
    Proxy of C++ vd_printer_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    hdrlines = _swig_property(_idaapi.vd_printer_t_hdrlines_get, _idaapi.vd_printer_t_hdrlines_set)
    def _print(self, *args):
        """
        _print(self, indent, format) -> int
        """
        return _idaapi.vd_printer_t__print(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> vd_printer_t
        """
        this = _idaapi.new_vd_printer_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_vd_printer_t
    __del__ = lambda self : None;
vd_printer_t_swigregister = _idaapi.vd_printer_t_swigregister
vd_printer_t_swigregister(vd_printer_t)

class vc_printer_t(vd_printer_t):
    """
    Proxy of C++ vc_printer_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    func = _swig_property(_idaapi.vc_printer_t_func_get, _idaapi.vc_printer_t_func_set)
    lastchar = _swig_property(_idaapi.vc_printer_t_lastchar_get, _idaapi.vc_printer_t_lastchar_set)
    def __init__(self, *args):
        """
        __init__(self, f) -> vc_printer_t
        """
        this = _idaapi.new_vc_printer_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def oneliner(self, *args):
        """
        oneliner(self) -> bool
        """
        return _idaapi.vc_printer_t_oneliner(self, *args)

    __swig_destroy__ = _idaapi.delete_vc_printer_t
    __del__ = lambda self : None;
vc_printer_t_swigregister = _idaapi.vc_printer_t_swigregister
vc_printer_t_swigregister(vc_printer_t)

class qstring_printer_t(vc_printer_t):
    """
    Proxy of C++ qstring_printer_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    with_tags = _swig_property(_idaapi.qstring_printer_t_with_tags_get, _idaapi.qstring_printer_t_with_tags_set)
    s = _swig_property(_idaapi.qstring_printer_t_s_get, _idaapi.qstring_printer_t_s_set)
    def _print(self, *args):
        """
        _print(self, indent, format) -> int
        """
        return _idaapi.qstring_printer_t__print(self, *args)

    def __init__(self, *args):
        """
        __init__(self, f, tags) -> qstring_printer_t
        """
        this = _idaapi.new_qstring_printer_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_s(self, *args):
        """
        get_s(self) -> qstring
        """
        return _idaapi.qstring_printer_t_get_s(self, *args)

    s = property(lambda self: self.get_s())

qstring_printer_t_swigregister = _idaapi.qstring_printer_t_swigregister
qstring_printer_t_swigregister(qstring_printer_t)


def is_type_correct(*args):
  """
  is_type_correct(ptr) -> bool
  """
  return _idaapi.is_type_correct(*args)

def is_small_struni(*args):
  """
  is_small_struni(tif) -> bool
  """
  return _idaapi.is_small_struni(*args)

def is_nonbool_type(*args):
  """
  is_nonbool_type(type) -> bool
  """
  return _idaapi.is_nonbool_type(*args)

def is_bool_type(*args):
  """
  is_bool_type(type) -> bool
  """
  return _idaapi.is_bool_type(*args)

def is_ptr_or_array(*args):
  """
  is_ptr_or_array(t) -> bool
  """
  return _idaapi.is_ptr_or_array(*args)

def is_paf(*args):
  """
  is_paf(t) -> bool
  """
  return _idaapi.is_paf(*args)

def partial_type_num(*args):
  """
  partial_type_num(type) -> int
  """
  return _idaapi.partial_type_num(*args)

def get_float_type(*args):
  """
  get_float_type(width) -> tinfo_t
  """
  return _idaapi.get_float_type(*args)

def get_int_type_by_width_and_sign(*args):
  """
  get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t
  """
  return _idaapi.get_int_type_by_width_and_sign(*args)

def get_unk_type(*args):
  """
  get_unk_type(size) -> tinfo_t
  """
  return _idaapi.get_unk_type(*args)

def dummy_ptrtype(*args):
  """
  dummy_ptrtype(ptrsize, isfp) -> tinfo_t
  """
  return _idaapi.dummy_ptrtype(*args)

def get_member_type(*args):
  """
  get_member_type(mptr, type) -> bool
  """
  return _idaapi.get_member_type(*args)

def make_pointer(*args):
  """
  make_pointer(type) -> tinfo_t
  """
  return _idaapi.make_pointer(*args)

def create_typedef(*args):
  """
    create_typedef(name) -> tinfo_t
    create_typedef(n) -> tinfo_t
    """
  return _idaapi.create_typedef(*args)
GUESSED_NONE = _idaapi.GUESSED_NONE
GUESSED_WEAK = _idaapi.GUESSED_WEAK
GUESSED_FUNC = _idaapi.GUESSED_FUNC
GUESSED_DATA = _idaapi.GUESSED_DATA
TS_NOELL = _idaapi.TS_NOELL
TS_SHRINK = _idaapi.TS_SHRINK
TS_MASK = _idaapi.TS_MASK

def compare_typsrc(*args):
  """
  compare_typsrc(s1, s2) -> int
  """
  return _idaapi.compare_typsrc(*args)

def get_type(*args):
  """
  get_type(id, tif, guess) -> bool
  """
  return _idaapi.get_type(*args)

def set_type(*args):
  """
  set_type(id, tif, source, force=False) -> bool
  """
  return _idaapi.set_type(*args)
class vdloc_t(argloc_t):
    """
    Proxy of C++ vdloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def reg1(self, *args):
        """
        reg1(self) -> int
        """
        return _idaapi.vdloc_t_reg1(self, *args)

    def _set_reg1(self, *args):
        """
        _set_reg1(self, r1)
        """
        return _idaapi.vdloc_t__set_reg1(self, *args)

    def set_reg1(self, *args):
        """
        set_reg1(self, r1)
        """
        return _idaapi.vdloc_t_set_reg1(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> vdloc_t
        """
        this = _idaapi.new_vdloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_vdloc_t
    __del__ = lambda self : None;
vdloc_t_swigregister = _idaapi.vdloc_t_swigregister
vdloc_t_swigregister(vdloc_t)


def print_vdloc(*args):
  """
  print_vdloc(loc, w) -> size_t
  """
  return _idaapi.print_vdloc(*args)

def arglocs_overlap(*args):
  """
  arglocs_overlap(loc1, w1, loc2, w2) -> bool
  """
  return _idaapi.arglocs_overlap(*args)
class lvar_locator_t(object):
    """
    Proxy of C++ lvar_locator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    location = _swig_property(_idaapi.lvar_locator_t_location_get, _idaapi.lvar_locator_t_location_set)
    defea = _swig_property(_idaapi.lvar_locator_t_defea_get, _idaapi.lvar_locator_t_defea_set)
    def __init__(self, *args):
        """
        __init__(self) -> lvar_locator_t
        __init__(self, loc, ea) -> lvar_locator_t
        """
        this = _idaapi.new_lvar_locator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_regnum(self, *args):
        """
        get_regnum(self) -> sval_t
        """
        return _idaapi.lvar_locator_t_get_regnum(self, *args)

    def is_reg1(self, *args):
        """
        is_reg1(self) -> bool
        """
        return _idaapi.lvar_locator_t_is_reg1(self, *args)

    def is_reg2(self, *args):
        """
        is_reg2(self) -> bool
        """
        return _idaapi.lvar_locator_t_is_reg2(self, *args)

    def is_reg_var(self, *args):
        """
        is_reg_var(self) -> bool
        """
        return _idaapi.lvar_locator_t_is_reg_var(self, *args)

    def is_stk_var(self, *args):
        """
        is_stk_var(self) -> bool
        """
        return _idaapi.lvar_locator_t_is_stk_var(self, *args)

    def is_scattered(self, *args):
        """
        is_scattered(self) -> bool
        """
        return _idaapi.lvar_locator_t_is_scattered(self, *args)

    def get_reg1(self, *args):
        """
        get_reg1(self) -> mreg_t
        """
        return _idaapi.lvar_locator_t_get_reg1(self, *args)

    def get_reg2(self, *args):
        """
        get_reg2(self) -> mreg_t
        """
        return _idaapi.lvar_locator_t_get_reg2(self, *args)

    def get_scattered(self, *args):
        """
        get_scattered(self) -> scattered_aloc_t
        get_scattered(self) -> scattered_aloc_t
        """
        return _idaapi.lvar_locator_t_get_scattered(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.lvar_locator_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.lvar_locator_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_lvar_locator_t
    __del__ = lambda self : None;
lvar_locator_t_swigregister = _idaapi.lvar_locator_t_swigregister
lvar_locator_t_swigregister(lvar_locator_t)

class lvar_t(lvar_locator_t):
    """
    Proxy of C++ lvar_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    name = _swig_property(_idaapi.lvar_t_name_get, _idaapi.lvar_t_name_set)
    cmt = _swig_property(_idaapi.lvar_t_cmt_get, _idaapi.lvar_t_cmt_set)
    tif = _swig_property(_idaapi.lvar_t_tif_get, _idaapi.lvar_t_tif_set)
    width = _swig_property(_idaapi.lvar_t_width_get, _idaapi.lvar_t_width_set)
    defblk = _swig_property(_idaapi.lvar_t_defblk_get, _idaapi.lvar_t_defblk_set)
    divisor = _swig_property(_idaapi.lvar_t_divisor_get, _idaapi.lvar_t_divisor_set)
    def used(self, *args):
        """
        used(self) -> bool
        """
        return _idaapi.lvar_t_used(self, *args)

    def typed(self, *args):
        """
        typed(self) -> bool
        """
        return _idaapi.lvar_t_typed(self, *args)

    def mreg_done(self, *args):
        """
        mreg_done(self) -> bool
        """
        return _idaapi.lvar_t_mreg_done(self, *args)

    def has_nice_name(self, *args):
        """
        has_nice_name(self) -> bool
        """
        return _idaapi.lvar_t_has_nice_name(self, *args)

    def is_unknown_width(self, *args):
        """
        is_unknown_width(self) -> bool
        """
        return _idaapi.lvar_t_is_unknown_width(self, *args)

    def has_user_info(self, *args):
        """
        has_user_info(self) -> bool
        """
        return _idaapi.lvar_t_has_user_info(self, *args)

    def has_user_name(self, *args):
        """
        has_user_name(self) -> bool
        """
        return _idaapi.lvar_t_has_user_name(self, *args)

    def has_user_type(self, *args):
        """
        has_user_type(self) -> bool
        """
        return _idaapi.lvar_t_has_user_type(self, *args)

    def is_result_var(self, *args):
        """
        is_result_var(self) -> bool
        """
        return _idaapi.lvar_t_is_result_var(self, *args)

    def is_arg_var(self, *args):
        """
        is_arg_var(self) -> bool
        """
        return _idaapi.lvar_t_is_arg_var(self, *args)

    def is_fake_var(self, *args):
        """
        is_fake_var(self) -> bool
        """
        return _idaapi.lvar_t_is_fake_var(self, *args)

    def is_overlapped_var(self, *args):
        """
        is_overlapped_var(self) -> bool
        """
        return _idaapi.lvar_t_is_overlapped_var(self, *args)

    def is_floating_var(self, *args):
        """
        is_floating_var(self) -> bool
        """
        return _idaapi.lvar_t_is_floating_var(self, *args)

    def is_spoiled_var(self, *args):
        """
        is_spoiled_var(self) -> bool
        """
        return _idaapi.lvar_t_is_spoiled_var(self, *args)

    def is_mapdst_var(self, *args):
        """
        is_mapdst_var(self) -> bool
        """
        return _idaapi.lvar_t_is_mapdst_var(self, *args)

    def set_used(self, *args):
        """
        set_used(self)
        """
        return _idaapi.lvar_t_set_used(self, *args)

    def clear_used(self, *args):
        """
        clear_used(self)
        """
        return _idaapi.lvar_t_clear_used(self, *args)

    def set_typed(self, *args):
        """
        set_typed(self)
        """
        return _idaapi.lvar_t_set_typed(self, *args)

    def set_non_typed(self, *args):
        """
        set_non_typed(self)
        """
        return _idaapi.lvar_t_set_non_typed(self, *args)

    def clr_user_info(self, *args):
        """
        clr_user_info(self)
        """
        return _idaapi.lvar_t_clr_user_info(self, *args)

    def set_user_name(self, *args):
        """
        set_user_name(self)
        """
        return _idaapi.lvar_t_set_user_name(self, *args)

    def set_user_type(self, *args):
        """
        set_user_type(self)
        """
        return _idaapi.lvar_t_set_user_type(self, *args)

    def clr_user_type(self, *args):
        """
        clr_user_type(self)
        """
        return _idaapi.lvar_t_clr_user_type(self, *args)

    def clr_user_name(self, *args):
        """
        clr_user_name(self)
        """
        return _idaapi.lvar_t_clr_user_name(self, *args)

    def set_mreg_done(self, *args):
        """
        set_mreg_done(self)
        """
        return _idaapi.lvar_t_set_mreg_done(self, *args)

    def clr_mreg_done(self, *args):
        """
        clr_mreg_done(self)
        """
        return _idaapi.lvar_t_clr_mreg_done(self, *args)

    def set_unknown_width(self, *args):
        """
        set_unknown_width(self)
        """
        return _idaapi.lvar_t_set_unknown_width(self, *args)

    def clr_unknown_width(self, *args):
        """
        clr_unknown_width(self)
        """
        return _idaapi.lvar_t_clr_unknown_width(self, *args)

    def set_arg_var(self, *args):
        """
        set_arg_var(self)
        """
        return _idaapi.lvar_t_set_arg_var(self, *args)

    def clr_arg_var(self, *args):
        """
        clr_arg_var(self)
        """
        return _idaapi.lvar_t_clr_arg_var(self, *args)

    def set_fake_var(self, *args):
        """
        set_fake_var(self)
        """
        return _idaapi.lvar_t_set_fake_var(self, *args)

    def clr_fake_var(self, *args):
        """
        clr_fake_var(self)
        """
        return _idaapi.lvar_t_clr_fake_var(self, *args)

    def set_overlapped_var(self, *args):
        """
        set_overlapped_var(self)
        """
        return _idaapi.lvar_t_set_overlapped_var(self, *args)

    def clr_overlapped_var(self, *args):
        """
        clr_overlapped_var(self)
        """
        return _idaapi.lvar_t_clr_overlapped_var(self, *args)

    def set_floating_var(self, *args):
        """
        set_floating_var(self)
        """
        return _idaapi.lvar_t_set_floating_var(self, *args)

    def clr_floating_var(self, *args):
        """
        clr_floating_var(self)
        """
        return _idaapi.lvar_t_clr_floating_var(self, *args)

    def set_spoiled_var(self, *args):
        """
        set_spoiled_var(self)
        """
        return _idaapi.lvar_t_set_spoiled_var(self, *args)

    def clr_spoiled_var(self, *args):
        """
        clr_spoiled_var(self)
        """
        return _idaapi.lvar_t_clr_spoiled_var(self, *args)

    def set_mapdst_var(self, *args):
        """
        set_mapdst_var(self)
        """
        return _idaapi.lvar_t_set_mapdst_var(self, *args)

    def clr_mapdst_var(self, *args):
        """
        clr_mapdst_var(self)
        """
        return _idaapi.lvar_t_clr_mapdst_var(self, *args)

    def set_reg_name(self, *args):
        """
        set_reg_name(self, n)
        """
        return _idaapi.lvar_t_set_reg_name(self, *args)

    def has_common(self, *args):
        """
        has_common(self, v) -> bool
        """
        return _idaapi.lvar_t_has_common(self, *args)

    def has_common_bit(self, *args):
        """
        has_common_bit(self, loc, width2) -> bool
        """
        return _idaapi.lvar_t_has_common_bit(self, *args)

    def type(self, *args):
        """
        type(self) -> tinfo_t
        type(self) -> tinfo_t
        """
        return _idaapi.lvar_t_type(self, *args)

    def accepts_type(self, *args):
        """
        accepts_type(self, t) -> bool
        """
        return _idaapi.lvar_t_accepts_type(self, *args)

    def force_lvar_type(self, *args):
        """
        force_lvar_type(self, t)
        """
        return _idaapi.lvar_t_force_lvar_type(self, *args)

    def set_lvar_type(self, *args):
        """
        set_lvar_type(self, t)
        """
        return _idaapi.lvar_t_set_lvar_type(self, *args)

    def set_final_lvar_type(self, *args):
        """
        set_final_lvar_type(self, t)
        """
        return _idaapi.lvar_t_set_final_lvar_type(self, *args)

    def set_width(self, *args):
        """
        set_width(self, w, is_float=False)
        """
        return _idaapi.lvar_t_set_width(self, *args)

    __swig_destroy__ = _idaapi.delete_lvar_t
    __del__ = lambda self : None;
lvar_t_swigregister = _idaapi.lvar_t_swigregister
lvar_t_swigregister(lvar_t)

class lvars_t(qvector_lvar_t):
    """
    Proxy of C++ lvars_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def find_input_lvar(self, *args):
        """
        find_input_lvar(self, argloc, _size) -> int
        """
        return _idaapi.lvars_t_find_input_lvar(self, *args)

    def find_stkvar(self, *args):
        """
        find_stkvar(self, spoff, width) -> int
        """
        return _idaapi.lvars_t_find_stkvar(self, *args)

    def find(self, *args):
        """
        find(self, ll) -> lvar_t
        """
        return _idaapi.lvars_t_find(self, *args)

    def find_lvar(self, *args):
        """
        find_lvar(self, location, width, defblk=-1) -> int
        """
        return _idaapi.lvars_t_find_lvar(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> lvars_t
        """
        this = _idaapi.new_lvars_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lvars_t
    __del__ = lambda self : None;
lvars_t_swigregister = _idaapi.lvars_t_swigregister
lvars_t_swigregister(lvars_t)

class lvar_saved_info_t(object):
    """
    Proxy of C++ lvar_saved_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ll = _swig_property(_idaapi.lvar_saved_info_t_ll_get, _idaapi.lvar_saved_info_t_ll_set)
    name = _swig_property(_idaapi.lvar_saved_info_t_name_get, _idaapi.lvar_saved_info_t_name_set)
    type = _swig_property(_idaapi.lvar_saved_info_t_type_get, _idaapi.lvar_saved_info_t_type_set)
    cmt = _swig_property(_idaapi.lvar_saved_info_t_cmt_get, _idaapi.lvar_saved_info_t_cmt_set)
    def has_info(self, *args):
        """
        has_info(self) -> bool
        """
        return _idaapi.lvar_saved_info_t_has_info(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> lvar_saved_info_t
        """
        this = _idaapi.new_lvar_saved_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lvar_saved_info_t
    __del__ = lambda self : None;
lvar_saved_info_t_swigregister = _idaapi.lvar_saved_info_t_swigregister
lvar_saved_info_t_swigregister(lvar_saved_info_t)

class user_lvar_visitor_t(object):
    """
    Proxy of C++ user_lvar_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    stkoff_delta = _swig_property(_idaapi.user_lvar_visitor_t_stkoff_delta_get, _idaapi.user_lvar_visitor_t_stkoff_delta_set)
    flags = _swig_property(_idaapi.user_lvar_visitor_t_flags_get, _idaapi.user_lvar_visitor_t_flags_set)
    def __init__(self, *args):
        """
        __init__(self) -> user_lvar_visitor_t
        """
        if self.__class__ == user_lvar_visitor_t:
            _self = None
        else:
            _self = self
        this = _idaapi.new_user_lvar_visitor_t(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def handle_retrieved_info(self, *args):
        """
        handle_retrieved_info(self, lv) -> int
        """
        return _idaapi.user_lvar_visitor_t_handle_retrieved_info(self, *args)

    def handle_retrieved_mapping(self, *args):
        """
        handle_retrieved_mapping(self, lm) -> int
        """
        return _idaapi.user_lvar_visitor_t_handle_retrieved_mapping(self, *args)

    def get_info_qty_for_saving(self, *args):
        """
        get_info_qty_for_saving(self) -> int
        """
        return _idaapi.user_lvar_visitor_t_get_info_qty_for_saving(self, *args)

    def get_info_for_saving(self, *args):
        """
        get_info_for_saving(self, lv) -> bool
        """
        return _idaapi.user_lvar_visitor_t_get_info_for_saving(self, *args)

    def get_info_mapping_for_saving(self, *args):
        """
        get_info_mapping_for_saving(self) -> lvar_mapping_t
        """
        return _idaapi.user_lvar_visitor_t_get_info_mapping_for_saving(self, *args)

    __swig_destroy__ = _idaapi.delete_user_lvar_visitor_t
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_user_lvar_visitor_t(self)
        return weakref_proxy(self)
user_lvar_visitor_t_swigregister = _idaapi.user_lvar_visitor_t_swigregister
user_lvar_visitor_t_swigregister(user_lvar_visitor_t)
ULV_PRECISE_DEFEA = _idaapi.ULV_PRECISE_DEFEA


def restore_user_lvar_settings(*args):
  """
  restore_user_lvar_settings(func_ea, ulv) -> int
  """
  return _idaapi.restore_user_lvar_settings(*args)

def save_user_lvar_settings(*args):
  """
  save_user_lvar_settings(func_ea, ulv)
  """
  return _idaapi.save_user_lvar_settings(*args)
class fnumber_t(object):
    """
    Proxy of C++ fnumber_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    fnum = _swig_property(_idaapi.fnumber_t_fnum_get, _idaapi.fnumber_t_fnum_set)
    nbytes = _swig_property(_idaapi.fnumber_t_nbytes_get, _idaapi.fnumber_t_nbytes_set)
    def dereference_uint16(self, *args):
        """
        dereference_uint16(self) -> uint16 *
        """
        return _idaapi.fnumber_t_dereference_uint16(self, *args)

    def dereference_const_uint16(self, *args):
        """
        dereference_const_uint16(self) -> uint16 const *
        """
        return _idaapi.fnumber_t_dereference_const_uint16(self, *args)

    def _print(self, *args):
        """
        _print(self) -> size_t
        """
        return _idaapi.fnumber_t__print(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.fnumber_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.fnumber_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.fnumber_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.fnumber_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.fnumber_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.fnumber_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.fnumber_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> fnumber_t
        """
        this = _idaapi.new_fnumber_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_fnumber_t
    __del__ = lambda self : None;
fnumber_t_swigregister = _idaapi.fnumber_t_swigregister
fnumber_t_swigregister(fnumber_t)

WARN_VARARG_REGS = _idaapi.WARN_VARARG_REGS
WARN_ILL_PURGED = _idaapi.WARN_ILL_PURGED
WARN_ILL_FUNCTYPE = _idaapi.WARN_ILL_FUNCTYPE
WARN_VARARG_TCAL = _idaapi.WARN_VARARG_TCAL
WARN_VARARG_NOSTK = _idaapi.WARN_VARARG_NOSTK
WARN_VARARG_MANY = _idaapi.WARN_VARARG_MANY
WARN_ADDR_OUTARGS = _idaapi.WARN_ADDR_OUTARGS
WARN_DEP_UNK_CALLS = _idaapi.WARN_DEP_UNK_CALLS
WARN_ILL_ELLIPSIS = _idaapi.WARN_ILL_ELLIPSIS
WARN_GUESSED_TYPE = _idaapi.WARN_GUESSED_TYPE
WARN_EXP_LINVAR = _idaapi.WARN_EXP_LINVAR
WARN_WIDEN_CHAINS = _idaapi.WARN_WIDEN_CHAINS
WARN_BAD_PURGED = _idaapi.WARN_BAD_PURGED
WARN_CBUILD_LOOPS = _idaapi.WARN_CBUILD_LOOPS
WARN_NO_SAVE_REST = _idaapi.WARN_NO_SAVE_REST
WARN_ODD_INPUT_REG = _idaapi.WARN_ODD_INPUT_REG
WARN_ODD_ADDR_USE = _idaapi.WARN_ODD_ADDR_USE
WARN_MUST_RET_FP = _idaapi.WARN_MUST_RET_FP
WARN_ILL_FPU_STACK = _idaapi.WARN_ILL_FPU_STACK
WARN_SELFREF_PROP = _idaapi.WARN_SELFREF_PROP
WARN_WOULD_OVERLAP = _idaapi.WARN_WOULD_OVERLAP
WARN_ARRAY_INARG = _idaapi.WARN_ARRAY_INARG
WARN_MAX_ARGS = _idaapi.WARN_MAX_ARGS
WARN_BAD_FIELD_TYPE = _idaapi.WARN_BAD_FIELD_TYPE
WARN_WRITE_CONST = _idaapi.WARN_WRITE_CONST
WARN_BAD_RETVAR = _idaapi.WARN_BAD_RETVAR
WARN_FRAG_LVAR = _idaapi.WARN_FRAG_LVAR
WARN_HUGE_STKOFF = _idaapi.WARN_HUGE_STKOFF
WARN_UNINITED_REG = _idaapi.WARN_UNINITED_REG
WARN_SPLIT_MACRO = _idaapi.WARN_SPLIT_MACRO
WARN_MAX = _idaapi.WARN_MAX
class hexwarn_t(object):
    """
    Proxy of C++ hexwarn_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.hexwarn_t_ea_get, _idaapi.hexwarn_t_ea_set)
    id = _swig_property(_idaapi.hexwarn_t_id_get, _idaapi.hexwarn_t_id_set)
    text = _swig_property(_idaapi.hexwarn_t_text_get, _idaapi.hexwarn_t_text_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.hexwarn_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.hexwarn_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> hexwarn_t
        """
        this = _idaapi.new_hexwarn_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_hexwarn_t
    __del__ = lambda self : None;
hexwarn_t_swigregister = _idaapi.hexwarn_t_swigregister
hexwarn_t_swigregister(hexwarn_t)


def get_hexrays_version(*args):
  """
  get_hexrays_version() -> char const *
  """
  return _idaapi.get_hexrays_version(*args)

def open_pseudocode(*args):
  """
  open_pseudocode(ea, new_window) -> vdui_t
  """
  return _idaapi.open_pseudocode(*args)

def close_pseudocode(*args):
  """
  close_pseudocode(f) -> bool
  """
  return _idaapi.close_pseudocode(*args)

def get_tform_vdui(*args):
  """
  get_tform_vdui(f) -> vdui_t
  """
  return _idaapi.get_tform_vdui(*args)
VDRUN_NEWFILE = _idaapi.VDRUN_NEWFILE
VDRUN_APPEND = _idaapi.VDRUN_APPEND
VDRUN_ONLYNEW = _idaapi.VDRUN_ONLYNEW
VDRUN_SILENT = _idaapi.VDRUN_SILENT
VDRUN_SENDIDB = _idaapi.VDRUN_SENDIDB
VDRUN_MAYSTOP = _idaapi.VDRUN_MAYSTOP
VDRUN_CMDLINE = _idaapi.VDRUN_CMDLINE
VDRUN_STATS = _idaapi.VDRUN_STATS

def decompile_many(*args):
  """
  decompile_many(outfile, funcaddrs, flags) -> bool
  """
  return _idaapi.decompile_many(*args)

def micro_err_format(*args):
  """
  micro_err_format(code) -> char const *
  """
  return _idaapi.micro_err_format(*args)
MERR_OK = _idaapi.MERR_OK
MERR_BLOCK = _idaapi.MERR_BLOCK
MERR_INTERR = _idaapi.MERR_INTERR
MERR_INSN = _idaapi.MERR_INSN
MERR_MEM = _idaapi.MERR_MEM
MERR_BADBLK = _idaapi.MERR_BADBLK
MERR_BADSP = _idaapi.MERR_BADSP
MERR_PROLOG = _idaapi.MERR_PROLOG
MERR_SWITCH = _idaapi.MERR_SWITCH
MERR_EXCEPTION = _idaapi.MERR_EXCEPTION
MERR_HUGESTACK = _idaapi.MERR_HUGESTACK
MERR_LVARS = _idaapi.MERR_LVARS
MERR_BITNESS = _idaapi.MERR_BITNESS
MERR_BADCALL = _idaapi.MERR_BADCALL
MERR_BADFRAME = _idaapi.MERR_BADFRAME
MERR_UNKTYPE = _idaapi.MERR_UNKTYPE
MERR_BADIDB = _idaapi.MERR_BADIDB
MERR_SIZEOF = _idaapi.MERR_SIZEOF
MERR_REDO = _idaapi.MERR_REDO
MERR_CANCELED = _idaapi.MERR_CANCELED
MERR_RECDEPTH = _idaapi.MERR_RECDEPTH
MERR_OVERLAP = _idaapi.MERR_OVERLAP
MERR_PARTINIT = _idaapi.MERR_PARTINIT
MERR_COMPLEX = _idaapi.MERR_COMPLEX
MERR_LICENSE = _idaapi.MERR_LICENSE
MERR_ONLY32 = _idaapi.MERR_ONLY32
MERR_ONLY64 = _idaapi.MERR_ONLY64
MERR_BUSY = _idaapi.MERR_BUSY
MERR_FARPTR = _idaapi.MERR_FARPTR
MERR_MAX_ERR = _idaapi.MERR_MAX_ERR
MERR_LOOP = _idaapi.MERR_LOOP
class hexrays_failure_t(object):
    """
    Proxy of C++ hexrays_failure_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    code = _swig_property(_idaapi.hexrays_failure_t_code_get, _idaapi.hexrays_failure_t_code_set)
    errea = _swig_property(_idaapi.hexrays_failure_t_errea_get, _idaapi.hexrays_failure_t_errea_set)
    str = _swig_property(_idaapi.hexrays_failure_t_str_get, _idaapi.hexrays_failure_t_str_set)
    def __init__(self, *args):
        """
        __init__(self) -> hexrays_failure_t
        __init__(self, c, ea, buf=None) -> hexrays_failure_t
        __init__(self, c, ea, buf) -> hexrays_failure_t
        """
        this = _idaapi.new_hexrays_failure_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def desc(self, *args):
        """
        desc(self) -> qstring
        """
        return _idaapi.hexrays_failure_t_desc(self, *args)

    __swig_destroy__ = _idaapi.delete_hexrays_failure_t
    __del__ = lambda self : None;
hexrays_failure_t_swigregister = _idaapi.hexrays_failure_t_swigregister
hexrays_failure_t_swigregister(hexrays_failure_t)

class vd_failure_t(object):
    """
    Proxy of C++ vd_failure_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    hf = _swig_property(_idaapi.vd_failure_t_hf_get, _idaapi.vd_failure_t_hf_set)
    def __init__(self, *args):
        """
        __init__(self) -> vd_failure_t
        __init__(self, code, ea, buf=None) -> vd_failure_t
        __init__(self, code, ea, buf) -> vd_failure_t
        __init__(self, _hf) -> vd_failure_t
        """
        this = _idaapi.new_vd_failure_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def desc(self, *args):
        """
        desc(self) -> qstring
        """
        return _idaapi.vd_failure_t_desc(self, *args)

    __swig_destroy__ = _idaapi.delete_vd_failure_t
    __del__ = lambda self : None;
vd_failure_t_swigregister = _idaapi.vd_failure_t_swigregister
vd_failure_t_swigregister(vd_failure_t)

class vd_interr_t(vd_failure_t):
    """
    Proxy of C++ vd_interr_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, ea, buf) -> vd_interr_t
        __init__(self, ea, buf) -> vd_interr_t
        """
        this = _idaapi.new_vd_interr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_vd_interr_t
    __del__ = lambda self : None;
vd_interr_t_swigregister = _idaapi.vd_interr_t_swigregister
vd_interr_t_swigregister(vd_interr_t)


def send_database(*args):
  """
  send_database(err, silent)
  """
  return _idaapi.send_database(*args)
cot_empty = _idaapi.cot_empty
cot_comma = _idaapi.cot_comma
cot_asg = _idaapi.cot_asg
cot_asgbor = _idaapi.cot_asgbor
cot_asgxor = _idaapi.cot_asgxor
cot_asgband = _idaapi.cot_asgband
cot_asgadd = _idaapi.cot_asgadd
cot_asgsub = _idaapi.cot_asgsub
cot_asgmul = _idaapi.cot_asgmul
cot_asgsshr = _idaapi.cot_asgsshr
cot_asgushr = _idaapi.cot_asgushr
cot_asgshl = _idaapi.cot_asgshl
cot_asgsdiv = _idaapi.cot_asgsdiv
cot_asgudiv = _idaapi.cot_asgudiv
cot_asgsmod = _idaapi.cot_asgsmod
cot_asgumod = _idaapi.cot_asgumod
cot_tern = _idaapi.cot_tern
cot_lor = _idaapi.cot_lor
cot_land = _idaapi.cot_land
cot_bor = _idaapi.cot_bor
cot_xor = _idaapi.cot_xor
cot_band = _idaapi.cot_band
cot_eq = _idaapi.cot_eq
cot_ne = _idaapi.cot_ne
cot_sge = _idaapi.cot_sge
cot_uge = _idaapi.cot_uge
cot_sle = _idaapi.cot_sle
cot_ule = _idaapi.cot_ule
cot_sgt = _idaapi.cot_sgt
cot_ugt = _idaapi.cot_ugt
cot_slt = _idaapi.cot_slt
cot_ult = _idaapi.cot_ult
cot_sshr = _idaapi.cot_sshr
cot_ushr = _idaapi.cot_ushr
cot_shl = _idaapi.cot_shl
cot_add = _idaapi.cot_add
cot_sub = _idaapi.cot_sub
cot_mul = _idaapi.cot_mul
cot_sdiv = _idaapi.cot_sdiv
cot_udiv = _idaapi.cot_udiv
cot_smod = _idaapi.cot_smod
cot_umod = _idaapi.cot_umod
cot_fadd = _idaapi.cot_fadd
cot_fsub = _idaapi.cot_fsub
cot_fmul = _idaapi.cot_fmul
cot_fdiv = _idaapi.cot_fdiv
cot_fneg = _idaapi.cot_fneg
cot_neg = _idaapi.cot_neg
cot_cast = _idaapi.cot_cast
cot_lnot = _idaapi.cot_lnot
cot_bnot = _idaapi.cot_bnot
cot_ptr = _idaapi.cot_ptr
cot_ref = _idaapi.cot_ref
cot_postinc = _idaapi.cot_postinc
cot_postdec = _idaapi.cot_postdec
cot_preinc = _idaapi.cot_preinc
cot_predec = _idaapi.cot_predec
cot_call = _idaapi.cot_call
cot_idx = _idaapi.cot_idx
cot_memref = _idaapi.cot_memref
cot_memptr = _idaapi.cot_memptr
cot_num = _idaapi.cot_num
cot_fnum = _idaapi.cot_fnum
cot_str = _idaapi.cot_str
cot_obj = _idaapi.cot_obj
cot_var = _idaapi.cot_var
cot_insn = _idaapi.cot_insn
cot_sizeof = _idaapi.cot_sizeof
cot_helper = _idaapi.cot_helper
cot_type = _idaapi.cot_type
cot_last = _idaapi.cot_last
cit_empty = _idaapi.cit_empty
cit_block = _idaapi.cit_block
cit_expr = _idaapi.cit_expr
cit_if = _idaapi.cit_if
cit_for = _idaapi.cit_for
cit_while = _idaapi.cit_while
cit_do = _idaapi.cit_do
cit_switch = _idaapi.cit_switch
cit_break = _idaapi.cit_break
cit_continue = _idaapi.cit_continue
cit_return = _idaapi.cit_return
cit_goto = _idaapi.cit_goto
cit_asm = _idaapi.cit_asm
cit_end = _idaapi.cit_end
class operator_info_t(object):
    """
    Proxy of C++ operator_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    text = _swig_property(_idaapi.operator_info_t_text_get, _idaapi.operator_info_t_text_set)
    precedence = _swig_property(_idaapi.operator_info_t_precedence_get, _idaapi.operator_info_t_precedence_set)
    valency = _swig_property(_idaapi.operator_info_t_valency_get, _idaapi.operator_info_t_valency_set)
    fixtype = _swig_property(_idaapi.operator_info_t_fixtype_get, _idaapi.operator_info_t_fixtype_set)
    flags = _swig_property(_idaapi.operator_info_t_flags_get, _idaapi.operator_info_t_flags_set)
    def __init__(self, *args):
        """
        __init__(self) -> operator_info_t
        """
        this = _idaapi.new_operator_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_operator_info_t
    __del__ = lambda self : None;
operator_info_t_swigregister = _idaapi.operator_info_t_swigregister
operator_info_t_swigregister(operator_info_t)
FX_NONE = cvar.FX_NONE
FX_INFIX = cvar.FX_INFIX
FX_PREFIX = cvar.FX_PREFIX
FX_POSTFIX = cvar.FX_POSTFIX
FX_TERNARY = cvar.FX_TERNARY
COI_RL = cvar.COI_RL
COI_LR = cvar.COI_LR
COI_INT = cvar.COI_INT
COI_FP = cvar.COI_FP
COI_SH = cvar.COI_SH
COI_SGN = cvar.COI_SGN
COI_SBN = cvar.COI_SBN


def negated_relation(*args):
  """
  negated_relation(op) -> ctype_t
  """
  return _idaapi.negated_relation(*args)

def get_op_signness(*args):
  """
  get_op_signness(op) -> type_sign_t
  """
  return _idaapi.get_op_signness(*args)

def asgop(*args):
  """
  asgop(cop) -> ctype_t
  """
  return _idaapi.asgop(*args)

def asgop_revert(*args):
  """
  asgop_revert(cop) -> ctype_t
  """
  return _idaapi.asgop_revert(*args)

def op_uses_x(*args):
  """
  op_uses_x(op) -> bool
  """
  return _idaapi.op_uses_x(*args)

def op_uses_y(*args):
  """
  op_uses_y(op) -> bool
  """
  return _idaapi.op_uses_y(*args)

def op_uses_z(*args):
  """
  op_uses_z(op) -> bool
  """
  return _idaapi.op_uses_z(*args)

def is_binary(*args):
  """
  is_binary(op) -> bool
  """
  return _idaapi.is_binary(*args)

def is_unary(*args):
  """
  is_unary(op) -> bool
  """
  return _idaapi.is_unary(*args)

def is_relational(*args):
  """
  is_relational(op) -> bool
  """
  return _idaapi.is_relational(*args)

def is_assignment(*args):
  """
  is_assignment(op) -> bool
  """
  return _idaapi.is_assignment(*args)

def accepts_udts(*args):
  """
  accepts_udts(op) -> bool
  """
  return _idaapi.accepts_udts(*args)

def is_prepost(*args):
  """
  is_prepost(op) -> bool
  """
  return _idaapi.is_prepost(*args)

def is_commutative(*args):
  """
  is_commutative(op) -> bool
  """
  return _idaapi.is_commutative(*args)

def is_additive(*args):
  """
  is_additive(op) -> bool
  """
  return _idaapi.is_additive(*args)

def is_multiplicative(*args):
  """
  is_multiplicative(op) -> bool
  """
  return _idaapi.is_multiplicative(*args)

def is_bitop(*args):
  """
  is_bitop(op) -> bool
  """
  return _idaapi.is_bitop(*args)

def is_logical(*args):
  """
  is_logical(op) -> bool
  """
  return _idaapi.is_logical(*args)

def is_loop(*args):
  """
  is_loop(op) -> bool
  """
  return _idaapi.is_loop(*args)

def is_break_consumer(*args):
  """
  is_break_consumer(op) -> bool
  """
  return _idaapi.is_break_consumer(*args)

def is_lvalue(*args):
  """
  is_lvalue(op) -> bool
  """
  return _idaapi.is_lvalue(*args)

def is_allowed_on_small_struni(*args):
  """
  is_allowed_on_small_struni(op) -> bool
  """
  return _idaapi.is_allowed_on_small_struni(*args)
class cnumber_t(object):
    """
    Proxy of C++ cnumber_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    _value = _swig_property(_idaapi.cnumber_t__value_get, _idaapi.cnumber_t__value_set)
    nf = _swig_property(_idaapi.cnumber_t_nf_get, _idaapi.cnumber_t_nf_set)
    def __init__(self, *args):
        """
        __init__(self, _opnum=0) -> cnumber_t
        """
        this = _idaapi.new_cnumber_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def _print(self, *args):
        """
        _print(self, type) -> size_t
        """
        return _idaapi.cnumber_t__print(self, *args)

    def value(self, *args):
        """
        value(self, type) -> uint64
        """
        return _idaapi.cnumber_t_value(self, *args)

    def assign(self, *args):
        """
        assign(self, v, nbytes, sign)
        """
        return _idaapi.cnumber_t_assign(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cnumber_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cnumber_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cnumber_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cnumber_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cnumber_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cnumber_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cnumber_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_cnumber_t
    __del__ = lambda self : None;
cnumber_t_swigregister = _idaapi.cnumber_t_swigregister
cnumber_t_swigregister(cnumber_t)

class var_ref_t(object):
    """
    Proxy of C++ var_ref_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mba = _swig_property(_idaapi.var_ref_t_mba_get, _idaapi.var_ref_t_mba_set)
    idx = _swig_property(_idaapi.var_ref_t_idx_get, _idaapi.var_ref_t_idx_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.var_ref_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.var_ref_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.var_ref_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.var_ref_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.var_ref_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.var_ref_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.var_ref_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> var_ref_t
        """
        this = _idaapi.new_var_ref_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_var_ref_t
    __del__ = lambda self : None;
var_ref_t_swigregister = _idaapi.var_ref_t_swigregister
var_ref_t_swigregister(var_ref_t)

class ctree_visitor_t(object):
    """
    Proxy of C++ ctree_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cv_flags = _swig_property(_idaapi.ctree_visitor_t_cv_flags_get, _idaapi.ctree_visitor_t_cv_flags_set)
    def maintain_parents(self, *args):
        """
        maintain_parents(self) -> bool
        """
        return _idaapi.ctree_visitor_t_maintain_parents(self, *args)

    def must_prune(self, *args):
        """
        must_prune(self) -> bool
        """
        return _idaapi.ctree_visitor_t_must_prune(self, *args)

    def must_restart(self, *args):
        """
        must_restart(self) -> bool
        """
        return _idaapi.ctree_visitor_t_must_restart(self, *args)

    def is_postorder(self, *args):
        """
        is_postorder(self) -> bool
        """
        return _idaapi.ctree_visitor_t_is_postorder(self, *args)

    def only_insns(self, *args):
        """
        only_insns(self) -> bool
        """
        return _idaapi.ctree_visitor_t_only_insns(self, *args)

    def prune_now(self, *args):
        """
        prune_now(self)
        """
        return _idaapi.ctree_visitor_t_prune_now(self, *args)

    def clr_prune(self, *args):
        """
        clr_prune(self)
        """
        return _idaapi.ctree_visitor_t_clr_prune(self, *args)

    def set_restart(self, *args):
        """
        set_restart(self)
        """
        return _idaapi.ctree_visitor_t_set_restart(self, *args)

    def clr_restart(self, *args):
        """
        clr_restart(self)
        """
        return _idaapi.ctree_visitor_t_clr_restart(self, *args)

    parents = _swig_property(_idaapi.ctree_visitor_t_parents_get, _idaapi.ctree_visitor_t_parents_set)
    def __init__(self, *args):
        """
        __init__(self, _flags) -> ctree_visitor_t
        """
        if self.__class__ == ctree_visitor_t:
            _self = None
        else:
            _self = self
        this = _idaapi.new_ctree_visitor_t(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def apply_to(self, *args):
        """
        apply_to(self, item, parent) -> int
        """
        return _idaapi.ctree_visitor_t_apply_to(self, *args)

    def apply_to_exprs(self, *args):
        """
        apply_to_exprs(self, item, parent) -> int
        """
        return _idaapi.ctree_visitor_t_apply_to_exprs(self, *args)

    def parent_expr(self, *args):
        """
        parent_expr(self) -> cexpr_t
        """
        return _idaapi.ctree_visitor_t_parent_expr(self, *args)

    def parent_insn(self, *args):
        """
        parent_insn(self) -> cinsn_t
        """
        return _idaapi.ctree_visitor_t_parent_insn(self, *args)

    def visit_insn(self, *args):
        """
        visit_insn(self, arg0) -> int
        """
        return _idaapi.ctree_visitor_t_visit_insn(self, *args)

    def visit_expr(self, *args):
        """
        visit_expr(self, arg0) -> int
        """
        return _idaapi.ctree_visitor_t_visit_expr(self, *args)

    def leave_insn(self, *args):
        """
        leave_insn(self, arg0) -> int
        """
        return _idaapi.ctree_visitor_t_leave_insn(self, *args)

    def leave_expr(self, *args):
        """
        leave_expr(self, arg0) -> int
        """
        return _idaapi.ctree_visitor_t_leave_expr(self, *args)

    __swig_destroy__ = _idaapi.delete_ctree_visitor_t
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_ctree_visitor_t(self)
        return weakref_proxy(self)
ctree_visitor_t_swigregister = _idaapi.ctree_visitor_t_swigregister
ctree_visitor_t_swigregister(ctree_visitor_t)
CV_FAST = _idaapi.CV_FAST
CV_PRUNE = _idaapi.CV_PRUNE
CV_PARENTS = _idaapi.CV_PARENTS
CV_POST = _idaapi.CV_POST
CV_RESTART = _idaapi.CV_RESTART
CV_INSNS = _idaapi.CV_INSNS

class ctree_parentee_t(ctree_visitor_t):
    """
    Proxy of C++ ctree_parentee_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, post=False) -> ctree_parentee_t
        """
        if self.__class__ == ctree_parentee_t:
            _self = None
        else:
            _self = self
        this = _idaapi.new_ctree_parentee_t(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def recalc_parent_types(self, *args):
        """
        recalc_parent_types(self) -> bool
        """
        return _idaapi.ctree_parentee_t_recalc_parent_types(self, *args)

    __swig_destroy__ = _idaapi.delete_ctree_parentee_t
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_ctree_parentee_t(self)
        return weakref_proxy(self)
ctree_parentee_t_swigregister = _idaapi.ctree_parentee_t_swigregister
ctree_parentee_t_swigregister(ctree_parentee_t)

class cfunc_parentee_t(ctree_parentee_t):
    """
    Proxy of C++ cfunc_parentee_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    func = _swig_property(_idaapi.cfunc_parentee_t_func_get, _idaapi.cfunc_parentee_t_func_set)
    def __init__(self, *args):
        """
        __init__(self, f, post=False) -> cfunc_parentee_t
        """
        if self.__class__ == cfunc_parentee_t:
            _self = None
        else:
            _self = self
        this = _idaapi.new_cfunc_parentee_t(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def calc_rvalue_type(self, *args):
        """
        calc_rvalue_type(self, target, e) -> bool
        """
        return _idaapi.cfunc_parentee_t_calc_rvalue_type(self, *args)

    __swig_destroy__ = _idaapi.delete_cfunc_parentee_t
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_cfunc_parentee_t(self)
        return weakref_proxy(self)
cfunc_parentee_t_swigregister = _idaapi.cfunc_parentee_t_swigregister
cfunc_parentee_t_swigregister(cfunc_parentee_t)

CMAT_ZERO = _idaapi.CMAT_ZERO
CMAT_BUILT = _idaapi.CMAT_BUILT
CMAT_TRANS1 = _idaapi.CMAT_TRANS1
CMAT_NICE = _idaapi.CMAT_NICE
CMAT_TRANS2 = _idaapi.CMAT_TRANS2
CMAT_CPA = _idaapi.CMAT_CPA
CMAT_TRANS3 = _idaapi.CMAT_TRANS3
CMAT_CASTED = _idaapi.CMAT_CASTED
CMAT_FINAL = _idaapi.CMAT_FINAL
ITP_EMPTY = _idaapi.ITP_EMPTY
ITP_ARG1 = _idaapi.ITP_ARG1
ITP_ARG64 = _idaapi.ITP_ARG64
ITP_BRACE1 = _idaapi.ITP_BRACE1
ITP_INNER_LAST = _idaapi.ITP_INNER_LAST
ITP_ASM = _idaapi.ITP_ASM
ITP_ELSE = _idaapi.ITP_ELSE
ITP_DO = _idaapi.ITP_DO
ITP_SEMI = _idaapi.ITP_SEMI
ITP_CURLY1 = _idaapi.ITP_CURLY1
ITP_CURLY2 = _idaapi.ITP_CURLY2
ITP_BRACE2 = _idaapi.ITP_BRACE2
ITP_COLON = _idaapi.ITP_COLON
ITP_BLOCK1 = _idaapi.ITP_BLOCK1
ITP_BLOCK2 = _idaapi.ITP_BLOCK2
ITP_CASE = _idaapi.ITP_CASE
ITP_SIGN = _idaapi.ITP_SIGN
class treeloc_t(object):
    """
    Proxy of C++ treeloc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.treeloc_t_ea_get, _idaapi.treeloc_t_ea_set)
    itp = _swig_property(_idaapi.treeloc_t_itp_get, _idaapi.treeloc_t_itp_set)
    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.treeloc_t___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.treeloc_t___eq__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> treeloc_t
        """
        this = _idaapi.new_treeloc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_treeloc_t
    __del__ = lambda self : None;
treeloc_t_swigregister = _idaapi.treeloc_t_swigregister
treeloc_t_swigregister(treeloc_t)

RETRIEVE_ONCE = _idaapi.RETRIEVE_ONCE
RETRIEVE_ALWAYS = _idaapi.RETRIEVE_ALWAYS
class citem_cmt_t(object):
    """
    Proxy of C++ citem_cmt_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    used = _swig_property(_idaapi.citem_cmt_t_used_get, _idaapi.citem_cmt_t_used_set)
    def __init__(self, *args):
        """
        __init__(self) -> citem_cmt_t
        __init__(self, s) -> citem_cmt_t
        """
        this = _idaapi.new_citem_cmt_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def c_str(self, *args):
        """
        c_str(self) -> char const *
        """
        return _idaapi.citem_cmt_t_c_str(self, *args)

    __swig_destroy__ = _idaapi.delete_citem_cmt_t
    __del__ = lambda self : None;
citem_cmt_t_swigregister = _idaapi.citem_cmt_t_swigregister
citem_cmt_t_swigregister(citem_cmt_t)

class citem_locator_t(object):
    """
    Proxy of C++ citem_locator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.citem_locator_t_ea_get, _idaapi.citem_locator_t_ea_set)
    op = _swig_property(_idaapi.citem_locator_t_op_get, _idaapi.citem_locator_t_op_set)
    def __init__(self, *args):
        """
        __init__(self) -> citem_locator_t
        __init__(self, _ea, _op) -> citem_locator_t
        __init__(self, i) -> citem_locator_t
        """
        this = _idaapi.new_citem_locator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.citem_locator_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.citem_locator_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_citem_locator_t
    __del__ = lambda self : None;
citem_locator_t_swigregister = _idaapi.citem_locator_t_swigregister
citem_locator_t_swigregister(citem_locator_t)

class citem_t(object):
    """
    Proxy of C++ citem_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.citem_t_ea_get, _idaapi.citem_t_ea_set)
    op = _swig_property(_idaapi.citem_t_op_get, _idaapi.citem_t_op_set)
    label_num = _swig_property(_idaapi.citem_t_label_num_get, _idaapi.citem_t_label_num_set)
    index = _swig_property(_idaapi.citem_t_index_get, _idaapi.citem_t_index_set)
    def __init__(self, *args):
        """
        __init__(self) -> citem_t
        __init__(self, o) -> citem_t
        """
        this = _idaapi.new_citem_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.citem_t_swap(self, *args)

    def is_expr(self, *args):
        """
        is_expr(self) -> bool
        """
        return _idaapi.citem_t_is_expr(self, *args)

    def contains_label(self, *args):
        """
        contains_label(self) -> bool
        """
        return _idaapi.citem_t_contains_label(self, *args)

    def find_parent_of(self, *args):
        """
        find_parent_of(self, sitem) -> citem_t
        find_parent_of(self, item) -> citem_t
        """
        return _idaapi.citem_t_find_parent_of(self, *args)

    def print1(self, *args):
        """
        print1(self, func) -> size_t
        """
        return _idaapi.citem_t_print1(self, *args)

    cinsn = _swig_property(_idaapi.citem_t_cinsn_get)
    cexpr = _swig_property(_idaapi.citem_t_cexpr_get)
    __swig_destroy__ = _idaapi.delete_citem_t
    __del__ = lambda self : None;
citem_t_swigregister = _idaapi.citem_t_swigregister
citem_t_swigregister(citem_t)

class cexpr_t(citem_t):
    """
    Proxy of C++ cexpr_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = _swig_property(_idaapi.cexpr_t_type_get, _idaapi.cexpr_t_type_set)
    exflags = _swig_property(_idaapi.cexpr_t_exflags_get, _idaapi.cexpr_t_exflags_set)
    def cpadone(self, *args):
        """
        cpadone(self) -> bool
        """
        return _idaapi.cexpr_t_cpadone(self, *args)

    def is_odd_lvalue(self, *args):
        """
        is_odd_lvalue(self) -> bool
        """
        return _idaapi.cexpr_t_is_odd_lvalue(self, *args)

    def is_fpop(self, *args):
        """
        is_fpop(self) -> bool
        """
        return _idaapi.cexpr_t_is_fpop(self, *args)

    def is_cstr(self, *args):
        """
        is_cstr(self) -> bool
        """
        return _idaapi.cexpr_t_is_cstr(self, *args)

    def set_cpadone(self, *args):
        """
        set_cpadone(self)
        """
        return _idaapi.cexpr_t_set_cpadone(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cexpr_t
        __init__(self, cop, _x) -> cexpr_t
        __init__(self, cop, _x, _y) -> cexpr_t
        __init__(self, cop, _x, _y, _z) -> cexpr_t
        __init__(self, r) -> cexpr_t
        """
        this = _idaapi.new_cexpr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.cexpr_t_swap(self, *args)

    def assign(self, *args):
        """
        assign(self, r) -> cexpr_t
        """
        return _idaapi.cexpr_t_assign(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cexpr_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cexpr_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cexpr_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cexpr_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cexpr_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cexpr_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cexpr_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_cexpr_t
    __del__ = lambda self : None;
    def replace_by(self, *args):
        """
        replace_by(self, r)
        """
        return _idaapi.cexpr_t_replace_by(self, *args)

    def cleanup(self, *args):
        """
        cleanup(self)
        """
        return _idaapi.cexpr_t_cleanup(self, *args)

    def put_number(self, *args):
        """
        put_number(self, func, value, nbytes, sign=no_sign)
        """
        return _idaapi.cexpr_t_put_number(self, *args)

    def print1(self, *args):
        """
        print1(self, func) -> size_t
        """
        return _idaapi.cexpr_t_print1(self, *args)

    def calc_type(self, *args):
        """
        calc_type(self, recursive)
        """
        return _idaapi.cexpr_t_calc_type(self, *args)

    def equal_effect(self, *args):
        """
        equal_effect(self, r) -> bool
        """
        return _idaapi.cexpr_t_equal_effect(self, *args)

    def is_child_of(self, *args):
        """
        is_child_of(self, parent) -> bool
        """
        return _idaapi.cexpr_t_is_child_of(self, *args)

    def contains_operator(self, *args):
        """
        contains_operator(self, needed_op) -> bool
        """
        return _idaapi.cexpr_t_contains_operator(self, *args)

    def contains_comma(self, *args):
        """
        contains_comma(self) -> bool
        """
        return _idaapi.cexpr_t_contains_comma(self, *args)

    def contains_insn(self, *args):
        """
        contains_insn(self) -> bool
        """
        return _idaapi.cexpr_t_contains_insn(self, *args)

    def contains_insn_or_label(self, *args):
        """
        contains_insn_or_label(self) -> bool
        """
        return _idaapi.cexpr_t_contains_insn_or_label(self, *args)

    def contains_comma_or_insn_or_label(self, *args):
        """
        contains_comma_or_insn_or_label(self) -> bool
        """
        return _idaapi.cexpr_t_contains_comma_or_insn_or_label(self, *args)

    def is_nice_expr(self, *args):
        """
        is_nice_expr(self) -> bool
        """
        return _idaapi.cexpr_t_is_nice_expr(self, *args)

    def is_nice_cond(self, *args):
        """
        is_nice_cond(self) -> bool
        """
        return _idaapi.cexpr_t_is_nice_cond(self, *args)

    def is_call_object_of(self, *args):
        """
        is_call_object_of(self, parent) -> bool
        """
        return _idaapi.cexpr_t_is_call_object_of(self, *args)

    def is_call_arg_of(self, *args):
        """
        is_call_arg_of(self, parent) -> bool
        """
        return _idaapi.cexpr_t_is_call_arg_of(self, *args)

    def get_type_sign(self, *args):
        """
        get_type_sign(self) -> type_sign_t
        """
        return _idaapi.cexpr_t_get_type_sign(self, *args)

    def get_high_nbit_bound(self, *args):
        """
        get_high_nbit_bound(self, pbits, psign, p_maybe_negative=None) -> int
        """
        return _idaapi.cexpr_t_get_high_nbit_bound(self, *args)

    def get_low_nbit_bound(self, *args):
        """
        get_low_nbit_bound(self, psign, p_maybe_negative=None) -> int
        """
        return _idaapi.cexpr_t_get_low_nbit_bound(self, *args)

    def requires_lvalue(self, *args):
        """
        requires_lvalue(self, child) -> bool
        """
        return _idaapi.cexpr_t_requires_lvalue(self, *args)

    def has_side_effects(self, *args):
        """
        has_side_effects(self) -> bool
        """
        return _idaapi.cexpr_t_has_side_effects(self, *args)

    def numval(self, *args):
        """
        numval(self) -> uint64
        """
        return _idaapi.cexpr_t_numval(self, *args)

    def is_const_value(self, *args):
        """
        is_const_value(self, _v) -> bool
        """
        return _idaapi.cexpr_t_is_const_value(self, *args)

    def is_negative_const(self, *args):
        """
        is_negative_const(self) -> bool
        """
        return _idaapi.cexpr_t_is_negative_const(self, *args)

    def is_non_zero_const(self, *args):
        """
        is_non_zero_const(self) -> bool
        """
        return _idaapi.cexpr_t_is_non_zero_const(self, *args)

    def is_zero_const(self, *args):
        """
        is_zero_const(self) -> bool
        """
        return _idaapi.cexpr_t_is_zero_const(self, *args)

    def get_const_value(self, *args):
        """
        get_const_value(self, np) -> bool
        """
        return _idaapi.cexpr_t_get_const_value(self, *args)

    def maybe_ptr(self, *args):
        """
        maybe_ptr(self) -> bool
        """
        return _idaapi.cexpr_t_maybe_ptr(self, *args)

    def get_ptr_or_array(self, *args):
        """
        get_ptr_or_array(self) -> cexpr_t
        """
        return _idaapi.cexpr_t_get_ptr_or_array(self, *args)

    def find_op(self, *args):
        """
        find_op(self, _op) -> cexpr_t
        find_op(self, _op) -> cexpr_t
        """
        return _idaapi.cexpr_t_find_op(self, *args)

    def find_num_op(self, *args):
        """
        find_num_op(self) -> cexpr_t
        find_num_op(self) -> cexpr_t
        """
        return _idaapi.cexpr_t_find_num_op(self, *args)

    def theother(self, *args):
        """
        theother(self, what) -> cexpr_t
        theother(self, what) -> cexpr_t
        """
        return _idaapi.cexpr_t_theother(self, *args)

    def get_1num_op(self, *args):
        """
        get_1num_op(self, o1, o2) -> bool
        """
        return _idaapi.cexpr_t_get_1num_op(self, *args)

    n = _swig_property(_idaapi.cexpr_t_n_get)
    fpc = _swig_property(_idaapi.cexpr_t_fpc_get)
    v = _swig_property(_idaapi.cexpr_t_v_get)
    obj_ea = _swig_property(_idaapi.cexpr_t_obj_ea_get)
    refwidth = _swig_property(_idaapi.cexpr_t_refwidth_get)
    x = _swig_property(_idaapi.cexpr_t_x_get)
    y = _swig_property(_idaapi.cexpr_t_y_get)
    a = _swig_property(_idaapi.cexpr_t_a_get)
    m = _swig_property(_idaapi.cexpr_t_m_get)
    z = _swig_property(_idaapi.cexpr_t_z_get)
    ptrsize = _swig_property(_idaapi.cexpr_t_ptrsize_get)
    insn = _swig_property(_idaapi.cexpr_t_insn_get)
    helper = _swig_property(_idaapi.cexpr_t_helper_get)
    string = _swig_property(_idaapi.cexpr_t_string_get)
cexpr_t_swigregister = _idaapi.cexpr_t_swigregister
cexpr_t_swigregister(cexpr_t)
EXFL_CPADONE = _idaapi.EXFL_CPADONE
EXFL_LVALUE = _idaapi.EXFL_LVALUE
EXFL_FPOP = _idaapi.EXFL_FPOP
EXFL_ALONE = _idaapi.EXFL_ALONE
EXFL_CSTR = _idaapi.EXFL_CSTR
EXFL_ALL = _idaapi.EXFL_ALL

class ceinsn_t(object):
    """
    Proxy of C++ ceinsn_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    expr = _swig_property(_idaapi.ceinsn_t_expr_get, _idaapi.ceinsn_t_expr_set)
    def __init__(self, *args):
        """
        __init__(self) -> ceinsn_t
        """
        this = _idaapi.new_ceinsn_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ceinsn_t
    __del__ = lambda self : None;
ceinsn_t_swigregister = _idaapi.ceinsn_t_swigregister
ceinsn_t_swigregister(ceinsn_t)

CALC_CURLY_BRACES = _idaapi.CALC_CURLY_BRACES
NO_CURLY_BRACES = _idaapi.NO_CURLY_BRACES
USE_CURLY_BRACES = _idaapi.USE_CURLY_BRACES
class cif_t(ceinsn_t):
    """
    Proxy of C++ cif_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ithen = _swig_property(_idaapi.cif_t_ithen_get, _idaapi.cif_t_ithen_set)
    ielse = _swig_property(_idaapi.cif_t_ielse_get, _idaapi.cif_t_ielse_set)
    def __init__(self, *args):
        """
        __init__(self) -> cif_t
        __init__(self, r) -> cif_t
        """
        this = _idaapi.new_cif_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args):
        """
        assign(self, r) -> cif_t
        """
        return _idaapi.cif_t_assign(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cif_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cif_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cif_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cif_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cif_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cif_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cif_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_cif_t
    __del__ = lambda self : None;
    def cleanup(self, *args):
        """
        cleanup(self)
        """
        return _idaapi.cif_t_cleanup(self, *args)

cif_t_swigregister = _idaapi.cif_t_swigregister
cif_t_swigregister(cif_t)

class cloop_t(ceinsn_t):
    """
    Proxy of C++ cloop_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    body = _swig_property(_idaapi.cloop_t_body_get, _idaapi.cloop_t_body_set)
    def __init__(self, *args):
        """
        __init__(self) -> cloop_t
        __init__(self, b) -> cloop_t
        __init__(self, r) -> cloop_t
        """
        this = _idaapi.new_cloop_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args):
        """
        assign(self, r) -> cloop_t
        """
        return _idaapi.cloop_t_assign(self, *args)

    __swig_destroy__ = _idaapi.delete_cloop_t
    __del__ = lambda self : None;
    def cleanup(self, *args):
        """
        cleanup(self)
        """
        return _idaapi.cloop_t_cleanup(self, *args)

cloop_t_swigregister = _idaapi.cloop_t_swigregister
cloop_t_swigregister(cloop_t)

class cfor_t(cloop_t):
    """
    Proxy of C++ cfor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = _swig_property(_idaapi.cfor_t_init_get, _idaapi.cfor_t_init_set)
    step = _swig_property(_idaapi.cfor_t_step_get, _idaapi.cfor_t_step_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cfor_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cfor_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cfor_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cfor_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cfor_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cfor_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cfor_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cfor_t
        """
        this = _idaapi.new_cfor_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cfor_t
    __del__ = lambda self : None;
cfor_t_swigregister = _idaapi.cfor_t_swigregister
cfor_t_swigregister(cfor_t)

class cwhile_t(cloop_t):
    """
    Proxy of C++ cwhile_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cwhile_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cwhile_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cwhile_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cwhile_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cwhile_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cwhile_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cwhile_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cwhile_t
        """
        this = _idaapi.new_cwhile_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cwhile_t
    __del__ = lambda self : None;
cwhile_t_swigregister = _idaapi.cwhile_t_swigregister
cwhile_t_swigregister(cwhile_t)

class cdo_t(cloop_t):
    """
    Proxy of C++ cdo_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cdo_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cdo_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cdo_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cdo_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cdo_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cdo_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cdo_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cdo_t
        """
        this = _idaapi.new_cdo_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cdo_t
    __del__ = lambda self : None;
cdo_t_swigregister = _idaapi.cdo_t_swigregister
cdo_t_swigregister(cdo_t)

class creturn_t(ceinsn_t):
    """
    Proxy of C++ creturn_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.creturn_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.creturn_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.creturn_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.creturn_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.creturn_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.creturn_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.creturn_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> creturn_t
        """
        this = _idaapi.new_creturn_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_creturn_t
    __del__ = lambda self : None;
creturn_t_swigregister = _idaapi.creturn_t_swigregister
creturn_t_swigregister(creturn_t)

class cgoto_t(object):
    """
    Proxy of C++ cgoto_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    label_num = _swig_property(_idaapi.cgoto_t_label_num_get, _idaapi.cgoto_t_label_num_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cgoto_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cgoto_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cgoto_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cgoto_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cgoto_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cgoto_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cgoto_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cgoto_t
        """
        this = _idaapi.new_cgoto_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cgoto_t
    __del__ = lambda self : None;
cgoto_t_swigregister = _idaapi.cgoto_t_swigregister
cgoto_t_swigregister(cgoto_t)

class casm_t(uvalvec_t):
    """
    Proxy of C++ casm_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, ea) -> casm_t
        __init__(self, r) -> casm_t
        """
        this = _idaapi.new_casm_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.casm_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.casm_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.casm_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.casm_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.casm_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.casm_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.casm_t_compare(self, *args)

    def one_insn(self, *args):
        """
        one_insn(self) -> bool
        """
        return _idaapi.casm_t_one_insn(self, *args)

    __swig_destroy__ = _idaapi.delete_casm_t
    __del__ = lambda self : None;
casm_t_swigregister = _idaapi.casm_t_swigregister
casm_t_swigregister(casm_t)

class cinsn_t(citem_t):
    """
    Proxy of C++ cinsn_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> cinsn_t
        __init__(self, r) -> cinsn_t
        """
        this = _idaapi.new_cinsn_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.cinsn_t_swap(self, *args)

    def assign(self, *args):
        """
        assign(self, r) -> cinsn_t
        """
        return _idaapi.cinsn_t_assign(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cinsn_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cinsn_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cinsn_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cinsn_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cinsn_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cinsn_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cinsn_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_cinsn_t
    __del__ = lambda self : None;
    def replace_by(self, *args):
        """
        replace_by(self, r)
        """
        return _idaapi.cinsn_t_replace_by(self, *args)

    def cleanup(self, *args):
        """
        cleanup(self)
        """
        return _idaapi.cinsn_t_cleanup(self, *args)

    def zero(self, *args):
        """
        zero(self)
        """
        return _idaapi.cinsn_t_zero(self, *args)

    def new_insn(self, *args):
        """
        new_insn(self, insn_ea) -> cinsn_t
        """
        return _idaapi.cinsn_t_new_insn(self, *args)

    def create_if(self, *args):
        """
        create_if(self, cnd) -> cif_t
        """
        return _idaapi.cinsn_t_create_if(self, *args)

    def _print(self, *args):
        """
        _print(self, indent, vp, use_curly=CALC_CURLY_BRACES)
        """
        return _idaapi.cinsn_t__print(self, *args)

    def print1(self, *args):
        """
        print1(self, func) -> size_t
        """
        return _idaapi.cinsn_t_print1(self, *args)

    def is_ordinary_flow(self, *args):
        """
        is_ordinary_flow(self) -> bool
        """
        return _idaapi.cinsn_t_is_ordinary_flow(self, *args)

    def contains_insn(self, *args):
        """
        contains_insn(self, type) -> bool
        """
        return _idaapi.cinsn_t_contains_insn(self, *args)

    def collect_free_breaks(self, *args):
        """
        collect_free_breaks(self, breaks) -> bool
        """
        return _idaapi.cinsn_t_collect_free_breaks(self, *args)

    def collect_free_continues(self, *args):
        """
        collect_free_continues(self, continues) -> bool
        """
        return _idaapi.cinsn_t_collect_free_continues(self, *args)

    def contains_free_break(self, *args):
        """
        contains_free_break(self) -> bool
        """
        return _idaapi.cinsn_t_contains_free_break(self, *args)

    def contains_free_continue(self, *args):
        """
        contains_free_continue(self) -> bool
        """
        return _idaapi.cinsn_t_contains_free_continue(self, *args)

    cblock = _swig_property(_idaapi.cinsn_t_cblock_get)
    cexpr = _swig_property(_idaapi.cinsn_t_cexpr_get)
    cif = _swig_property(_idaapi.cinsn_t_cif_get)
    cfor = _swig_property(_idaapi.cinsn_t_cfor_get)
    cwhile = _swig_property(_idaapi.cinsn_t_cwhile_get)
    cdo = _swig_property(_idaapi.cinsn_t_cdo_get)
    cswitch = _swig_property(_idaapi.cinsn_t_cswitch_get)
    creturn = _swig_property(_idaapi.cinsn_t_creturn_get)
    cgoto = _swig_property(_idaapi.cinsn_t_cgoto_get)
    casm = _swig_property(_idaapi.cinsn_t_casm_get)
cinsn_t_swigregister = _idaapi.cinsn_t_swigregister
cinsn_t_swigregister(cinsn_t)

class cblock_t(qlist_cinsn_t):
    """
    Proxy of C++ cblock_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cblock_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cblock_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cblock_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cblock_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cblock_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cblock_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cblock_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cblock_t
        """
        this = _idaapi.new_cblock_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cblock_t
    __del__ = lambda self : None;
cblock_t_swigregister = _idaapi.cblock_t_swigregister
cblock_t_swigregister(cblock_t)

class carg_t(cexpr_t):
    """
    Proxy of C++ carg_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    is_vararg = _swig_property(_idaapi.carg_t_is_vararg_get, _idaapi.carg_t_is_vararg_set)
    formal_type = _swig_property(_idaapi.carg_t_formal_type_get, _idaapi.carg_t_formal_type_set)
    def consume_cexpr(self, *args):
        """
        consume_cexpr(self, e)
        """
        return _idaapi.carg_t_consume_cexpr(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> carg_t
        """
        this = _idaapi.new_carg_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.carg_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.carg_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.carg_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.carg_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.carg_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.carg_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.carg_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_carg_t
    __del__ = lambda self : None;
carg_t_swigregister = _idaapi.carg_t_swigregister
carg_t_swigregister(carg_t)

class carglist_t(qvector_carg_t):
    """
    Proxy of C++ carglist_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    functype = _swig_property(_idaapi.carglist_t_functype_get, _idaapi.carglist_t_functype_set)
    def __init__(self, *args):
        """
        __init__(self) -> carglist_t
        __init__(self, ftype) -> carglist_t
        """
        this = _idaapi.new_carglist_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.carglist_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.carglist_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.carglist_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.carglist_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.carglist_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.carglist_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.carglist_t_compare(self, *args)

    __swig_destroy__ = _idaapi.delete_carglist_t
    __del__ = lambda self : None;
carglist_t_swigregister = _idaapi.carglist_t_swigregister
carglist_t_swigregister(carglist_t)

class ccase_t(cinsn_t):
    """
    Proxy of C++ ccase_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    values = _swig_property(_idaapi.ccase_t_values_get, _idaapi.ccase_t_values_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.ccase_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.ccase_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.ccase_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.ccase_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.ccase_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.ccase_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.ccase_t_compare(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.ccase_t_size(self, *args)

    def value(self, *args):
        """
        value(self, i) -> uint64 const &
        """
        return _idaapi.ccase_t_value(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> ccase_t
        """
        this = _idaapi.new_ccase_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ccase_t
    __del__ = lambda self : None;
ccase_t_swigregister = _idaapi.ccase_t_swigregister
ccase_t_swigregister(ccase_t)

class ccases_t(qvector_ccase_t):
    """
    Proxy of C++ ccases_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.ccases_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.ccases_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.ccases_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.ccases_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.ccases_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.ccases_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.ccases_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> ccases_t
        """
        this = _idaapi.new_ccases_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ccases_t
    __del__ = lambda self : None;
ccases_t_swigregister = _idaapi.ccases_t_swigregister
ccases_t_swigregister(ccases_t)

class cswitch_t(ceinsn_t):
    """
    Proxy of C++ cswitch_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mvnf = _swig_property(_idaapi.cswitch_t_mvnf_get, _idaapi.cswitch_t_mvnf_set)
    cases = _swig_property(_idaapi.cswitch_t_cases_get, _idaapi.cswitch_t_cases_set)
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.cswitch_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.cswitch_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.cswitch_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.cswitch_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.cswitch_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.cswitch_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.cswitch_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> cswitch_t
        """
        this = _idaapi.new_cswitch_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_cswitch_t
    __del__ = lambda self : None;
cswitch_t_swigregister = _idaapi.cswitch_t_swigregister
cswitch_t_swigregister(cswitch_t)

class ctree_anchor_t(object):
    """
    Proxy of C++ ctree_anchor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    value = _swig_property(_idaapi.ctree_anchor_t_value_get, _idaapi.ctree_anchor_t_value_set)
    def __init__(self, *args):
        """
        __init__(self) -> ctree_anchor_t
        """
        this = _idaapi.new_ctree_anchor_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_index(self, *args):
        """
        get_index(self) -> int
        """
        return _idaapi.ctree_anchor_t_get_index(self, *args)

    def get_itp(self, *args):
        """
        get_itp(self) -> item_preciser_t
        """
        return _idaapi.ctree_anchor_t_get_itp(self, *args)

    def is_valid_anchor(self, *args):
        """
        is_valid_anchor(self) -> bool
        """
        return _idaapi.ctree_anchor_t_is_valid_anchor(self, *args)

    def is_citem_anchor(self, *args):
        """
        is_citem_anchor(self) -> bool
        """
        return _idaapi.ctree_anchor_t_is_citem_anchor(self, *args)

    def is_lvar_anchor(self, *args):
        """
        is_lvar_anchor(self) -> bool
        """
        return _idaapi.ctree_anchor_t_is_lvar_anchor(self, *args)

    def is_itp_anchor(self, *args):
        """
        is_itp_anchor(self) -> bool
        """
        return _idaapi.ctree_anchor_t_is_itp_anchor(self, *args)

    def is_blkcmt_anchor(self, *args):
        """
        is_blkcmt_anchor(self) -> bool
        """
        return _idaapi.ctree_anchor_t_is_blkcmt_anchor(self, *args)

    __swig_destroy__ = _idaapi.delete_ctree_anchor_t
    __del__ = lambda self : None;
ctree_anchor_t_swigregister = _idaapi.ctree_anchor_t_swigregister
ctree_anchor_t_swigregister(ctree_anchor_t)
ANCHOR_INDEX = _idaapi.ANCHOR_INDEX
ANCHOR_MASK = _idaapi.ANCHOR_MASK
ANCHOR_CITEM = _idaapi.ANCHOR_CITEM
ANCHOR_LVAR = _idaapi.ANCHOR_LVAR
ANCHOR_ITP = _idaapi.ANCHOR_ITP
ANCHOR_BLKCMT = _idaapi.ANCHOR_BLKCMT

VDI_NONE = _idaapi.VDI_NONE
VDI_EXPR = _idaapi.VDI_EXPR
VDI_LVAR = _idaapi.VDI_LVAR
VDI_FUNC = _idaapi.VDI_FUNC
VDI_TAIL = _idaapi.VDI_TAIL
class ctree_item_t(object):
    """
    Proxy of C++ ctree_item_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    citype = _swig_property(_idaapi.ctree_item_t_citype_get, _idaapi.ctree_item_t_citype_set)
    def get_memptr(self, *args):
        """
        get_memptr(self, p_sptr=None) -> member_t
        """
        return _idaapi.ctree_item_t_get_memptr(self, *args)

    def get_lvar(self, *args):
        """
        get_lvar(self) -> lvar_t
        """
        return _idaapi.ctree_item_t_get_lvar(self, *args)

    def get_ea(self, *args):
        """
        get_ea(self) -> ea_t
        """
        return _idaapi.ctree_item_t_get_ea(self, *args)

    def get_label_num(self, *args):
        """
        get_label_num(self, gln_flags) -> int
        """
        return _idaapi.ctree_item_t_get_label_num(self, *args)

    def is_citem(self, *args):
        """
        is_citem(self) -> bool
        """
        return _idaapi.ctree_item_t_is_citem(self, *args)

    it = _swig_property(_idaapi.ctree_item_t_it_get)
    e = _swig_property(_idaapi.ctree_item_t_e_get)
    i = _swig_property(_idaapi.ctree_item_t_i_get)
    l = _swig_property(_idaapi.ctree_item_t_l_get)
    f = _swig_property(_idaapi.ctree_item_t_f_get)
    loc = _swig_property(_idaapi.ctree_item_t_loc_get)
    def __init__(self, *args):
        """
        __init__(self) -> ctree_item_t
        """
        this = _idaapi.new_ctree_item_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ctree_item_t
    __del__ = lambda self : None;
ctree_item_t_swigregister = _idaapi.ctree_item_t_swigregister
ctree_item_t_swigregister(ctree_item_t)
GLN_CURRENT = _idaapi.GLN_CURRENT
GLN_GOTO_TARGET = _idaapi.GLN_GOTO_TARGET
GLN_ALL = _idaapi.GLN_ALL

FORBID_UNUSED_LABELS = _idaapi.FORBID_UNUSED_LABELS
ALLOW_UNUSED_LABELS = _idaapi.ALLOW_UNUSED_LABELS

def lnot(*args):
  """
  lnot(e) -> cexpr_t
  """
  return _idaapi.lnot(*args)

def new_block(*args):
  """
  new_block() -> cinsn_t
  """
  return _idaapi.new_block(*args)

def vcreate_helper(*args):
  """
  vcreate_helper(standalone, type, format, va) -> cexpr_t
  """
  return _idaapi.vcreate_helper(*args)

def create_helper(*args):
  """
  create_helper(standalone, type, format) -> cexpr_t
  """
  return _idaapi.create_helper(*args)

def vcall_helper(*args):
  """
  vcall_helper(rettype, args, format, va) -> cexpr_t
  """
  return _idaapi.vcall_helper(*args)

def call_helper(*args):
  """
  call_helper(rettype, args, format) -> cexpr_t
  """
  return _idaapi.call_helper(*args)

def make_num(*args):
  """
  make_num(n, func=None, ea=BADADDR, opnum=0, sign=no_sign, size=0) -> cexpr_t
  """
  return _idaapi.make_num(*args)

def make_ref(*args):
  """
  make_ref(e) -> cexpr_t
  """
  return _idaapi.make_ref(*args)

def dereference(*args):
  """
  dereference(e, ptrsize, is_float=False) -> cexpr_t
  """
  return _idaapi.dereference(*args)

def save_user_labels(*args):
  """
  save_user_labels(func_ea, user_labels)
  """
  return _idaapi.save_user_labels(*args)

def save_user_cmts(*args):
  """
  save_user_cmts(func_ea, user_cmts)
  """
  return _idaapi.save_user_cmts(*args)

def save_user_numforms(*args):
  """
  save_user_numforms(func_ea, numforms)
  """
  return _idaapi.save_user_numforms(*args)

def save_user_iflags(*args):
  """
  save_user_iflags(func_ea, iflags)
  """
  return _idaapi.save_user_iflags(*args)

def save_user_unions(*args):
  """
  save_user_unions(func_ea, unions)
  """
  return _idaapi.save_user_unions(*args)

def restore_user_labels(*args):
  """
  restore_user_labels(func_ea) -> user_labels_t
  """
  return _idaapi.restore_user_labels(*args)

def restore_user_cmts(*args):
  """
  restore_user_cmts(func_ea) -> user_cmts_t
  """
  return _idaapi.restore_user_cmts(*args)

def restore_user_numforms(*args):
  """
  restore_user_numforms(func_ea) -> user_numforms_t
  """
  return _idaapi.restore_user_numforms(*args)

def restore_user_iflags(*args):
  """
  restore_user_iflags(func_ea) -> user_iflags_t
  """
  return _idaapi.restore_user_iflags(*args)

def restore_user_unions(*args):
  """
  restore_user_unions(func_ea) -> user_unions_t
  """
  return _idaapi.restore_user_unions(*args)
class cfunc_t(object):
    """
    Proxy of C++ cfunc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    entry_ea = _swig_property(_idaapi.cfunc_t_entry_ea_get, _idaapi.cfunc_t_entry_ea_set)
    mba = _swig_property(_idaapi.cfunc_t_mba_get, _idaapi.cfunc_t_mba_set)
    body = _swig_property(_idaapi.cfunc_t_body_get, _idaapi.cfunc_t_body_set)
    argidx = _swig_property(_idaapi.cfunc_t_argidx_get)
    maturity = _swig_property(_idaapi.cfunc_t_maturity_get, _idaapi.cfunc_t_maturity_set)
    user_labels = _swig_property(_idaapi.cfunc_t_user_labels_get, _idaapi.cfunc_t_user_labels_set)
    user_cmts = _swig_property(_idaapi.cfunc_t_user_cmts_get, _idaapi.cfunc_t_user_cmts_set)
    numforms = _swig_property(_idaapi.cfunc_t_numforms_get, _idaapi.cfunc_t_numforms_set)
    user_iflags = _swig_property(_idaapi.cfunc_t_user_iflags_get, _idaapi.cfunc_t_user_iflags_set)
    user_unions = _swig_property(_idaapi.cfunc_t_user_unions_get, _idaapi.cfunc_t_user_unions_set)
    refcnt = _swig_property(_idaapi.cfunc_t_refcnt_get, _idaapi.cfunc_t_refcnt_set)
    statebits = _swig_property(_idaapi.cfunc_t_statebits_get, _idaapi.cfunc_t_statebits_set)
    hdrlines = _swig_property(_idaapi.cfunc_t_hdrlines_get, _idaapi.cfunc_t_hdrlines_set)
    treeitems = _swig_property(_idaapi.cfunc_t_treeitems_get, _idaapi.cfunc_t_treeitems_set)
    __swig_destroy__ = _idaapi.delete_cfunc_t
    __del__ = lambda self : None;
    def release(self, *args):
        """
        release(self)
        """
        return _idaapi.cfunc_t_release(self, *args)

    def build_c_tree(self, *args):
        """
        build_c_tree(self)
        """
        return _idaapi.cfunc_t_build_c_tree(self, *args)

    def verify(self, *args):
        """
        verify(self, aul, even_without_debugger)
        """
        return _idaapi.cfunc_t_verify(self, *args)

    def print_dcl(self, *args):
        """
        print_dcl(self, buf, bufsize) -> size_t
        """
        return _idaapi.cfunc_t_print_dcl(self, *args)

    def print_dcl2(self, *args):
        """
        print_dcl2(self) -> size_t
        """
        return _idaapi.cfunc_t_print_dcl2(self, *args)

    def print_func(self, *args):
        """
        print_func(self, vp)
        """
        return _idaapi.cfunc_t_print_func(self, *args)

    def get_func_type(self, *args):
        """
        get_func_type(self, type) -> bool
        """
        return _idaapi.cfunc_t_get_func_type(self, *args)

    def get_lvars(self, *args):
        """
        get_lvars(self) -> lvars_t
        """
        return _idaapi.cfunc_t_get_lvars(self, *args)

    def find_label(self, *args):
        """
        find_label(self, label) -> citem_t
        """
        return _idaapi.cfunc_t_find_label(self, *args)

    def remove_unused_labels(self, *args):
        """
        remove_unused_labels(self)
        """
        return _idaapi.cfunc_t_remove_unused_labels(self, *args)

    def get_user_cmt(self, *args):
        """
        get_user_cmt(self, loc, rt) -> char const *
        """
        return _idaapi.cfunc_t_get_user_cmt(self, *args)

    def set_user_cmt(self, *args):
        """
        set_user_cmt(self, loc, cmt)
        """
        return _idaapi.cfunc_t_set_user_cmt(self, *args)

    def get_user_iflags(self, *args):
        """
        get_user_iflags(self, loc) -> int32
        """
        return _idaapi.cfunc_t_get_user_iflags(self, *args)

    def set_user_iflags(self, *args):
        """
        set_user_iflags(self, loc, iflags)
        """
        return _idaapi.cfunc_t_set_user_iflags(self, *args)

    def has_orphan_cmts(self, *args):
        """
        has_orphan_cmts(self) -> bool
        """
        return _idaapi.cfunc_t_has_orphan_cmts(self, *args)

    def del_orphan_cmts(self, *args):
        """
        del_orphan_cmts(self) -> int
        """
        return _idaapi.cfunc_t_del_orphan_cmts(self, *args)

    def get_user_union_selection(self, *args):
        """
        get_user_union_selection(self, ea, path) -> bool
        """
        return _idaapi.cfunc_t_get_user_union_selection(self, *args)

    def set_user_union_selection(self, *args):
        """
        set_user_union_selection(self, ea, path)
        """
        return _idaapi.cfunc_t_set_user_union_selection(self, *args)

    def save_user_labels(self, *args):
        """
        save_user_labels(self)
        """
        return _idaapi.cfunc_t_save_user_labels(self, *args)

    def save_user_cmts(self, *args):
        """
        save_user_cmts(self)
        """
        return _idaapi.cfunc_t_save_user_cmts(self, *args)

    def save_user_numforms(self, *args):
        """
        save_user_numforms(self)
        """
        return _idaapi.cfunc_t_save_user_numforms(self, *args)

    def save_user_iflags(self, *args):
        """
        save_user_iflags(self)
        """
        return _idaapi.cfunc_t_save_user_iflags(self, *args)

    def save_user_unions(self, *args):
        """
        save_user_unions(self)
        """
        return _idaapi.cfunc_t_save_user_unions(self, *args)

    def get_line_item(self, *args):
        """
        get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
        """
        return _idaapi.cfunc_t_get_line_item(self, *args)

    def get_warnings(self, *args):
        """
        get_warnings(self) -> hexwarns_t
        """
        return _idaapi.cfunc_t_get_warnings(self, *args)

    def get_eamap(self, *args):
        """
        get_eamap(self) -> eamap_t
        """
        return _idaapi.cfunc_t_get_eamap(self, *args)

    def get_boundaries(self, *args):
        """
        get_boundaries(self) -> boundaries_t
        """
        return _idaapi.cfunc_t_get_boundaries(self, *args)

    def get_pseudocode(self, *args):
        """
        get_pseudocode(self) -> strvec_t
        """
        return _idaapi.cfunc_t_get_pseudocode(self, *args)

    def gather_derefs(self, *args):
        """
        gather_derefs(self, ci, udm=None) -> bool
        """
        return _idaapi.cfunc_t_gather_derefs(self, *args)

    def __str__(self, *args):
        """
        __str__(self) -> qstring
        """
        return _idaapi.cfunc_t___str__(self, *args)

cfunc_t_swigregister = _idaapi.cfunc_t_swigregister
cfunc_t_swigregister(cfunc_t)
CIT_COLLAPSED = _idaapi.CIT_COLLAPSED
CFS_BOUNDS = _idaapi.CFS_BOUNDS
CFS_TEXT = _idaapi.CFS_TEXT
CFS_LVARS_HIDDEN = _idaapi.CFS_LVARS_HIDDEN


def mark_cfunc_dirty(*args):
  """
  mark_cfunc_dirty(ea) -> bool
  """
  return _idaapi.mark_cfunc_dirty(*args)

def clear_cached_cfuncs(*args):
  """
  clear_cached_cfuncs()
  """
  return _idaapi.clear_cached_cfuncs(*args)

def has_cached_cfunc(*args):
  """
  has_cached_cfunc(ea) -> bool
  """
  return _idaapi.has_cached_cfunc(*args)

def get_ctype_name(*args):
  """
  get_ctype_name(op) -> char const *
  """
  return _idaapi.get_ctype_name(*args)

def create_field_name(*args):
  """
  create_field_name(type, offset=BADADDR) -> qstring
  """
  return _idaapi.create_field_name(*args)
hxe_flowchart = _idaapi.hxe_flowchart
hxe_prolog = _idaapi.hxe_prolog
hxe_preoptimized = _idaapi.hxe_preoptimized
hxe_locopt = _idaapi.hxe_locopt
hxe_prealloc = _idaapi.hxe_prealloc
hxe_glbopt = _idaapi.hxe_glbopt
hxe_structural = _idaapi.hxe_structural
hxe_maturity = _idaapi.hxe_maturity
hxe_interr = _idaapi.hxe_interr
hxe_combine = _idaapi.hxe_combine
hxe_print_func = _idaapi.hxe_print_func
hxe_func_printed = _idaapi.hxe_func_printed
hxe_resolve_stkaddrs = _idaapi.hxe_resolve_stkaddrs
hxe_open_pseudocode = _idaapi.hxe_open_pseudocode
hxe_switch_pseudocode = _idaapi.hxe_switch_pseudocode
hxe_refresh_pseudocode = _idaapi.hxe_refresh_pseudocode
hxe_close_pseudocode = _idaapi.hxe_close_pseudocode
hxe_keyboard = _idaapi.hxe_keyboard
hxe_right_click = _idaapi.hxe_right_click
hxe_double_click = _idaapi.hxe_double_click
hxe_curpos = _idaapi.hxe_curpos
hxe_create_hint = _idaapi.hxe_create_hint
hxe_text_ready = _idaapi.hxe_text_ready
hxe_populating_popup = _idaapi.hxe_populating_popup
USE_KEYBOARD = _idaapi.USE_KEYBOARD
USE_MOUSE = _idaapi.USE_MOUSE
class ctext_position_t(object):
    """
    Proxy of C++ ctext_position_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    lnnum = _swig_property(_idaapi.ctext_position_t_lnnum_get, _idaapi.ctext_position_t_lnnum_set)
    x = _swig_property(_idaapi.ctext_position_t_x_get, _idaapi.ctext_position_t_x_set)
    y = _swig_property(_idaapi.ctext_position_t_y_get, _idaapi.ctext_position_t_y_set)
    def in_ctree(self, *args):
        """
        in_ctree(self, hdrlines) -> bool
        """
        return _idaapi.ctext_position_t_in_ctree(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___gt__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___le__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, r) -> bool
        """
        return _idaapi.ctext_position_t___ge__(self, *args)

    def compare(self, *args):
        """
        compare(self, r) -> int
        """
        return _idaapi.ctext_position_t_compare(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> ctext_position_t
        """
        this = _idaapi.new_ctext_position_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ctext_position_t
    __del__ = lambda self : None;
ctext_position_t_swigregister = _idaapi.ctext_position_t_swigregister
ctext_position_t_swigregister(ctext_position_t)
HEXRAYS_API_MAGIC1 = cvar.HEXRAYS_API_MAGIC1
HEXRAYS_API_MAGIC2 = cvar.HEXRAYS_API_MAGIC2

def compare(*args):
  """
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    compare(a, b) -> int
    """
  return _idaapi.compare(*args)

class history_item_t(ctext_position_t):
    """
    Proxy of C++ history_item_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.history_item_t_ea_get, _idaapi.history_item_t_ea_set)
    def __init__(self, *args):
        """
        __init__(self) -> history_item_t
        """
        this = _idaapi.new_history_item_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_history_item_t
    __del__ = lambda self : None;
history_item_t_swigregister = _idaapi.history_item_t_swigregister
history_item_t_swigregister(history_item_t)

class vdui_t(object):
    """
    Proxy of C++ vdui_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    form = _swig_property(_idaapi.vdui_t_form_get, _idaapi.vdui_t_form_set)
    flags = _swig_property(_idaapi.vdui_t_flags_get, _idaapi.vdui_t_flags_set)
    def visible(self, *args):
        """
        visible(self) -> bool
        """
        return _idaapi.vdui_t_visible(self, *args)

    def valid(self, *args):
        """
        valid(self) -> bool
        """
        return _idaapi.vdui_t_valid(self, *args)

    def locked(self, *args):
        """
        locked(self) -> bool
        """
        return _idaapi.vdui_t_locked(self, *args)

    def set_visible(self, *args):
        """
        set_visible(self, v)
        """
        return _idaapi.vdui_t_set_visible(self, *args)

    def set_valid(self, *args):
        """
        set_valid(self, v)
        """
        return _idaapi.vdui_t_set_valid(self, *args)

    def set_locked(self, *args):
        """
        set_locked(self, v)
        """
        return _idaapi.vdui_t_set_locked(self, *args)

    view_idx = _swig_property(_idaapi.vdui_t_view_idx_get, _idaapi.vdui_t_view_idx_set)
    ct = _swig_property(_idaapi.vdui_t_ct_get, _idaapi.vdui_t_ct_set)
    cv = _swig_property(_idaapi.vdui_t_cv_get, _idaapi.vdui_t_cv_set)
    mba = _swig_property(_idaapi.vdui_t_mba_get, _idaapi.vdui_t_mba_set)
    cfunc = _swig_property(_idaapi.vdui_t_cfunc_get, _idaapi.vdui_t_cfunc_set)
    last_code = _swig_property(_idaapi.vdui_t_last_code_get, _idaapi.vdui_t_last_code_set)
    cpos = _swig_property(_idaapi.vdui_t_cpos_get, _idaapi.vdui_t_cpos_set)
    head = _swig_property(_idaapi.vdui_t_head_get, _idaapi.vdui_t_head_set)
    item = _swig_property(_idaapi.vdui_t_item_get, _idaapi.vdui_t_item_set)
    tail = _swig_property(_idaapi.vdui_t_tail_get, _idaapi.vdui_t_tail_set)
    def refresh_view(self, *args):
        """
        refresh_view(self, redo_mba)
        """
        return _idaapi.vdui_t_refresh_view(self, *args)

    def refresh_ctext(self, *args):
        """
        refresh_ctext(self, activate=True)
        """
        return _idaapi.vdui_t_refresh_ctext(self, *args)

    def switch_to(self, *args):
        """
        switch_to(self, f, activate)
        """
        return _idaapi.vdui_t_switch_to(self, *args)

    def in_ctree(self, *args):
        """
        in_ctree(self) -> bool
        """
        return _idaapi.vdui_t_in_ctree(self, *args)

    def get_number(self, *args):
        """
        get_number(self) -> cnumber_t
        """
        return _idaapi.vdui_t_get_number(self, *args)

    def get_current_label(self, *args):
        """
        get_current_label(self) -> int
        """
        return _idaapi.vdui_t_get_current_label(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.vdui_t_clear(self, *args)

    def refresh_cpos(self, *args):
        """
        refresh_cpos(self, idv) -> bool
        """
        return _idaapi.vdui_t_refresh_cpos(self, *args)

    def get_current_item(self, *args):
        """
        get_current_item(self, idv) -> bool
        """
        return _idaapi.vdui_t_get_current_item(self, *args)

    def ui_rename_lvar(self, *args):
        """
        ui_rename_lvar(self, v) -> bool
        """
        return _idaapi.vdui_t_ui_rename_lvar(self, *args)

    def rename_lvar(self, *args):
        """
        rename_lvar(self, v, name, is_user_name) -> bool
        """
        return _idaapi.vdui_t_rename_lvar(self, *args)

    def ui_set_lvar_type(self, *args):
        """
        ui_set_lvar_type(self, v) -> bool
        """
        return _idaapi.vdui_t_ui_set_lvar_type(self, *args)

    def set_lvar_type(self, *args):
        """
        set_lvar_type(self, v, type) -> bool
        """
        return _idaapi.vdui_t_set_lvar_type(self, *args)

    def ui_edit_lvar_cmt(self, *args):
        """
        ui_edit_lvar_cmt(self, v) -> bool
        """
        return _idaapi.vdui_t_ui_edit_lvar_cmt(self, *args)

    def set_lvar_cmt(self, *args):
        """
        set_lvar_cmt(self, v, cmt) -> bool
        """
        return _idaapi.vdui_t_set_lvar_cmt(self, *args)

    def ui_map_lvar(self, *args):
        """
        ui_map_lvar(self, v) -> bool
        """
        return _idaapi.vdui_t_ui_map_lvar(self, *args)

    def ui_unmap_lvar(self, *args):
        """
        ui_unmap_lvar(self, v) -> bool
        """
        return _idaapi.vdui_t_ui_unmap_lvar(self, *args)

    def map_lvar(self, *args):
        """
        map_lvar(self, frm, to) -> bool
        """
        return _idaapi.vdui_t_map_lvar(self, *args)

    def set_strmem_type(self, *args):
        """
        set_strmem_type(self, sptr, mptr) -> bool
        """
        return _idaapi.vdui_t_set_strmem_type(self, *args)

    def rename_strmem(self, *args):
        """
        rename_strmem(self, sptr, mptr) -> bool
        """
        return _idaapi.vdui_t_rename_strmem(self, *args)

    def set_global_type(self, *args):
        """
        set_global_type(self, ea) -> bool
        """
        return _idaapi.vdui_t_set_global_type(self, *args)

    def rename_global(self, *args):
        """
        rename_global(self, ea) -> bool
        """
        return _idaapi.vdui_t_rename_global(self, *args)

    def rename_label(self, *args):
        """
        rename_label(self, label) -> bool
        """
        return _idaapi.vdui_t_rename_label(self, *args)

    def jump_enter(self, *args):
        """
        jump_enter(self, idv, omflags) -> bool
        """
        return _idaapi.vdui_t_jump_enter(self, *args)

    def ctree_to_disasm(self, *args):
        """
        ctree_to_disasm(self) -> bool
        """
        return _idaapi.vdui_t_ctree_to_disasm(self, *args)

    def calc_cmt_type(self, *args):
        """
        calc_cmt_type(self, lnnum, cmttype) -> cmt_type_t
        """
        return _idaapi.vdui_t_calc_cmt_type(self, *args)

    def edit_cmt(self, *args):
        """
        edit_cmt(self, loc) -> bool
        """
        return _idaapi.vdui_t_edit_cmt(self, *args)

    def edit_func_cmt(self, *args):
        """
        edit_func_cmt(self) -> bool
        """
        return _idaapi.vdui_t_edit_func_cmt(self, *args)

    def del_orphan_cmts(self, *args):
        """
        del_orphan_cmts(self) -> bool
        """
        return _idaapi.vdui_t_del_orphan_cmts(self, *args)

    def set_num_radix(self, *args):
        """
        set_num_radix(self, base) -> bool
        """
        return _idaapi.vdui_t_set_num_radix(self, *args)

    def set_num_enum(self, *args):
        """
        set_num_enum(self) -> bool
        """
        return _idaapi.vdui_t_set_num_enum(self, *args)

    def set_num_stroff(self, *args):
        """
        set_num_stroff(self) -> bool
        """
        return _idaapi.vdui_t_set_num_stroff(self, *args)

    def invert_sign(self, *args):
        """
        invert_sign(self) -> bool
        """
        return _idaapi.vdui_t_invert_sign(self, *args)

    def invert_bits(self, *args):
        """
        invert_bits(self) -> bool
        """
        return _idaapi.vdui_t_invert_bits(self, *args)

    def collapse_item(self, *args):
        """
        collapse_item(self, hide) -> bool
        """
        return _idaapi.vdui_t_collapse_item(self, *args)

    def collapse_lvars(self, *args):
        """
        collapse_lvars(self, hide) -> bool
        """
        return _idaapi.vdui_t_collapse_lvars(self, *args)

    def split_item(self, *args):
        """
        split_item(self, split) -> bool
        """
        return _idaapi.vdui_t_split_item(self, *args)

    __swig_destroy__ = _idaapi.delete_vdui_t
    __del__ = lambda self : None;
vdui_t_swigregister = _idaapi.vdui_t_swigregister
vdui_t_swigregister(vdui_t)
CMT_NONE = cvar.CMT_NONE
CMT_TAIL = cvar.CMT_TAIL
CMT_BLOCK1 = cvar.CMT_BLOCK1
CMT_BLOCK2 = cvar.CMT_BLOCK2
CMT_LVAR = cvar.CMT_LVAR
CMT_FUNC = cvar.CMT_FUNC
CMT_ALL = cvar.CMT_ALL
VDUI_VISIBLE = _idaapi.VDUI_VISIBLE
VDUI_VALID = _idaapi.VDUI_VALID
VDUI_LOCKED = _idaapi.VDUI_LOCKED

hx_user_cmts_begin = _idaapi.hx_user_cmts_begin
hx_user_cmts_end = _idaapi.hx_user_cmts_end
hx_user_cmts_next = _idaapi.hx_user_cmts_next
hx_user_cmts_prev = _idaapi.hx_user_cmts_prev
hx_user_cmts_first = _idaapi.hx_user_cmts_first
hx_user_cmts_second = _idaapi.hx_user_cmts_second
hx_user_cmts_find = _idaapi.hx_user_cmts_find
hx_user_cmts_insert = _idaapi.hx_user_cmts_insert
hx_user_cmts_erase = _idaapi.hx_user_cmts_erase
hx_user_cmts_clear = _idaapi.hx_user_cmts_clear
hx_user_cmts_size = _idaapi.hx_user_cmts_size
hx_user_cmts_free = _idaapi.hx_user_cmts_free
hx_user_numforms_begin = _idaapi.hx_user_numforms_begin
hx_user_numforms_end = _idaapi.hx_user_numforms_end
hx_user_numforms_next = _idaapi.hx_user_numforms_next
hx_user_numforms_prev = _idaapi.hx_user_numforms_prev
hx_user_numforms_first = _idaapi.hx_user_numforms_first
hx_user_numforms_second = _idaapi.hx_user_numforms_second
hx_user_numforms_find = _idaapi.hx_user_numforms_find
hx_user_numforms_insert = _idaapi.hx_user_numforms_insert
hx_user_numforms_erase = _idaapi.hx_user_numforms_erase
hx_user_numforms_clear = _idaapi.hx_user_numforms_clear
hx_user_numforms_size = _idaapi.hx_user_numforms_size
hx_user_numforms_free = _idaapi.hx_user_numforms_free
hx_user_iflags_begin = _idaapi.hx_user_iflags_begin
hx_user_iflags_end = _idaapi.hx_user_iflags_end
hx_user_iflags_next = _idaapi.hx_user_iflags_next
hx_user_iflags_prev = _idaapi.hx_user_iflags_prev
hx_user_iflags_first = _idaapi.hx_user_iflags_first
hx_user_iflags_second = _idaapi.hx_user_iflags_second
hx_user_iflags_find = _idaapi.hx_user_iflags_find
hx_user_iflags_insert = _idaapi.hx_user_iflags_insert
hx_user_iflags_erase = _idaapi.hx_user_iflags_erase
hx_user_iflags_clear = _idaapi.hx_user_iflags_clear
hx_user_iflags_size = _idaapi.hx_user_iflags_size
hx_user_iflags_free = _idaapi.hx_user_iflags_free
hx_user_labels_begin = _idaapi.hx_user_labels_begin
hx_user_labels_end = _idaapi.hx_user_labels_end
hx_user_labels_next = _idaapi.hx_user_labels_next
hx_user_labels_prev = _idaapi.hx_user_labels_prev
hx_user_labels_first = _idaapi.hx_user_labels_first
hx_user_labels_second = _idaapi.hx_user_labels_second
hx_user_labels_find = _idaapi.hx_user_labels_find
hx_user_labels_insert = _idaapi.hx_user_labels_insert
hx_user_labels_erase = _idaapi.hx_user_labels_erase
hx_user_labels_clear = _idaapi.hx_user_labels_clear
hx_user_labels_size = _idaapi.hx_user_labels_size
hx_user_labels_free = _idaapi.hx_user_labels_free
hx_operand_locator_t_compare = _idaapi.hx_operand_locator_t_compare
hx_vd_printer_t_print = _idaapi.hx_vd_printer_t_print
hx_qstring_printer_t_print = _idaapi.hx_qstring_printer_t_print
hx_remove_typedef = _idaapi.hx_remove_typedef
hx_is_type_correct = _idaapi.hx_is_type_correct
hx_is_type_integral = _idaapi.hx_is_type_integral
hx_is_type_small_struni = _idaapi.hx_is_type_small_struni
hx_partial_type_num = _idaapi.hx_partial_type_num
hx_get_float_bit = _idaapi.hx_get_float_bit
hx_typestring_print = _idaapi.hx_typestring_print
hx_typestring_change_sign = _idaapi.hx_typestring_change_sign
hx_typestring_get_cc = _idaapi.hx_typestring_get_cc
hx_typestring_get_nth_arg = _idaapi.hx_typestring_get_nth_arg
hx_get_int_type_by_width_and_sign = _idaapi.hx_get_int_type_by_width_and_sign
hx_get_unk_type = _idaapi.hx_get_unk_type
hx_get_member_type = _idaapi.hx_get_member_type
hx_make_array = _idaapi.hx_make_array
hx_make_pointer = _idaapi.hx_make_pointer
hx_create_typedef = _idaapi.hx_create_typedef
hx_remove_pointer = _idaapi.hx_remove_pointer
hx_cnv_array_to_ptr = _idaapi.hx_cnv_array_to_ptr
hx_strtype_info_t_build_base_type = _idaapi.hx_strtype_info_t_build_base_type
hx_strtype_info_t_build_udt_type = _idaapi.hx_strtype_info_t_build_udt_type
hx_arglocs_overlap = _idaapi.hx_arglocs_overlap
hx_lvar_locator_t_get_regnum = _idaapi.hx_lvar_locator_t_get_regnum
hx_lvar_locator_t_compare = _idaapi.hx_lvar_locator_t_compare
hx_lvar_t_accepts_type = _idaapi.hx_lvar_t_accepts_type
hx_lvar_t_set_lvar_type = _idaapi.hx_lvar_t_set_lvar_type
hx_lvar_t_set_width = _idaapi.hx_lvar_t_set_width
hx_lvars_t_find_stkvar = _idaapi.hx_lvars_t_find_stkvar
hx_lvars_t_find = _idaapi.hx_lvars_t_find
hx_lvars_t_find_lvar = _idaapi.hx_lvars_t_find_lvar
hx_restore_user_lvar_settings = _idaapi.hx_restore_user_lvar_settings
hx_save_user_lvar_settings = _idaapi.hx_save_user_lvar_settings
hx_fnumber_t_print = _idaapi.hx_fnumber_t_print
hx_get_hexrays_version = _idaapi.hx_get_hexrays_version
hx_open_pseudocode = _idaapi.hx_open_pseudocode
hx_close_pseudocode = _idaapi.hx_close_pseudocode
hx_decompile = _idaapi.hx_decompile
hx_decompile_many = _idaapi.hx_decompile_many
hx_micro_err_format = _idaapi.hx_micro_err_format
hx_hexrays_failure_t_desc = _idaapi.hx_hexrays_failure_t_desc
hx_send_database = _idaapi.hx_send_database
hx_negated_relation = _idaapi.hx_negated_relation
hx_get_op_signness = _idaapi.hx_get_op_signness
hx_asgop = _idaapi.hx_asgop
hx_asgop_revert = _idaapi.hx_asgop_revert
hx_cnumber_t_print = _idaapi.hx_cnumber_t_print
hx_cnumber_t_value = _idaapi.hx_cnumber_t_value
hx_cnumber_t_assign = _idaapi.hx_cnumber_t_assign
hx_cnumber_t_compare = _idaapi.hx_cnumber_t_compare
hx_var_ref_t_compare = _idaapi.hx_var_ref_t_compare
hx_ctree_visitor_t_apply_to = _idaapi.hx_ctree_visitor_t_apply_to
hx_ctree_visitor_t_apply_to_exprs = _idaapi.hx_ctree_visitor_t_apply_to_exprs
hx_ctree_parentee_t_recalc_parent_types = _idaapi.hx_ctree_parentee_t_recalc_parent_types
hx_cfunc_parentee_t_calc_rvalue_type = _idaapi.hx_cfunc_parentee_t_calc_rvalue_type
hx_citem_locator_t_compare = _idaapi.hx_citem_locator_t_compare
hx_citem_t_contains_label = _idaapi.hx_citem_t_contains_label
hx_citem_t_find_parent_of = _idaapi.hx_citem_t_find_parent_of
hx_cexpr_t_assign = _idaapi.hx_cexpr_t_assign
hx_cexpr_t_compare = _idaapi.hx_cexpr_t_compare
hx_cexpr_t_replace_by = _idaapi.hx_cexpr_t_replace_by
hx_cexpr_t_cleanup = _idaapi.hx_cexpr_t_cleanup
hx_cexpr_t_put_number = _idaapi.hx_cexpr_t_put_number
hx_cexpr_t_print1 = _idaapi.hx_cexpr_t_print1
hx_cexpr_t_calc_type = _idaapi.hx_cexpr_t_calc_type
hx_cexpr_t_equal_effect = _idaapi.hx_cexpr_t_equal_effect
hx_cexpr_t_is_child_of = _idaapi.hx_cexpr_t_is_child_of
hx_cexpr_t_contains_operator = _idaapi.hx_cexpr_t_contains_operator
hx_cexpr_t_get_high_nbit_bound = _idaapi.hx_cexpr_t_get_high_nbit_bound
hx_cexpr_t_requires_lvalue = _idaapi.hx_cexpr_t_requires_lvalue
hx_cexpr_t_has_side_effects = _idaapi.hx_cexpr_t_has_side_effects
hx_cif_t_assign = _idaapi.hx_cif_t_assign
hx_cif_t_compare = _idaapi.hx_cif_t_compare
hx_cloop_t_assign = _idaapi.hx_cloop_t_assign
hx_cfor_t_compare = _idaapi.hx_cfor_t_compare
hx_cwhile_t_compare = _idaapi.hx_cwhile_t_compare
hx_cdo_t_compare = _idaapi.hx_cdo_t_compare
hx_creturn_t_compare = _idaapi.hx_creturn_t_compare
hx_cgoto_t_compare = _idaapi.hx_cgoto_t_compare
hx_casm_t_compare = _idaapi.hx_casm_t_compare
hx_cinsn_t_assign = _idaapi.hx_cinsn_t_assign
hx_cinsn_t_compare = _idaapi.hx_cinsn_t_compare
hx_cinsn_t_replace_by = _idaapi.hx_cinsn_t_replace_by
hx_cinsn_t_cleanup = _idaapi.hx_cinsn_t_cleanup
hx_cinsn_t_new_insn = _idaapi.hx_cinsn_t_new_insn
hx_cinsn_t_create_if = _idaapi.hx_cinsn_t_create_if
hx_cinsn_t_print = _idaapi.hx_cinsn_t_print
hx_cinsn_t_print1 = _idaapi.hx_cinsn_t_print1
hx_cinsn_t_is_ordinary_flow = _idaapi.hx_cinsn_t_is_ordinary_flow
hx_cinsn_t_contains_insn = _idaapi.hx_cinsn_t_contains_insn
hx_cinsn_t_collect_free_breaks = _idaapi.hx_cinsn_t_collect_free_breaks
hx_cinsn_t_collect_free_continues = _idaapi.hx_cinsn_t_collect_free_continues
hx_cblock_t_compare = _idaapi.hx_cblock_t_compare
hx_carglist_t_compare = _idaapi.hx_carglist_t_compare
hx_ccase_t_compare = _idaapi.hx_ccase_t_compare
hx_ccases_t_compare = _idaapi.hx_ccases_t_compare
hx_cswitch_t_compare = _idaapi.hx_cswitch_t_compare
hx_ctree_item_t_get_memptr = _idaapi.hx_ctree_item_t_get_memptr
hx_ctree_item_t_get_lvar = _idaapi.hx_ctree_item_t_get_lvar
hx_ctree_item_t_get_ea = _idaapi.hx_ctree_item_t_get_ea
hx_ctree_item_t_get_label_num = _idaapi.hx_ctree_item_t_get_label_num
hx_lnot = _idaapi.hx_lnot
hx_new_block = _idaapi.hx_new_block
hx_vcreate_helper = _idaapi.hx_vcreate_helper
hx_vcall_helper = _idaapi.hx_vcall_helper
hx_make_num = _idaapi.hx_make_num
hx_make_ref = _idaapi.hx_make_ref
hx_dereference = _idaapi.hx_dereference
hx_save_user_labels = _idaapi.hx_save_user_labels
hx_save_user_cmts = _idaapi.hx_save_user_cmts
hx_save_user_numforms = _idaapi.hx_save_user_numforms
hx_save_user_iflags = _idaapi.hx_save_user_iflags
hx_restore_user_labels = _idaapi.hx_restore_user_labels
hx_restore_user_cmts = _idaapi.hx_restore_user_cmts
hx_restore_user_numforms = _idaapi.hx_restore_user_numforms
hx_restore_user_iflags = _idaapi.hx_restore_user_iflags
hx_cfunc_t_build_c_tree = _idaapi.hx_cfunc_t_build_c_tree
hx_cfunc_t_verify = _idaapi.hx_cfunc_t_verify
hx_cfunc_t_print_dcl = _idaapi.hx_cfunc_t_print_dcl
hx_cfunc_t_print_func = _idaapi.hx_cfunc_t_print_func
hx_cfunc_t_get_func_type = _idaapi.hx_cfunc_t_get_func_type
hx_cfunc_t_get_lvars = _idaapi.hx_cfunc_t_get_lvars
hx_cfunc_t_find_label = _idaapi.hx_cfunc_t_find_label
hx_cfunc_t_remove_unused_labels = _idaapi.hx_cfunc_t_remove_unused_labels
hx_cfunc_t_get_user_cmt = _idaapi.hx_cfunc_t_get_user_cmt
hx_cfunc_t_set_user_cmt = _idaapi.hx_cfunc_t_set_user_cmt
hx_cfunc_t_get_user_iflags = _idaapi.hx_cfunc_t_get_user_iflags
hx_cfunc_t_set_user_iflags = _idaapi.hx_cfunc_t_set_user_iflags
hx_cfunc_t_has_orphan_cmts = _idaapi.hx_cfunc_t_has_orphan_cmts
hx_cfunc_t_del_orphan_cmts = _idaapi.hx_cfunc_t_del_orphan_cmts
hx_cfunc_t_get_line_item = _idaapi.hx_cfunc_t_get_line_item
hx_cfunc_t_get_warnings = _idaapi.hx_cfunc_t_get_warnings
hx_cfunc_t_gather_derefs = _idaapi.hx_cfunc_t_gather_derefs
hx_cfunc_t_cleanup = _idaapi.hx_cfunc_t_cleanup
hx_get_ctype_name = _idaapi.hx_get_ctype_name
hx_install_hexrays_callback = _idaapi.hx_install_hexrays_callback
hx_remove_hexrays_callback = _idaapi.hx_remove_hexrays_callback
hx_vdui_t_refresh_view = _idaapi.hx_vdui_t_refresh_view
hx_vdui_t_refresh_ctext = _idaapi.hx_vdui_t_refresh_ctext
hx_vdui_t_switch_to = _idaapi.hx_vdui_t_switch_to
hx_vdui_t_get_number = _idaapi.hx_vdui_t_get_number
hx_vdui_t_clear = _idaapi.hx_vdui_t_clear
hx_vdui_t_refresh_cpos = _idaapi.hx_vdui_t_refresh_cpos
hx_vdui_t_get_current_item = _idaapi.hx_vdui_t_get_current_item
hx_vdui_t_ui_rename_lvar = _idaapi.hx_vdui_t_ui_rename_lvar
hx_vdui_t_rename_lvar = _idaapi.hx_vdui_t_rename_lvar
hx_vdui_t_ui_set_lvar_type = _idaapi.hx_vdui_t_ui_set_lvar_type
hx_vdui_t_set_lvar_type = _idaapi.hx_vdui_t_set_lvar_type
hx_vdui_t_edit_lvar_cmt = _idaapi.hx_vdui_t_edit_lvar_cmt
hx_vdui_t_set_lvar_cmt = _idaapi.hx_vdui_t_set_lvar_cmt
hx_vdui_t_set_strmem_type = _idaapi.hx_vdui_t_set_strmem_type
hx_vdui_t_rename_strmem = _idaapi.hx_vdui_t_rename_strmem
hx_vdui_t_set_global_type = _idaapi.hx_vdui_t_set_global_type
hx_vdui_t_rename_global = _idaapi.hx_vdui_t_rename_global
hx_vdui_t_rename_label = _idaapi.hx_vdui_t_rename_label
hx_vdui_t_jump_enter = _idaapi.hx_vdui_t_jump_enter
hx_vdui_t_ctree_to_disasm = _idaapi.hx_vdui_t_ctree_to_disasm
hx_vdui_t_push_current_location = _idaapi.hx_vdui_t_push_current_location
hx_vdui_t_pop_current_location = _idaapi.hx_vdui_t_pop_current_location
hx_vdui_t_calc_cmt_type = _idaapi.hx_vdui_t_calc_cmt_type
hx_vdui_t_edit_cmt = _idaapi.hx_vdui_t_edit_cmt
hx_vdui_t_edit_func_cmt = _idaapi.hx_vdui_t_edit_func_cmt
hx_vdui_t_del_orphan_cmts = _idaapi.hx_vdui_t_del_orphan_cmts
hx_vdui_t_set_num_radix = _idaapi.hx_vdui_t_set_num_radix
hx_vdui_t_set_num_enum = _idaapi.hx_vdui_t_set_num_enum
hx_vdui_t_set_num_stroff = _idaapi.hx_vdui_t_set_num_stroff
hx_vdui_t_invert_sign = _idaapi.hx_vdui_t_invert_sign
hx_vdui_t_collapse_item = _idaapi.hx_vdui_t_collapse_item
hx_vdui_t_split_item = _idaapi.hx_vdui_t_split_item
hx_vdui_t_set_vargloc_end = _idaapi.hx_vdui_t_set_vargloc_end
hx_lvar_mapping_begin = _idaapi.hx_lvar_mapping_begin
hx_lvar_mapping_end = _idaapi.hx_lvar_mapping_end
hx_lvar_mapping_next = _idaapi.hx_lvar_mapping_next
hx_lvar_mapping_prev = _idaapi.hx_lvar_mapping_prev
hx_lvar_mapping_first = _idaapi.hx_lvar_mapping_first
hx_lvar_mapping_second = _idaapi.hx_lvar_mapping_second
hx_lvar_mapping_find = _idaapi.hx_lvar_mapping_find
hx_lvar_mapping_insert = _idaapi.hx_lvar_mapping_insert
hx_lvar_mapping_erase = _idaapi.hx_lvar_mapping_erase
hx_lvar_mapping_clear = _idaapi.hx_lvar_mapping_clear
hx_lvar_mapping_size = _idaapi.hx_lvar_mapping_size
hx_lvar_mapping_free = _idaapi.hx_lvar_mapping_free
hx_user_unions_begin = _idaapi.hx_user_unions_begin
hx_user_unions_end = _idaapi.hx_user_unions_end
hx_user_unions_next = _idaapi.hx_user_unions_next
hx_user_unions_prev = _idaapi.hx_user_unions_prev
hx_user_unions_first = _idaapi.hx_user_unions_first
hx_user_unions_second = _idaapi.hx_user_unions_second
hx_user_unions_find = _idaapi.hx_user_unions_find
hx_user_unions_insert = _idaapi.hx_user_unions_insert
hx_user_unions_erase = _idaapi.hx_user_unions_erase
hx_user_unions_clear = _idaapi.hx_user_unions_clear
hx_user_unions_size = _idaapi.hx_user_unions_size
hx_user_unions_free = _idaapi.hx_user_unions_free
hx_strtype_info_t_create_from = _idaapi.hx_strtype_info_t_create_from
hx_save_user_unions = _idaapi.hx_save_user_unions
hx_restore_user_unions = _idaapi.hx_restore_user_unions
hx_cfunc_t_get_user_union_selection = _idaapi.hx_cfunc_t_get_user_union_selection
hx_cfunc_t_set_user_union_selection = _idaapi.hx_cfunc_t_set_user_union_selection
hx_vdui_t_ui_edit_lvar_cmt = _idaapi.hx_vdui_t_ui_edit_lvar_cmt
hx_vdui_t_ui_map_lvar = _idaapi.hx_vdui_t_ui_map_lvar
hx_vdui_t_ui_unmap_lvar = _idaapi.hx_vdui_t_ui_unmap_lvar
hx_vdui_t_map_lvar = _idaapi.hx_vdui_t_map_lvar
hx_dummy_ptrtype = _idaapi.hx_dummy_ptrtype
hx_create_field_name = _idaapi.hx_create_field_name
hx_dummy_plist_for = _idaapi.hx_dummy_plist_for
hx_make_dt = _idaapi.hx_make_dt
hx_cexpr_t_get_low_nbit_bound = _idaapi.hx_cexpr_t_get_low_nbit_bound
hx_eamap_begin = _idaapi.hx_eamap_begin
hx_eamap_end = _idaapi.hx_eamap_end
hx_eamap_next = _idaapi.hx_eamap_next
hx_eamap_prev = _idaapi.hx_eamap_prev
hx_eamap_first = _idaapi.hx_eamap_first
hx_eamap_second = _idaapi.hx_eamap_second
hx_eamap_find = _idaapi.hx_eamap_find
hx_eamap_insert = _idaapi.hx_eamap_insert
hx_eamap_erase = _idaapi.hx_eamap_erase
hx_eamap_clear = _idaapi.hx_eamap_clear
hx_eamap_size = _idaapi.hx_eamap_size
hx_eamap_free = _idaapi.hx_eamap_free
hx_boundaries_begin = _idaapi.hx_boundaries_begin
hx_boundaries_end = _idaapi.hx_boundaries_end
hx_boundaries_next = _idaapi.hx_boundaries_next
hx_boundaries_prev = _idaapi.hx_boundaries_prev
hx_boundaries_first = _idaapi.hx_boundaries_first
hx_boundaries_second = _idaapi.hx_boundaries_second
hx_boundaries_find = _idaapi.hx_boundaries_find
hx_boundaries_insert = _idaapi.hx_boundaries_insert
hx_boundaries_erase = _idaapi.hx_boundaries_erase
hx_boundaries_clear = _idaapi.hx_boundaries_clear
hx_boundaries_size = _idaapi.hx_boundaries_size
hx_boundaries_free = _idaapi.hx_boundaries_free
hx_mark_cfunc_dirty = _idaapi.hx_mark_cfunc_dirty
hx_clear_cached_cfuncs = _idaapi.hx_clear_cached_cfuncs
hx_has_cached_cfunc = _idaapi.hx_has_cached_cfunc
hx_cfunc_t_get_eamap = _idaapi.hx_cfunc_t_get_eamap
hx_cfunc_t_get_boundaries = _idaapi.hx_cfunc_t_get_boundaries
hx_cfunc_t_get_pseudocode = _idaapi.hx_cfunc_t_get_pseudocode
hx_vdui_t_collapse_lvars = _idaapi.hx_vdui_t_collapse_lvars
hx_vdui_t_invert_bits = _idaapi.hx_vdui_t_invert_bits
hx_print_vdloc = _idaapi.hx_print_vdloc
hx_is_small_struni = _idaapi.hx_is_small_struni
hx_is_nonbool_type = _idaapi.hx_is_nonbool_type
hx_is_bool_type = _idaapi.hx_is_bool_type
hx_get_type = _idaapi.hx_get_type
hx_set_type = _idaapi.hx_set_type
hx_vdloc_t_compare = _idaapi.hx_vdloc_t_compare
hx_get_float_type = _idaapi.hx_get_float_type
hx_vdui_t_get_current_label = _idaapi.hx_vdui_t_get_current_label
hx_get_tform_vdui = _idaapi.hx_get_tform_vdui
hx_cfunc_t_print_dcl2 = _idaapi.hx_cfunc_t_print_dcl2

def term_hexrays_plugin(*args):
  """
  term_hexrays_plugin()
  """
  return _idaapi.term_hexrays_plugin(*args)
class user_numforms_iterator_t(object):
    """
    Proxy of C++ user_numforms_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.user_numforms_iterator_t_x_get, _idaapi.user_numforms_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.user_numforms_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.user_numforms_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_numforms_iterator_t
        """
        this = _idaapi.new_user_numforms_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_numforms_iterator_t
    __del__ = lambda self : None;
user_numforms_iterator_t_swigregister = _idaapi.user_numforms_iterator_t_swigregister
user_numforms_iterator_t_swigregister(user_numforms_iterator_t)


def user_numforms_begin(*args):
  """
  user_numforms_begin(map) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_begin(*args)

def user_numforms_end(*args):
  """
  user_numforms_end(map) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_end(*args)

def user_numforms_next(*args):
  """
  user_numforms_next(p) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_next(*args)

def user_numforms_prev(*args):
  """
  user_numforms_prev(p) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_prev(*args)

def user_numforms_first(*args):
  """
  user_numforms_first(p) -> operand_locator_t
  """
  return _idaapi.user_numforms_first(*args)

def user_numforms_second(*args):
  """
  user_numforms_second(p) -> number_format_t
  """
  return _idaapi.user_numforms_second(*args)

def user_numforms_find(*args):
  """
  user_numforms_find(map, key) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_find(*args)

def user_numforms_insert(*args):
  """
  user_numforms_insert(map, key, val) -> user_numforms_iterator_t
  """
  return _idaapi.user_numforms_insert(*args)

def user_numforms_erase(*args):
  """
  user_numforms_erase(map, p)
  """
  return _idaapi.user_numforms_erase(*args)

def user_numforms_clear(*args):
  """
  user_numforms_clear(map)
  """
  return _idaapi.user_numforms_clear(*args)

def user_numforms_size(*args):
  """
  user_numforms_size(map) -> size_t
  """
  return _idaapi.user_numforms_size(*args)

def user_numforms_free(*args):
  """
  user_numforms_free(map)
  """
  return _idaapi.user_numforms_free(*args)
class lvar_mapping_iterator_t(object):
    """
    Proxy of C++ lvar_mapping_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.lvar_mapping_iterator_t_x_get, _idaapi.lvar_mapping_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.lvar_mapping_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.lvar_mapping_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> lvar_mapping_iterator_t
        """
        this = _idaapi.new_lvar_mapping_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lvar_mapping_iterator_t
    __del__ = lambda self : None;
lvar_mapping_iterator_t_swigregister = _idaapi.lvar_mapping_iterator_t_swigregister
lvar_mapping_iterator_t_swigregister(lvar_mapping_iterator_t)


def lvar_mapping_begin(*args):
  """
  lvar_mapping_begin(map) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_begin(*args)

def lvar_mapping_end(*args):
  """
  lvar_mapping_end(map) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_end(*args)

def lvar_mapping_next(*args):
  """
  lvar_mapping_next(p) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_next(*args)

def lvar_mapping_prev(*args):
  """
  lvar_mapping_prev(p) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_prev(*args)

def lvar_mapping_first(*args):
  """
  lvar_mapping_first(p) -> lvar_locator_t
  """
  return _idaapi.lvar_mapping_first(*args)

def lvar_mapping_second(*args):
  """
  lvar_mapping_second(p) -> lvar_locator_t
  """
  return _idaapi.lvar_mapping_second(*args)

def lvar_mapping_find(*args):
  """
  lvar_mapping_find(map, key) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_find(*args)

def lvar_mapping_insert(*args):
  """
  lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t
  """
  return _idaapi.lvar_mapping_insert(*args)

def lvar_mapping_erase(*args):
  """
  lvar_mapping_erase(map, p)
  """
  return _idaapi.lvar_mapping_erase(*args)

def lvar_mapping_clear(*args):
  """
  lvar_mapping_clear(map)
  """
  return _idaapi.lvar_mapping_clear(*args)

def lvar_mapping_size(*args):
  """
  lvar_mapping_size(map) -> size_t
  """
  return _idaapi.lvar_mapping_size(*args)

def lvar_mapping_free(*args):
  """
  lvar_mapping_free(map)
  """
  return _idaapi.lvar_mapping_free(*args)
class user_cmts_iterator_t(object):
    """
    Proxy of C++ user_cmts_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.user_cmts_iterator_t_x_get, _idaapi.user_cmts_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.user_cmts_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.user_cmts_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_cmts_iterator_t
        """
        this = _idaapi.new_user_cmts_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_cmts_iterator_t
    __del__ = lambda self : None;
user_cmts_iterator_t_swigregister = _idaapi.user_cmts_iterator_t_swigregister
user_cmts_iterator_t_swigregister(user_cmts_iterator_t)


def user_cmts_begin(*args):
  """
  user_cmts_begin(map) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_begin(*args)

def user_cmts_end(*args):
  """
  user_cmts_end(map) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_end(*args)

def user_cmts_next(*args):
  """
  user_cmts_next(p) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_next(*args)

def user_cmts_prev(*args):
  """
  user_cmts_prev(p) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_prev(*args)

def user_cmts_first(*args):
  """
  user_cmts_first(p) -> treeloc_t
  """
  return _idaapi.user_cmts_first(*args)

def user_cmts_second(*args):
  """
  user_cmts_second(p) -> citem_cmt_t
  """
  return _idaapi.user_cmts_second(*args)

def user_cmts_find(*args):
  """
  user_cmts_find(map, key) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_find(*args)

def user_cmts_insert(*args):
  """
  user_cmts_insert(map, key, val) -> user_cmts_iterator_t
  """
  return _idaapi.user_cmts_insert(*args)

def user_cmts_erase(*args):
  """
  user_cmts_erase(map, p)
  """
  return _idaapi.user_cmts_erase(*args)

def user_cmts_clear(*args):
  """
  user_cmts_clear(map)
  """
  return _idaapi.user_cmts_clear(*args)

def user_cmts_size(*args):
  """
  user_cmts_size(map) -> size_t
  """
  return _idaapi.user_cmts_size(*args)

def user_cmts_free(*args):
  """
  user_cmts_free(map)
  """
  return _idaapi.user_cmts_free(*args)
class user_iflags_iterator_t(object):
    """
    Proxy of C++ user_iflags_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.user_iflags_iterator_t_x_get, _idaapi.user_iflags_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.user_iflags_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.user_iflags_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_iflags_iterator_t
        """
        this = _idaapi.new_user_iflags_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_iflags_iterator_t
    __del__ = lambda self : None;
user_iflags_iterator_t_swigregister = _idaapi.user_iflags_iterator_t_swigregister
user_iflags_iterator_t_swigregister(user_iflags_iterator_t)


def user_iflags_begin(*args):
  """
  user_iflags_begin(map) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_begin(*args)

def user_iflags_end(*args):
  """
  user_iflags_end(map) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_end(*args)

def user_iflags_next(*args):
  """
  user_iflags_next(p) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_next(*args)

def user_iflags_prev(*args):
  """
  user_iflags_prev(p) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_prev(*args)

def user_iflags_first(*args):
  """
  user_iflags_first(p) -> citem_locator_t
  """
  return _idaapi.user_iflags_first(*args)

def user_iflags_second(*args):
  """
  user_iflags_second(p) -> int32 &
  """
  return _idaapi.user_iflags_second(*args)

def user_iflags_find(*args):
  """
  user_iflags_find(map, key) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_find(*args)

def user_iflags_insert(*args):
  """
  user_iflags_insert(map, key, val) -> user_iflags_iterator_t
  """
  return _idaapi.user_iflags_insert(*args)

def user_iflags_erase(*args):
  """
  user_iflags_erase(map, p)
  """
  return _idaapi.user_iflags_erase(*args)

def user_iflags_clear(*args):
  """
  user_iflags_clear(map)
  """
  return _idaapi.user_iflags_clear(*args)

def user_iflags_size(*args):
  """
  user_iflags_size(map) -> size_t
  """
  return _idaapi.user_iflags_size(*args)

def user_iflags_free(*args):
  """
  user_iflags_free(map)
  """
  return _idaapi.user_iflags_free(*args)
class user_unions_iterator_t(object):
    """
    Proxy of C++ user_unions_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.user_unions_iterator_t_x_get, _idaapi.user_unions_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.user_unions_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.user_unions_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_unions_iterator_t
        """
        this = _idaapi.new_user_unions_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_unions_iterator_t
    __del__ = lambda self : None;
user_unions_iterator_t_swigregister = _idaapi.user_unions_iterator_t_swigregister
user_unions_iterator_t_swigregister(user_unions_iterator_t)


def user_unions_begin(*args):
  """
  user_unions_begin(map) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_begin(*args)

def user_unions_end(*args):
  """
  user_unions_end(map) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_end(*args)

def user_unions_next(*args):
  """
  user_unions_next(p) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_next(*args)

def user_unions_prev(*args):
  """
  user_unions_prev(p) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_prev(*args)

def user_unions_first(*args):
  """
  user_unions_first(p) -> ea_t const &
  """
  return _idaapi.user_unions_first(*args)

def user_unions_second(*args):
  """
  user_unions_second(p) -> intvec_t
  """
  return _idaapi.user_unions_second(*args)

def user_unions_find(*args):
  """
  user_unions_find(map, key) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_find(*args)

def user_unions_insert(*args):
  """
  user_unions_insert(map, key, val) -> user_unions_iterator_t
  """
  return _idaapi.user_unions_insert(*args)

def user_unions_erase(*args):
  """
  user_unions_erase(map, p)
  """
  return _idaapi.user_unions_erase(*args)

def user_unions_clear(*args):
  """
  user_unions_clear(map)
  """
  return _idaapi.user_unions_clear(*args)

def user_unions_size(*args):
  """
  user_unions_size(map) -> size_t
  """
  return _idaapi.user_unions_size(*args)

def user_unions_free(*args):
  """
  user_unions_free(map)
  """
  return _idaapi.user_unions_free(*args)
class user_labels_iterator_t(object):
    """
    Proxy of C++ user_labels_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.user_labels_iterator_t_x_get, _idaapi.user_labels_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.user_labels_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.user_labels_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> user_labels_iterator_t
        """
        this = _idaapi.new_user_labels_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_user_labels_iterator_t
    __del__ = lambda self : None;
user_labels_iterator_t_swigregister = _idaapi.user_labels_iterator_t_swigregister
user_labels_iterator_t_swigregister(user_labels_iterator_t)


def user_labels_begin(*args):
  """
  user_labels_begin(map) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_begin(*args)

def user_labels_end(*args):
  """
  user_labels_end(map) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_end(*args)

def user_labels_next(*args):
  """
  user_labels_next(p) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_next(*args)

def user_labels_prev(*args):
  """
  user_labels_prev(p) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_prev(*args)

def user_labels_first(*args):
  """
  user_labels_first(p) -> int const &
  """
  return _idaapi.user_labels_first(*args)

def user_labels_second(*args):
  """
  user_labels_second(p) -> qstring &
  """
  return _idaapi.user_labels_second(*args)

def user_labels_find(*args):
  """
  user_labels_find(map, key) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_find(*args)

def user_labels_insert(*args):
  """
  user_labels_insert(map, key, val) -> user_labels_iterator_t
  """
  return _idaapi.user_labels_insert(*args)

def user_labels_erase(*args):
  """
  user_labels_erase(map, p)
  """
  return _idaapi.user_labels_erase(*args)

def user_labels_clear(*args):
  """
  user_labels_clear(map)
  """
  return _idaapi.user_labels_clear(*args)

def user_labels_size(*args):
  """
  user_labels_size(map) -> size_t
  """
  return _idaapi.user_labels_size(*args)

def user_labels_free(*args):
  """
  user_labels_free(map)
  """
  return _idaapi.user_labels_free(*args)
class eamap_iterator_t(object):
    """
    Proxy of C++ eamap_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.eamap_iterator_t_x_get, _idaapi.eamap_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.eamap_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.eamap_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> eamap_iterator_t
        """
        this = _idaapi.new_eamap_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_eamap_iterator_t
    __del__ = lambda self : None;
eamap_iterator_t_swigregister = _idaapi.eamap_iterator_t_swigregister
eamap_iterator_t_swigregister(eamap_iterator_t)


def eamap_begin(*args):
  """
  eamap_begin(map) -> eamap_iterator_t
  """
  return _idaapi.eamap_begin(*args)

def eamap_end(*args):
  """
  eamap_end(map) -> eamap_iterator_t
  """
  return _idaapi.eamap_end(*args)

def eamap_next(*args):
  """
  eamap_next(p) -> eamap_iterator_t
  """
  return _idaapi.eamap_next(*args)

def eamap_prev(*args):
  """
  eamap_prev(p) -> eamap_iterator_t
  """
  return _idaapi.eamap_prev(*args)

def eamap_first(*args):
  """
  eamap_first(p) -> ea_t const &
  """
  return _idaapi.eamap_first(*args)

def eamap_second(*args):
  """
  eamap_second(p) -> cinsnptrvec_t
  """
  return _idaapi.eamap_second(*args)

def eamap_find(*args):
  """
  eamap_find(map, key) -> eamap_iterator_t
  """
  return _idaapi.eamap_find(*args)

def eamap_insert(*args):
  """
  eamap_insert(map, key, val) -> eamap_iterator_t
  """
  return _idaapi.eamap_insert(*args)

def eamap_erase(*args):
  """
  eamap_erase(map, p)
  """
  return _idaapi.eamap_erase(*args)

def eamap_clear(*args):
  """
  eamap_clear(map)
  """
  return _idaapi.eamap_clear(*args)

def eamap_size(*args):
  """
  eamap_size(map) -> size_t
  """
  return _idaapi.eamap_size(*args)

def eamap_free(*args):
  """
  eamap_free(map)
  """
  return _idaapi.eamap_free(*args)
class boundaries_iterator_t(object):
    """
    Proxy of C++ boundaries_iterator_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_idaapi.boundaries_iterator_t_x_get, _idaapi.boundaries_iterator_t_x_set)
    def __eq__(self, *args):
        """
        __eq__(self, p) -> bool
        """
        return _idaapi.boundaries_iterator_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, p) -> bool
        """
        return _idaapi.boundaries_iterator_t___ne__(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> boundaries_iterator_t
        """
        this = _idaapi.new_boundaries_iterator_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_boundaries_iterator_t
    __del__ = lambda self : None;
boundaries_iterator_t_swigregister = _idaapi.boundaries_iterator_t_swigregister
boundaries_iterator_t_swigregister(boundaries_iterator_t)


def boundaries_begin(*args):
  """
  boundaries_begin(map) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_begin(*args)

def boundaries_end(*args):
  """
  boundaries_end(map) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_end(*args)

def boundaries_next(*args):
  """
  boundaries_next(p) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_next(*args)

def boundaries_prev(*args):
  """
  boundaries_prev(p) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_prev(*args)

def boundaries_first(*args):
  """
  boundaries_first(p) -> cinsn_t
  """
  return _idaapi.boundaries_first(*args)

def boundaries_second(*args):
  """
  boundaries_second(p) -> areaset_t
  """
  return _idaapi.boundaries_second(*args)

def boundaries_find(*args):
  """
  boundaries_find(map, key) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_find(*args)

def boundaries_insert(*args):
  """
  boundaries_insert(map, key, val) -> boundaries_iterator_t
  """
  return _idaapi.boundaries_insert(*args)

def boundaries_erase(*args):
  """
  boundaries_erase(map, p)
  """
  return _idaapi.boundaries_erase(*args)

def boundaries_clear(*args):
  """
  boundaries_clear(map)
  """
  return _idaapi.boundaries_clear(*args)

def boundaries_size(*args):
  """
  boundaries_size(map) -> size_t
  """
  return _idaapi.boundaries_size(*args)

def boundaries_free(*args):
  """
  boundaries_free(map)
  """
  return _idaapi.boundaries_free(*args)
import idaapi

hexrays_failure_t.__str__ = lambda self: str(self.str)

# ---------------------------------------------------------------------
class DecompilationFailure(Exception):
    """
     Raised on a decompilation error.

    The associated hexrays_failure_t object is stored in the
    'info' member of this exception. 
"""

    def __init__(self, info):
        Exception.__init__(self, 'Decompilation failed: %s' % (str(info), ))
        self.info = info
        return

# ---------------------------------------------------------------------
def decompile(ea, hf=None):
    if isinstance(ea, (int, long)):
        func = idaapi.get_func(ea)
        if not func: return
    elif type(ea) == idaapi.func_t:
        func = ea
    else:
        raise RuntimeError('arg 1 of decompile expects either ea_t or cfunc_t argument')

    if hf is None:
        hf = hexrays_failure_t()

    ptr = _decompile(func, hf)

    if ptr.__deref__() is None:
        raise DecompilationFailure(hf)

    return ptr

# ---------------------------------------------------------------------
# stringify all string types
#qtype.__str__ = qtype.c_str
#qstring.__str__ = qstring.c_str
#citem_cmt_t.__str__ = citem_cmt_t.c_str

# ---------------------------------------------------------------------
# listify all list types
_listify_types(cinsnptrvec_t,
               ctree_items_t,
               qvector_lvar_t,
               qvector_carg_t,
               qvector_ccase_t,
               hexwarns_t,
               history_t)

def citem_to_specific_type(self):
    """
     cast the citem_t object to its more specific type, either cexpr_t or cinsn_t. 
    """

    if self.op >= cot_empty and self.op <= cot_last:
        return self.cexpr
    elif self.op >= cit_empty and self.op < cit_end:
        return self.cinsn

    raise RuntimeError('unknown op type %s' % (repr(self.op), ))
citem_t.to_specific_type = property(citem_to_specific_type)

"""
 array used for translating cinsn_t->op type to their names. 
"""
cinsn_t.op_to_typename = {}
for k in dir(_idaapi):
    if k.startswith('cit_'):
        cinsn_t.op_to_typename[getattr(_idaapi, k)] = k[4:]

"""
 array used for translating cexpr_t->op type to their names. 
"""
cexpr_t.op_to_typename = {}
for k in dir(_idaapi):
    if k.startswith('cot_'):
        cexpr_t.op_to_typename[getattr(_idaapi, k)] = k[4:]

def property_op_to_typename(self):
    return self.op_to_typename[self.op]
cinsn_t.opname = property(property_op_to_typename)
cexpr_t.opname = property(property_op_to_typename)

def cexpr_operands(self):
    """
     return a dictionary with the operands of a cexpr_t. 
    """

    if self.op >= cot_comma and self.op <= cot_asgumod or \
        self.op >= cot_lor and self.op <= cot_fdiv or \
        self.op == cot_idx:
        return {'x': self.x, 'y': self.y}

    elif self.op == cot_tern:
        return {'x': self.x, 'y': self.y, 'z': self.z}

    elif self.op in [cot_fneg, cot_neg, cot_sizeof] or \
        self.op >= cot_lnot and self.op <= cot_predec:
        return {'x': self.x}

    elif self.op == cot_cast:
        return {'type': self.type, 'x': self.x}

    elif self.op == cot_call:
        return {'x': self.x, 'a': self.a}

    elif self.op in [cot_memref, cot_memptr]:
        return {'x': self.x, 'm': self.m}

    elif self.op == cot_num:
        return {'n': self.n}

    elif self.op == cot_fnum:
        return {'fpc': self.fpc}

    elif self.op == cot_str:
        return {'string': self.string}

    elif self.op == cot_obj:
        return {'obj_ea': self.obj_ea}

    elif self.op == cot_var:
        return {'v': self.v}

    elif self.op == cot_helper:
        return {'helper': self.helper}

    raise RuntimeError('unknown op type %s' % self.opname)
cexpr_t.operands = property(cexpr_operands)

def cinsn_details(self):
    """
     return the details pointer for the cinsn_t object depending on the value of its op member. \
        this is one of the cblock_t, cif_t, etc. objects. 
"""

    if self.op not in self.op_to_typename:
        raise RuntimeError('unknown item->op type')

    opname = self.opname
    if opname == 'empty':
        return self

    if opname in ['break', 'continue']:
        return None

    return getattr(self, 'c' + opname)
cinsn_t.details = property(cinsn_details)

def cblock_iter(self):

    iter = self.begin()
    for i in range(self.size()):
        yield iter.cur
        iter.next()

    return
cblock_t.__iter__ = cblock_iter
cblock_t.__len__ = cblock_t.size

# cblock.find(cinsn_t) -> returns the iterator positioned at the given item
def cblock_find(self, item):

    iter = self.begin()
    for i in range(self.size()):
        if iter.cur == item:
            return iter
        iter.next()

    return
cblock_t.find = cblock_find

# cblock.index(cinsn_t) -> returns the index of the given item
def cblock_index(self, item):

    iter = self.begin()
    for i in range(self.size()):
        if iter.cur == item:
            return i
        iter.next()

    return
cblock_t.index = cblock_index

# cblock.at(int) -> returns the item at the given index index
def cblock_at(self, index):

    iter = self.begin()
    for i in range(self.size()):
        if i == index:
            return iter.cur
        iter.next()

    return
cblock_t.at = cblock_at

# cblock.remove(cinsn_t)
def cblock_remove(self, item):

    iter = self.find(item)
    self.erase(iter)

    return
cblock_t.remove = cblock_remove

# cblock.insert(index, cinsn_t)
def cblock_insert(self, index, item):

    pos = self.at(index)
    iter = self.find(pos)
    self.insert(iter, item)

    return
cblock_t.insert = cblock_insert

cfuncptr_t.__str__ = lambda self: str(self.__deref__())

def cfunc_type(self):
    """
     Get the function's return type tinfo_t object. 
    """
    tif = tinfo_t()
    result = self.get_func_type(tif)
    if not result:
        return
    return tif
cfunc_t.type = property(cfunc_type)
cfuncptr_t.type = property(lambda self: self.__deref__().type)

cfunc_t.arguments = property(lambda self: [o for o in self.lvars if o.is_arg_var])
cfuncptr_t.arguments = property(lambda self: self.__deref__().arguments)

cfunc_t.lvars = property(cfunc_t.get_lvars)
cfuncptr_t.lvars = property(lambda self: self.__deref__().lvars)
cfunc_t.warnings = property(cfunc_t.get_warnings)
cfuncptr_t.warnings = property(lambda self: self.__deref__().warnings)
cfunc_t.pseudocode = property(cfunc_t.get_pseudocode)
cfuncptr_t.pseudocode = property(lambda self: self.__deref__().get_pseudocode())
cfunc_t.eamap = property(cfunc_t.get_eamap)
cfuncptr_t.eamap = property(lambda self: self.__deref__().get_eamap())
cfunc_t.boundaries = property(cfunc_t.get_boundaries)
cfuncptr_t.boundaries = property(lambda self: self.__deref__().get_boundaries())

#pragma SWIG nowarn=+503

lvar_t.used = property(lvar_t.used)
lvar_t.typed = property(lvar_t.typed)
lvar_t.mreg_done = property(lvar_t.mreg_done)
lvar_t.has_nice_name = property(lvar_t.has_nice_name)
lvar_t.is_unknown_width = property(lvar_t.is_unknown_width)
lvar_t.has_user_info = property(lvar_t.has_user_info)
lvar_t.has_user_name = property(lvar_t.has_user_name)
lvar_t.has_user_type = property(lvar_t.has_user_type)
lvar_t.is_result_var = property(lvar_t.is_result_var)
lvar_t.is_arg_var = property(lvar_t.is_arg_var)
lvar_t.is_fake_var = property(lvar_t.is_fake_var)
lvar_t.is_overlapped_var = property(lvar_t.is_overlapped_var)
lvar_t.is_floating_var = property(lvar_t.is_floating_var)
lvar_t.is_spoiled_var = property(lvar_t.is_spoiled_var)
lvar_t.is_mapdst_var = property(lvar_t.is_mapdst_var)

# dictify all dict-like types

def _map___getitem__(self, key):
    """
     Returns the value associated with the provided key. 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if key not in self:
        raise KeyError('key not found')
    return self.second(self.find(key))

def _map___setitem__(self, key, value):
    """
     Returns the value associated with the provided key. 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if not isinstance(value, self.valuetype):
        raise KeyError('type of `value` should be ' + repr(self.valuetype) + ' but got ' + type(value))
    self.insert(key, value)
    return

def _map___delitem__(self, key):
    """
     Removes the value associated with the provided key. 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if key not in self:
        raise KeyError('key not found')
    self.erase(self.find(key))
    return

def _map___contains__(self, key):
    """
     Returns true if the specified key exists in the . 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if self.find(key) != self.end():
        return True
    return False

def _map_clear(self):
    self.clear()
    return

def _map_copy(self):
    ret = {}
    for k in self.iterkeys():
        ret[k] = self[k]
    return ret

def _map_get(self, key, default=None):
    if key in self:
        return self[key]
    return default

def _map_iterkeys(self):
    iter = self.begin()
    while iter != self.end():
        yield self.first(iter)
        iter = self.next(iter)
    return

def _map_itervalues(self):
    iter = self.begin()
    while iter != self.end():
        yield self.second(iter)
        iter = self.next(iter)
    return

def _map_iteritems(self):
    iter = self.begin()
    while iter != self.end():
        yield (self.first(iter), self.second(iter))
        iter = self.next(iter)
    return

def _map_keys(self):
    return list(self.iterkeys())

def _map_values(self):
    return list(self.itervalues())

def _map_items(self):
    return list(self.iteritems())

def _map_has_key(self, key):
    return key in self

def _map_pop(self, key):
    """
     Sets the value associated with the provided key. 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if key not in self:
        raise KeyError('key not found')
    ret = self[key]
    del self[key]
    return ret

def _map_popitem(self):
    """
     Sets the value associated with the provided key. 
    """
    if len(self) == 0:
        raise KeyError('key not found')
    key = self.keys()[0]
    return (key, self.pop(key))

def _map_setdefault(self, key, default=None):
    """
     Sets the value associated with the provided key. 
    """
    if not isinstance(key, self.keytype):
        raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))
    if key in self:
        return self[key]
    self[key] = default
    return default

def _map_as_dict(maptype, name, keytype, valuetype):

    maptype.keytype = keytype
    maptype.valuetype = valuetype

    for fctname in ['begin', 'end', 'first', 'second', 'next', \
                        'find', 'insert', 'erase', 'clear', 'size']:
        fct = getattr(_idaapi, name + '_' + fctname)
        setattr(maptype, '__' + fctname, fct)

    maptype.__len__ = maptype.size
    maptype.__getitem__ = maptype.at

    maptype.begin = lambda self, *args: self.__begin(self, *args)
    maptype.end = lambda self, *args: self.__end(self, *args)
    maptype.first = lambda self, *args: self.__first(*args)
    maptype.second = lambda self, *args: self.__second(*args)
    maptype.next = lambda self, *args: self.__next(*args)
    maptype.find = lambda self, *args: self.__find(self, *args)
    maptype.insert = lambda self, *args: self.__insert(self, *args)
    maptype.erase = lambda self, *args: self.__erase(self, *args)
    maptype.clear = lambda self, *args: self.__clear(self, *args)
    maptype.size = lambda self, *args: self.__size(self, *args)
    maptype.__getitem__ = _map___getitem__
    maptype.__setitem__ = _map___setitem__
    maptype.__delitem__ = _map___delitem__
    maptype.__contains__ = _map___contains__
    maptype.clear = _map_clear
    maptype.copy = _map_copy
    maptype.get = _map_get
    maptype.iterkeys = _map_iterkeys
    maptype.itervalues = _map_itervalues
    maptype.iteritems = _map_iteritems
    maptype.keys = _map_keys
    maptype.values = _map_values
    maptype.items = _map_items
    maptype.has_key = _map_has_key
    maptype.pop = _map_pop
    maptype.popitem = _map_popitem
    maptype.setdefault = _map_setdefault

#_map_as_dict(user_labels_t, 'user_labels', (int, long), qstring)
_map_as_dict(user_cmts_t, 'user_cmts', treeloc_t, citem_cmt_t)
_map_as_dict(user_numforms_t, 'user_numforms', operand_locator_t, number_format_t)
_map_as_dict(user_iflags_t, 'user_iflags', citem_locator_t, (int, long))
_map_as_dict(user_unions_t, 'user_unions', (int, long), intvec_t)
_map_as_dict(eamap_t, 'eamap', long, cinsnptrvec_t)
#_map_as_dict(boundaries_t, 'boundaries', cinsn_t, areaset_t)



def qstrvec_t_create(*args):
  """
  qstrvec_t_create() -> PyObject *
  """
  return _idaapi.qstrvec_t_create(*args)

def qstrvec_t_destroy(*args):
  """
  qstrvec_t_destroy(py_obj) -> bool
  """
  return _idaapi.qstrvec_t_destroy(*args)

def qstrvec_t_get_clink(*args):
  """
  qstrvec_t_get_clink(self) -> qstrvec_t *
  """
  return _idaapi.qstrvec_t_get_clink(*args)

def qstrvec_t_get_clink_ptr(*args):
  """
  qstrvec_t_get_clink_ptr(self) -> PyObject *
  """
  return _idaapi.qstrvec_t_get_clink_ptr(*args)

def parse_command_line3(*args):
  """
  parse_command_line3(cmdline) -> PyObject *
  """
  return _idaapi.parse_command_line3(*args)

def get_inf_structure(*args):
  """
  get_inf_structure() -> idainfo


  Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp)
  """
  return _idaapi.get_inf_structure(*args)

def set_script_timeout(*args):
  """
  set_script_timeout(timeout) -> int


  Changes the script timeout value. The script wait box dialog will be hidden and shown again when the timeout elapses.
  See also L{disable_script_timeout}.
  
  @param timeout: This value is in seconds.
                  If this value is set to zero then the script will never timeout.
  @return: Returns the old timeout value
  """
  return _idaapi.set_script_timeout(*args)

def disable_script_timeout(*args):
  """
  disable_script_timeout()


  Disables the script timeout and hides the script wait box.
  Calling L{set_script_timeout} will not have any effects until the script is compiled and executed again
  
  @return: None
  """
  return _idaapi.disable_script_timeout(*args)

def enable_extlang_python(*args):
  """
  enable_extlang_python(enable)


  Enables or disables Python extlang.
  When enabled, all expressions will be evaluated by Python.
  @param enable: Set to True to enable, False otherwise
  """
  return _idaapi.enable_extlang_python(*args)

def enable_python_cli(*args):
  """
  enable_python_cli(enable)
  """
  return _idaapi.enable_python_cli(*args)

def qstrvec_t_assign(*args):
  """
  qstrvec_t_assign(self, other) -> bool
  """
  return _idaapi.qstrvec_t_assign(*args)

def qstrvec_t_addressof(*args):
  """
  qstrvec_t_addressof(self, idx) -> PyObject *
  """
  return _idaapi.qstrvec_t_addressof(*args)

def qstrvec_t_set(*args):
  """
  qstrvec_t_set(self, idx, s) -> bool
  """
  return _idaapi.qstrvec_t_set(*args)

def qstrvec_t_from_list(*args):
  """
  qstrvec_t_from_list(self, py_list) -> bool
  """
  return _idaapi.qstrvec_t_from_list(*args)

def qstrvec_t_size(*args):
  """
  qstrvec_t_size(self) -> size_t
  """
  return _idaapi.qstrvec_t_size(*args)

def qstrvec_t_get(*args):
  """
  qstrvec_t_get(self, idx) -> PyObject *
  """
  return _idaapi.qstrvec_t_get(*args)

def qstrvec_t_add(*args):
  """
  qstrvec_t_add(self, s) -> bool
  """
  return _idaapi.qstrvec_t_add(*args)

def qstrvec_t_clear(*args):
  """
  qstrvec_t_clear(self, qclear) -> bool
  """
  return _idaapi.qstrvec_t_clear(*args)

def qstrvec_t_insert(*args):
  """
  qstrvec_t_insert(self, idx, s) -> bool
  """
  return _idaapi.qstrvec_t_insert(*args)

def qstrvec_t_remove(*args):
  """
  qstrvec_t_remove(self, idx) -> bool
  """
  return _idaapi.qstrvec_t_remove(*args)

def notify_when(*args):
  """
  notify_when(when, py_callable) -> bool


  Register a callback that will be called when an event happens.
  @param when: one of NW_XXXX constants
  @param callback: This callback prototype varies depending on the 'when' parameter:
                   The general callback format:
                       def notify_when_callback(nw_code)
                   In the case of NW_OPENIDB:
                       def notify_when_callback(nw_code, is_old_database)
  @return: Boolean
  """
  return _idaapi.notify_when(*args)
fcb_normal = _idaapi.fcb_normal
fcb_indjump = _idaapi.fcb_indjump
fcb_ret = _idaapi.fcb_ret
fcb_cndret = _idaapi.fcb_cndret
fcb_noret = _idaapi.fcb_noret
fcb_enoret = _idaapi.fcb_enoret
fcb_extern = _idaapi.fcb_extern
fcb_error = _idaapi.fcb_error
class node_iterator(object):
    """
    Proxy of C++ node_iterator class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _g, n) -> node_iterator
        """
        this = _idaapi.new_node_iterator(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, n) -> bool
        """
        return _idaapi.node_iterator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, n) -> bool
        """
        return _idaapi.node_iterator___ne__(self, *args)

    def __ref__(self, *args):
        """
        __ref__(self) -> int
        """
        return _idaapi.node_iterator___ref__(self, *args)

    __swig_destroy__ = _idaapi.delete_node_iterator
    __del__ = lambda self : None;
node_iterator_swigregister = _idaapi.node_iterator_swigregister
node_iterator_swigregister(node_iterator)


def gen_gdl(*args):
  """
  gen_gdl(g, fname)
  """
  return _idaapi.gen_gdl(*args)

def display_gdl(*args):
  """
  display_gdl(fname) -> int
  """
  return _idaapi.display_gdl(*args)

def gen_flow_graph(*args):
  """
  gen_flow_graph(filename, title, pfn, ea1, ea2, gflags) -> bool
  """
  return _idaapi.gen_flow_graph(*args)
CHART_PRINT_NAMES = _idaapi.CHART_PRINT_NAMES
CHART_GEN_DOT = _idaapi.CHART_GEN_DOT
CHART_GEN_GDL = _idaapi.CHART_GEN_GDL
CHART_WINGRAPH = _idaapi.CHART_WINGRAPH

def gen_simple_call_chart(*args):
  """
  gen_simple_call_chart(filename, wait, title, gflags) -> bool
  """
  return _idaapi.gen_simple_call_chart(*args)

def gen_complex_call_chart(*args):
  """
  gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool
  """
  return _idaapi.gen_complex_call_chart(*args)
CHART_NOLIBFUNCS = _idaapi.CHART_NOLIBFUNCS
CHART_REFERENCING = _idaapi.CHART_REFERENCING
CHART_REFERENCED = _idaapi.CHART_REFERENCED
CHART_RECURSIVE = _idaapi.CHART_RECURSIVE
CHART_FOLLOW_DIRECTION = _idaapi.CHART_FOLLOW_DIRECTION
CHART_IGNORE_XTRN = _idaapi.CHART_IGNORE_XTRN
CHART_IGNORE_DATA_BSS = _idaapi.CHART_IGNORE_DATA_BSS
CHART_IGNORE_LIB_TO = _idaapi.CHART_IGNORE_LIB_TO
CHART_IGNORE_LIB_FROM = _idaapi.CHART_IGNORE_LIB_FROM
CHART_PRINT_COMMENTS = _idaapi.CHART_PRINT_COMMENTS
CHART_PRINT_DOTS = _idaapi.CHART_PRINT_DOTS
class qbasic_block_t(area_t):
    """
    Proxy of C++ qbasic_block_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> qbasic_block_t
        """
        this = _idaapi.new_qbasic_block_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_qbasic_block_t
    __del__ = lambda self : None;
qbasic_block_t_swigregister = _idaapi.qbasic_block_t_swigregister
qbasic_block_t_swigregister(qbasic_block_t)


def is_noret_block(*args):
  """
  is_noret_block(btype) -> bool
  """
  return _idaapi.is_noret_block(*args)

def is_ret_block(*args):
  """
  is_ret_block(btype) -> bool
  """
  return _idaapi.is_ret_block(*args)
class qflow_chart_t(object):
    """
    Proxy of C++ qflow_chart_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    title = _swig_property(_idaapi.qflow_chart_t_title_get, _idaapi.qflow_chart_t_title_set)
    bounds = _swig_property(_idaapi.qflow_chart_t_bounds_get, _idaapi.qflow_chart_t_bounds_set)
    pfn = _swig_property(_idaapi.qflow_chart_t_pfn_get, _idaapi.qflow_chart_t_pfn_set)
    flags = _swig_property(_idaapi.qflow_chart_t_flags_get, _idaapi.qflow_chart_t_flags_set)
    nproper = _swig_property(_idaapi.qflow_chart_t_nproper_get, _idaapi.qflow_chart_t_nproper_set)
    def __init__(self, *args):
        """
        __init__(self) -> qflow_chart_t
        __init__(self, _title, _pfn, _ea1, _ea2, _flags) -> qflow_chart_t
        """
        this = _idaapi.new_qflow_chart_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def create(self, *args):
        """
        create(self, _title, _pfn, _ea1, _ea2, _flags)
        create(self, _title, ranges, _flags)
        """
        return _idaapi.qflow_chart_t_create(self, *args)

    def append_to_flowchart(self, *args):
        """
        append_to_flowchart(self, ea1, ea2)
        """
        return _idaapi.qflow_chart_t_append_to_flowchart(self, *args)

    def refresh(self, *args):
        """
        refresh(self)
        """
        return _idaapi.qflow_chart_t_refresh(self, *args)

    def calc_block_type(self, *args):
        """
        calc_block_type(self, blknum) -> fc_block_type_t
        """
        return _idaapi.qflow_chart_t_calc_block_type(self, *args)

    def is_ret_block(self, *args):
        """
        is_ret_block(self, blknum) -> bool
        """
        return _idaapi.qflow_chart_t_is_ret_block(self, *args)

    def is_noret_block(self, *args):
        """
        is_noret_block(self, blknum) -> bool
        """
        return _idaapi.qflow_chart_t_is_noret_block(self, *args)

    def print_node_attributes(self, *args):
        """
        print_node_attributes(self, arg2, arg3)
        """
        return _idaapi.qflow_chart_t_print_node_attributes(self, *args)

    def nsucc(self, *args):
        """
        nsucc(self, node) -> int
        """
        return _idaapi.qflow_chart_t_nsucc(self, *args)

    def npred(self, *args):
        """
        npred(self, node) -> int
        """
        return _idaapi.qflow_chart_t_npred(self, *args)

    def succ(self, *args):
        """
        succ(self, node, i) -> int
        """
        return _idaapi.qflow_chart_t_succ(self, *args)

    def pred(self, *args):
        """
        pred(self, node, i) -> int
        """
        return _idaapi.qflow_chart_t_pred(self, *args)

    def print_names(self, *args):
        """
        print_names(self) -> bool
        """
        return _idaapi.qflow_chart_t_print_names(self, *args)

    def get_node_label(self, *args):
        """
        get_node_label(self, arg2, arg3, arg4) -> char *
        """
        return _idaapi.qflow_chart_t_get_node_label(self, *args)

    def size(self, *args):
        """
        size(self) -> int
        """
        return _idaapi.qflow_chart_t_size(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, n) -> qbasic_block_t
        """
        return _idaapi.qflow_chart_t___getitem__(self, *args)

    __swig_destroy__ = _idaapi.delete_qflow_chart_t
    __del__ = lambda self : None;
qflow_chart_t_swigregister = _idaapi.qflow_chart_t_swigregister
qflow_chart_t_swigregister(qflow_chart_t)
FC_PRINT = _idaapi.FC_PRINT
FC_NOEXT = _idaapi.FC_NOEXT
FC_PREDS = _idaapi.FC_PREDS
FC_APPND = _idaapi.FC_APPND
FC_CHKBREAK = _idaapi.FC_CHKBREAK


def display_flow_graph(*args):
  """
  display_flow_graph(title, pfn, ea1, ea2, print_names) -> bool
  """
  return _idaapi.display_flow_graph(*args)

def display_simple_call_chart(*args):
  """
  display_simple_call_chart(wait, title, ignore_libfuncs) -> bool
  """
  return _idaapi.display_simple_call_chart(*args)

def display_complex_call_chart(*args):
  """
  display_complex_call_chart(wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool
  """
  return _idaapi.display_complex_call_chart(*args)
#<pycode(py_gdl)>
# -----------------------------------------------------------------------
class BasicBlock(object):
    """
    Basic block class. It is returned by the Flowchart class
    """
    def __init__(self, id, bb, fc):
        self._fc = fc

        self.id = id
        """
        Basic block ID
        """

        self.startEA = bb.startEA
        """
        startEA of basic block
        """

        self.endEA = bb.endEA
        """
        endEA of basic block
        """

        self.type  = self._fc._q.calc_block_type(self.id)
        """
        Block type (check fc_block_type_t enum)
        """


    def preds(self):
        """
        Iterates the predecessors list
        """
        q = self._fc._q
        for i in xrange(0, self._fc._q.npred(self.id)):
            yield self._fc[q.pred(self.id, i)]


    def succs(self):
        """
        Iterates the successors list
        """
        q = self._fc._q
        for i in xrange(0, q.nsucc(self.id)):
            yield self._fc[q.succ(self.id, i)]

# -----------------------------------------------------------------------
class FlowChart(object):
    """
    Flowchart class used to determine basic blocks.
    Check ex_gdl_qflow_chart.py for sample usage.
    """
    def __init__(self, f=None, bounds=None, flags=0):
        """
        Constructor
        @param f: A func_t type, use get_func(ea) to get a reference
        @param bounds: A tuple of the form (start, end). Used if "f" is None
        @param flags: one of the FC_xxxx flags. One interesting flag is FC_PREDS
        """
        if (f is None) and (bounds is None or type(bounds) != types.TupleType):
            raise Exception("Please specifiy either a function or start/end pair")

        if bounds is None:
            bounds = (BADADDR, BADADDR)

        # Create the flowchart
        self._q = qflow_chart_t("", f, bounds[0], bounds[1], flags)

    size = property(lambda self: self._q.size())
    """
    Number of blocks in the flow chart
    """


    def refresh():
        """
        Refreshes the flow chart
        """
        self._q.refresh()


    def _getitem(self, index):
        return BasicBlock(index, self._q[index], self)


    def __iter__(self):
        return (self._getitem(index) for index in xrange(0, self.size))


    def __getitem__(self, index):
        """
        Returns a basic block

        @return: BasicBlock
        """
        if index >= self.size:
            raise KeyError
        else:
            return self._getitem(index)

#</pycode(py_gdl)>


def refresh_lists(*args):
  """
  refresh_lists()
  """
  return _idaapi.refresh_lists(*args)

def textctrl_info_t_create(*args):
  """
  textctrl_info_t_create() -> PyObject *
  """
  return _idaapi.textctrl_info_t_create(*args)

def textctrl_info_t_destroy(*args):
  """
  textctrl_info_t_destroy(py_obj) -> bool
  """
  return _idaapi.textctrl_info_t_destroy(*args)

def textctrl_info_t_get_clink(*args):
  """
  textctrl_info_t_get_clink(self) -> textctrl_info_t *
  """
  return _idaapi.textctrl_info_t_get_clink(*args)

def textctrl_info_t_get_clink_ptr(*args):
  """
  textctrl_info_t_get_clink_ptr(self) -> PyObject *
  """
  return _idaapi.textctrl_info_t_get_clink_ptr(*args)

def register_timer(*args):
  """
  register_timer(interval, py_callback) -> PyObject *


  Register a timer
  
  @param interval: Interval in milliseconds
  @param callback: A Python callable that takes no parameters and returns an integer.
                   The callback may return:
                   -1   : to unregister the timer
                   >= 0 : the new or same timer interval
  @return: None or a timer object
  """
  return _idaapi.register_timer(*args)

def unregister_timer(*args):
  """
  unregister_timer(py_timerctx) -> PyObject *


  Unregister a timer
  
  @param timer_obj: a timer object previously returned by a register_timer()
  @return: Boolean
  @note: After the timer has been deleted, the timer_obj will become invalid.
  """
  return _idaapi.unregister_timer(*args)

def choose_idasgn(*args):
  """
  choose_idasgn() -> PyObject *


  Opens the signature chooser
  
  @return: None or the selected signature name
  """
  return _idaapi.choose_idasgn(*args)

def get_highlighted_identifier(*args):
  """
  get_highlighted_identifier(flags=0) -> PyObject *


  Returns the currently highlighted identifier
  
  @param flags: reserved (pass 0)
  @return: None or the highlighted identifier
  """
  return _idaapi.get_highlighted_identifier(*args)

def py_load_custom_icon_fn(*args):
  """
  py_load_custom_icon_fn(filename) -> int
  """
  return _idaapi.py_load_custom_icon_fn(*args)

def py_load_custom_icon_data(*args):
  """
  py_load_custom_icon_data(data, format) -> int
  """
  return _idaapi.py_load_custom_icon_data(*args)

def umsg(*args):
  """
  umsg(o) -> PyObject *


  Prints text into IDA's Output window
  
  @param text: text to print
               Can be Unicode, or string in UTF-8 encoding
  @return: number of bytes printed
  """
  return _idaapi.umsg(*args)

def msg(*args):
  """
  msg(o) -> PyObject *


  Prints text into IDA's Output window
  
  @param text: text to print
               Can be Unicode, or string in local encoding
  @return: number of bytes printed
  """
  return _idaapi.msg(*args)

def asktext(*args):
  """
  asktext(max_text, defval, prompt) -> PyObject *


  Asks for a long text
  
  @param max_text: Maximum text length
  @param defval: The default value
  @param prompt: The prompt value
  @return: None or the entered string
  """
  return _idaapi.asktext(*args)

def str2ea(*args):
  """
  str2ea(str, screenEA=BADADDR) -> ea_t


  Converts a string express to EA. The expression evaluator may be called as well.
  
  @return: BADADDR or address value
  """
  return _idaapi.str2ea(*args)

def str2user(*args):
  """
  str2user(str) -> PyObject *


  Insert C-style escape characters to string
  
  @return: new string with escape characters inserted
  """
  return _idaapi.str2user(*args)

def process_ui_action(*args):
  """
  process_ui_action(name, flags=0) -> bool


  Invokes an IDA UI action by name
  
  @param name:  action name
  @return: Boolean
  """
  return _idaapi.process_ui_action(*args)

def del_menu_item(*args):
  """
  del_menu_item(py_ctx) -> bool


  Deprecated. Use detach_menu_item()/unregister_action() instead.
  """
  return _idaapi.del_menu_item(*args)

def del_hotkey(*args):
  """
  del_hotkey(pyctx) -> bool


  Deletes a previously registered function hotkey
  
  @param ctx: Hotkey context previously returned by add_hotkey()
  
  @return: Boolean.
  """
  return _idaapi.del_hotkey(*args)

def add_hotkey(*args):
  """
  add_hotkey(hotkey, pyfunc) -> PyObject *


  Associates a function call with a hotkey.
  Callable pyfunc will be called each time the hotkey is pressed
  
  @param hotkey: The hotkey
  @param pyfunc: Callable
  
  @return: Context object on success or None on failure.
  """
  return _idaapi.add_hotkey(*args)

def py_menu_item_callback(*args):
  """
  py_menu_item_callback(userdata) -> bool
  """
  return _idaapi.py_menu_item_callback(*args)

def add_menu_item(*args):
  """
  add_menu_item(menupath, name, hotkey, flags, pyfunc, args) -> PyObject *


  Deprecated. Use register_action()/attach_menu_item() instead.
  """
  return _idaapi.add_menu_item(*args)

def execute_sync(*args):
  """
  execute_sync(py_callable, reqf) -> int


  Executes a function in the context of the main thread.
  If the current thread not the main thread, then the call is queued and
  executed afterwards.
  
  @note: The Python version of execute_sync() cannot be called from a different thread
         for the time being.
  @param callable: A python callable object
  @param reqf: one of MFF_ flags
  @return: -1 or the return value of the callable
  """
  return _idaapi.execute_sync(*args)

def execute_ui_requests(*args):
  """
  execute_ui_requests(py_list) -> bool


  Inserts a list of callables into the UI message processing queue.
  When the UI is ready it will call one callable.
  A callable can request to be called more than once if it returns True.
  
  @param callable_list: A list of python callable objects.
  @note: A callable should return True if it wants to be called more than once.
  @return: Boolean. False if the list contains a non callabale item
  """
  return _idaapi.execute_ui_requests(*args)
class UI_Hooks(object):
    """
    Proxy of C++ UI_Hooks class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _idaapi.delete_UI_Hooks
    __del__ = lambda self : None;
    def hook(self, *args):
        """
        hook(self) -> bool


        Creates an UI hook
        
        @return: Boolean true on success
        """
        return _idaapi.UI_Hooks_hook(self, *args)

    def unhook(self, *args):
        """
        unhook(self) -> bool


        Removes the UI hook
        @return: Boolean true on success
        """
        return _idaapi.UI_Hooks_unhook(self, *args)

    def preprocess(self, *args):
        """
        preprocess(self, arg0) -> int


        IDA ui is about to handle a user command
        
        @param name: ui command name
                     (these names can be looked up in ida[tg]ui.cfg)
        @return: 0-ok, nonzero - a plugin has handled the command
        """
        return _idaapi.UI_Hooks_preprocess(self, *args)

    def postprocess(self, *args):
        """
        postprocess(self)


        An ida ui command has been handled
        
        @return: Ignored
        """
        return _idaapi.UI_Hooks_postprocess(self, *args)

    def saving(self, *args):
        """
        saving(self)


        The kernel is saving the database.
        
        @return: Ignored
        """
        return _idaapi.UI_Hooks_saving(self, *args)

    def saved(self, *args):
        """
        saved(self)


        The kernel has saved the database.
        
        @return: Ignored
        """
        return _idaapi.UI_Hooks_saved(self, *args)

    def term(self, *args):
        """
        term(self)


        IDA is terminated and the database is already closed.
        The UI may close its windows in this callback.
        """
        return _idaapi.UI_Hooks_term(self, *args)

    def get_ea_hint(self, *args):
        """
        get_ea_hint(self, arg0) -> PyObject *


        The UI wants to display a simple hint for an address in the navigation band
        
        @param ea: The address
        @return: String with the hint or None
        """
        return _idaapi.UI_Hooks_get_ea_hint(self, *args)

    def current_tform_changed(self, *args):
        """
        current_tform_changed(self, arg0, arg1)
        """
        return _idaapi.UI_Hooks_current_tform_changed(self, *args)

    def updating_actions(self, *args):
        """
        updating_actions(self, ctx)


        The UI is about to batch-update some actions.
        
        @param ctx: The action_update_ctx_t instance
        @return: Ignored
        """
        return _idaapi.UI_Hooks_updating_actions(self, *args)

    def updated_actions(self, *args):
        """
        updated_actions(self)


        The UI is done updating actions.
        
        @return: Ignored
        """
        return _idaapi.UI_Hooks_updated_actions(self, *args)

    def populating_tform_popup(self, *args):
        """
        populating_tform_popup(self, arg0, arg1)


        The UI is populating the TForm's popup menu.
        Now is a good time to call idaapi.attach_action_to_popup()
        
        @param form: The form
        @param popup: The popup menu.
        @return: Ignored
        """
        return _idaapi.UI_Hooks_populating_tform_popup(self, *args)

    def finish_populating_tform_popup(self, *args):
        """
        finish_populating_tform_popup(self, arg0, arg1)


        The UI is about to be done populating the TForm's popup menu.
        Now is a good time to call idaapi.attach_action_to_popup()
        
        @param form: The form
        @param popup: The popup menu.
        @return: Ignored
        """
        return _idaapi.UI_Hooks_finish_populating_tform_popup(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> UI_Hooks
        """
        if self.__class__ == UI_Hooks:
            _self = None
        else:
            _self = self
        this = _idaapi.new_UI_Hooks(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _idaapi.disown_UI_Hooks(self)
        return weakref_proxy(self)
UI_Hooks_swigregister = _idaapi.UI_Hooks_swigregister
UI_Hooks_swigregister(UI_Hooks)


def register_action(*args):
  """
  register_action(desc) -> bool
  """
  return _idaapi.register_action(*args)

def unregister_action(*args):
  """
  unregister_action(name) -> bool
  """
  return _idaapi.unregister_action(*args)

def attach_dynamic_action_to_popup(*args):
  """
  attach_dynamic_action_to_popup(form, popup_handle, desc, popuppath=None, flags=0) -> bool
  """
  return _idaapi.attach_dynamic_action_to_popup(*args)
class disasm_line_t(object):
    """
    Proxy of C++ disasm_line_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _idaapi.delete_disasm_line_t
    __del__ = lambda self : None;
    def __init__(self, *args):
        """
        __init__(self) -> disasm_line_t
        __init__(self, other) -> disasm_line_t
        """
        this = _idaapi.new_disasm_line_t(*args)
        try: self.this.append(this)
        except: self.this = this
    at = _swig_property(_idaapi.disasm_line_t_at_get, _idaapi.disasm_line_t_at_set)
    line = _swig_property(_idaapi.disasm_line_t_line_get, _idaapi.disasm_line_t_line_set)
    prefix_color = _swig_property(_idaapi.disasm_line_t_prefix_color_get, _idaapi.disasm_line_t_prefix_color_set)
    bg_color = _swig_property(_idaapi.disasm_line_t_bg_color_get, _idaapi.disasm_line_t_bg_color_set)
    is_default = _swig_property(_idaapi.disasm_line_t_is_default_get, _idaapi.disasm_line_t_is_default_set)
disasm_line_t_swigregister = _idaapi.disasm_line_t_swigregister
disasm_line_t_swigregister(disasm_line_t)


def gen_disasm_text(*args):
  """
  gen_disasm_text(ea1, ea2, text, truncate_lines)
  """
  return _idaapi.gen_disasm_text(*args)

def set_nav_colorizer(*args):
  """
  set_nav_colorizer(new_py_colorizer) -> nav_colorizer_t *


  Set a new colorizer for the navigation band.
  
  The 'callback' is a function of 2 arguments:
     - ea (the EA to colorize for)
     - nbytes (the number of bytes at that EA)
  and must return a 'long' value.
  
  The previous colorizer is returned, allowing
  the new 'callback' to use 'call_nav_colorizer'
  with it.
  
  Note that the previous colorizer is returned
  only the first time set_nav_colorizer() is called:
  due to the way the colorizers API is defined in C,
  it is impossible to chain more than 2 colorizers
  in IDAPython: the original, IDA-provided colorizer,
  and a user-provided one.
  
  Example: colorizer inverting the color provided by the IDA colorizer:
      def my_colorizer(ea, nbytes):
          global ida_colorizer
          orig = idaapi.call_nav_colorizer(ida_colorizer, ea, nbytes)
          return long(~orig)
  
      ida_colorizer = idaapi.set_nav_colorizer(my_colorizer)
  """
  return _idaapi.set_nav_colorizer(*args)

def call_nav_colorizer(*args):
  """
  call_nav_colorizer(col, ea, nbytes) -> uint32


  To be used with the IDA-provided colorizer, that is
  returned as result of the first call to set_nav_colorizer().
  
  This is a trivial trampoline, so that SWIG can generate a
  wrapper that will do the types checking.
  """
  return _idaapi.call_nav_colorizer(*args)

def choose_sizer(*args):
  """
  choose_sizer(self) -> uint32
  """
  return _idaapi.choose_sizer(*args)

def choose_getl(*args):
  """
  choose_getl(self, n, buf) -> char *
  """
  return _idaapi.choose_getl(*args)

def choose_enter(*args):
  """
  choose_enter(self, n)
  """
  return _idaapi.choose_enter(*args)

def choose2_find(*args):
  """
  choose2_find(title) -> PyObject *
  """
  return _idaapi.choose2_find(*args)

def choose2_add_command(*args):
  """
  choose2_add_command(self, caption, flags, menu_index, icon) -> int
  """
  return _idaapi.choose2_add_command(*args)

def choose2_refresh(*args):
  """
  choose2_refresh(self)
  """
  return _idaapi.choose2_refresh(*args)

def choose2_close(*args):
  """
  choose2_close(self)
  """
  return _idaapi.choose2_close(*args)

def choose2_create(*args):
  """
  choose2_create(self, embedded) -> int
  """
  return _idaapi.choose2_create(*args)

def choose2_activate(*args):
  """
  choose2_activate(self)
  """
  return _idaapi.choose2_activate(*args)

def choose2_get_embedded(*args):
  """
  choose2_get_embedded(self) -> PyObject *
  """
  return _idaapi.choose2_get_embedded(*args)

def choose2_get_embedded_selection(*args):
  """
  choose2_get_embedded_selection(self) -> PyObject *
  """
  return _idaapi.choose2_get_embedded_selection(*args)

def textctrl_info_t_assign(*args):
  """
  textctrl_info_t_assign(self, other) -> bool
  """
  return _idaapi.textctrl_info_t_assign(*args)

def textctrl_info_t_set_text(*args):
  """
  textctrl_info_t_set_text(self, s) -> bool
  """
  return _idaapi.textctrl_info_t_set_text(*args)

def textctrl_info_t_get_text(*args):
  """
  textctrl_info_t_get_text(self) -> char const *
  """
  return _idaapi.textctrl_info_t_get_text(*args)

def textctrl_info_t_set_flags(*args):
  """
  textctrl_info_t_set_flags(self, flags) -> bool
  """
  return _idaapi.textctrl_info_t_set_flags(*args)

def textctrl_info_t_get_flags(*args):
  """
  textctrl_info_t_get_flags(self, flags) -> unsigned int
  """
  return _idaapi.textctrl_info_t_get_flags(*args)

def textctrl_info_t_set_tabsize(*args):
  """
  textctrl_info_t_set_tabsize(self, tabsize) -> bool
  """
  return _idaapi.textctrl_info_t_set_tabsize(*args)

def textctrl_info_t_get_tabsize(*args):
  """
  textctrl_info_t_get_tabsize(self, tabsize) -> unsigned int
  """
  return _idaapi.textctrl_info_t_get_tabsize(*args)

def formchgcbfa_enable_field(*args):
  """
  formchgcbfa_enable_field(p_fa, fid, enable) -> bool
  """
  return _idaapi.formchgcbfa_enable_field(*args)

def formchgcbfa_show_field(*args):
  """
  formchgcbfa_show_field(p_fa, fid, show) -> bool
  """
  return _idaapi.formchgcbfa_show_field(*args)

def formchgcbfa_move_field(*args):
  """
  formchgcbfa_move_field(p_fa, fid, x, y, w, h) -> bool
  """
  return _idaapi.formchgcbfa_move_field(*args)

def formchgcbfa_get_focused_field(*args):
  """
  formchgcbfa_get_focused_field(p_fa) -> int
  """
  return _idaapi.formchgcbfa_get_focused_field(*args)

def formchgcbfa_set_focused_field(*args):
  """
  formchgcbfa_set_focused_field(p_fa, fid) -> bool
  """
  return _idaapi.formchgcbfa_set_focused_field(*args)

def formchgcbfa_refresh_field(*args):
  """
  formchgcbfa_refresh_field(p_fa, fid)
  """
  return _idaapi.formchgcbfa_refresh_field(*args)

def formchgcbfa_close(*args):
  """
  formchgcbfa_close(p_fa, close_normally)
  """
  return _idaapi.formchgcbfa_close(*args)

def formchgcbfa_get_field_value(*args):
  """
  formchgcbfa_get_field_value(p_fa, fid, ft, sz) -> PyObject *
  """
  return _idaapi.formchgcbfa_get_field_value(*args)

def formchgcbfa_set_field_value(*args):
  """
  formchgcbfa_set_field_value(p_fa, fid, ft, py_val) -> bool
  """
  return _idaapi.formchgcbfa_set_field_value(*args)

def py_get_AskUsingForm(*args):
  """
  py_get_AskUsingForm() -> size_t
  """
  return _idaapi.py_get_AskUsingForm(*args)

def py_get_OpenForm(*args):
  """
  py_get_OpenForm() -> size_t
  """
  return _idaapi.py_get_OpenForm(*args)

def py_register_compiled_form(*args):
  """
  py_register_compiled_form(py_form)
  """
  return _idaapi.py_register_compiled_form(*args)

def py_unregister_compiled_form(*args):
  """
  py_unregister_compiled_form(py_form)
  """
  return _idaapi.py_unregister_compiled_form(*args)

def plgform_new(*args):
  """
  plgform_new() -> PyObject *
  """
  return _idaapi.plgform_new(*args)

def plgform_show(*args):
  """
  plgform_show(py_link, py_obj, caption, options=FORM_TAB|FORM_MENU|FORM_RESTORE) -> bool
  """
  return _idaapi.plgform_show(*args)

def plgform_close(*args):
  """
  plgform_close(py_link, options)
  """
  return _idaapi.plgform_close(*args)

def install_command_interpreter(*args):
  """
  install_command_interpreter(py_obj) -> int
  """
  return _idaapi.install_command_interpreter(*args)

def remove_command_interpreter(*args):
  """
  remove_command_interpreter(cli_idx)
  """
  return _idaapi.remove_command_interpreter(*args)

def pyscv_init(*args):
  """
  pyscv_init(py_link, title) -> PyObject *
  """
  return _idaapi.pyscv_init(*args)

def pyscv_refresh(*args):
  """
  pyscv_refresh(py_this) -> bool
  """
  return _idaapi.pyscv_refresh(*args)

def pyscv_delete(*args):
  """
  pyscv_delete(py_this) -> bool
  """
  return _idaapi.pyscv_delete(*args)

def pyscv_refresh_current(*args):
  """
  pyscv_refresh_current(py_this) -> bool
  """
  return _idaapi.pyscv_refresh_current(*args)

def pyscv_get_current_line(*args):
  """
  pyscv_get_current_line(py_this, mouse, notags) -> PyObject *
  """
  return _idaapi.pyscv_get_current_line(*args)

def pyscv_is_focused(*args):
  """
  pyscv_is_focused(py_this) -> bool
  """
  return _idaapi.pyscv_is_focused(*args)

def pyscv_clear_popup_menu(*args):
  """
  pyscv_clear_popup_menu(py_this)
  """
  return _idaapi.pyscv_clear_popup_menu(*args)

def pyscv_add_popup_menu(*args):
  """
  pyscv_add_popup_menu(py_this, title, hotkey) -> size_t
  """
  return _idaapi.pyscv_add_popup_menu(*args)

def pyscv_count(*args):
  """
  pyscv_count(py_this) -> size_t
  """
  return _idaapi.pyscv_count(*args)

def pyscv_show(*args):
  """
  pyscv_show(py_this) -> bool
  """
  return _idaapi.pyscv_show(*args)

def pyscv_close(*args):
  """
  pyscv_close(py_this)
  """
  return _idaapi.pyscv_close(*args)

def pyscv_jumpto(*args):
  """
  pyscv_jumpto(py_this, ln, x, y) -> bool
  """
  return _idaapi.pyscv_jumpto(*args)

def pyscv_get_line(*args):
  """
  pyscv_get_line(py_this, nline) -> PyObject *
  """
  return _idaapi.pyscv_get_line(*args)

def pyscv_get_pos(*args):
  """
  pyscv_get_pos(py_this, mouse) -> PyObject *
  """
  return _idaapi.pyscv_get_pos(*args)

def pyscv_clear_lines(*args):
  """
  pyscv_clear_lines(py_this) -> PyObject *
  """
  return _idaapi.pyscv_clear_lines(*args)

def pyscv_add_line(*args):
  """
  pyscv_add_line(py_this, py_sl) -> bool
  """
  return _idaapi.pyscv_add_line(*args)

def pyscv_insert_line(*args):
  """
  pyscv_insert_line(py_this, nline, py_sl) -> bool
  """
  return _idaapi.pyscv_insert_line(*args)

def pyscv_patch_line(*args):
  """
  pyscv_patch_line(py_this, nline, offs, value) -> bool
  """
  return _idaapi.pyscv_patch_line(*args)

def pyscv_del_line(*args):
  """
  pyscv_del_line(py_this, nline) -> bool
  """
  return _idaapi.pyscv_del_line(*args)

def pyscv_get_selection(*args):
  """
  pyscv_get_selection(py_this) -> PyObject *
  """
  return _idaapi.pyscv_get_selection(*args)

def pyscv_get_current_word(*args):
  """
  pyscv_get_current_word(py_this, mouse) -> PyObject *
  """
  return _idaapi.pyscv_get_current_word(*args)

def pyscv_edit_line(*args):
  """
  pyscv_edit_line(py_this, nline, py_sl) -> bool
  """
  return _idaapi.pyscv_edit_line(*args)

def pyscv_get_tform(*args):
  """
  pyscv_get_tform(py_this) -> TForm *
  """
  return _idaapi.pyscv_get_tform(*args)

def pyscv_get_tcustom_control(*args):
  """
  pyscv_get_tcustom_control(py_this) -> TCustomControl *
  """
  return _idaapi.pyscv_get_tcustom_control(*args)
mbox_internal = _idaapi.mbox_internal
mbox_info = _idaapi.mbox_info
mbox_warning = _idaapi.mbox_warning
mbox_error = _idaapi.mbox_error
mbox_nomem = _idaapi.mbox_nomem
mbox_feedback = _idaapi.mbox_feedback
mbox_readerror = _idaapi.mbox_readerror
mbox_writeerror = _idaapi.mbox_writeerror
mbox_filestruct = _idaapi.mbox_filestruct
mbox_wait = _idaapi.mbox_wait
mbox_hide = _idaapi.mbox_hide
mbox_replace = _idaapi.mbox_replace
chtype_generic = _idaapi.chtype_generic
chtype_idasgn = _idaapi.chtype_idasgn
chtype_entry = _idaapi.chtype_entry
chtype_name = _idaapi.chtype_name
chtype_stkvar_xref = _idaapi.chtype_stkvar_xref
chtype_xref = _idaapi.chtype_xref
chtype_enum = _idaapi.chtype_enum
chtype_enum_by_value = _idaapi.chtype_enum_by_value
chtype_func = _idaapi.chtype_func
chtype_segm = _idaapi.chtype_segm
chtype_segreg = _idaapi.chtype_segreg
chtype_struc = _idaapi.chtype_struc
chtype_strpath = _idaapi.chtype_strpath
chtype_generic2 = _idaapi.chtype_generic2
chtype_idatil = _idaapi.chtype_idatil
chtype_enum_by_value_and_size = _idaapi.chtype_enum_by_value_and_size
chtype_srcp = _idaapi.chtype_srcp
beep_default = _idaapi.beep_default
TCCRT_INVALID = _idaapi.TCCRT_INVALID
TCCRT_FLAT = _idaapi.TCCRT_FLAT
TCCRT_GRAPH = _idaapi.TCCRT_GRAPH
TCCRT_PROXIMITY = _idaapi.TCCRT_PROXIMITY
TCCPT_INVALID = _idaapi.TCCPT_INVALID
TCCPT_PLACE = _idaapi.TCCPT_PLACE
TCCPT_SIMPLELINE_PLACE = _idaapi.TCCPT_SIMPLELINE_PLACE
TCCPT_IDAPLACE = _idaapi.TCCPT_IDAPLACE
TCCPT_ENUMPLACE = _idaapi.TCCPT_ENUMPLACE
TCCPT_STRUCTPLACE = _idaapi.TCCPT_STRUCTPLACE
VME_UNKNOWN = _idaapi.VME_UNKNOWN
VME_LEFT_BUTTON = _idaapi.VME_LEFT_BUTTON
VME_RIGHT_BUTTON = _idaapi.VME_RIGHT_BUTTON
VME_MID_BUTTON = _idaapi.VME_MID_BUTTON
SETMENU_POSMASK = _idaapi.SETMENU_POSMASK
SETMENU_INS = _idaapi.SETMENU_INS
SETMENU_APP = _idaapi.SETMENU_APP
KERNEL_VERSION_MAGIC1 = _idaapi.KERNEL_VERSION_MAGIC1
KERNEL_VERSION_MAGIC2 = _idaapi.KERNEL_VERSION_MAGIC2

def get_kernel_version(*args):
  """
  get_kernel_version() -> bool
  """
  return _idaapi.get_kernel_version(*args)
class place_t(object):
    """
    Proxy of C++ place_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    lnnum = _swig_property(_idaapi.place_t_lnnum_get, _idaapi.place_t_lnnum_set)
    def _print(self, *args):
        """
        _print(self, ud, out_buf, bufsize)
        """
        return _idaapi.place_t__print(self, *args)

    def touval(self, *args):
        """
        touval(self, ud) -> uval_t
        """
        return _idaapi.place_t_touval(self, *args)

    def clone(self, *args):
        """
        clone(self) -> place_t
        """
        return _idaapi.place_t_clone(self, *args)

    def copyfrom(self, *args):
        """
        copyfrom(self, frm)
        """
        return _idaapi.place_t_copyfrom(self, *args)

    def makeplace(self, *args):
        """
        makeplace(self, ud, x, lnnum) -> place_t
        """
        return _idaapi.place_t_makeplace(self, *args)

    def compare(self, *args):
        """
        compare(self, t2) -> int
        """
        return _idaapi.place_t_compare(self, *args)

    def adjust(self, *args):
        """
        adjust(self, ud)
        """
        return _idaapi.place_t_adjust(self, *args)

    def prev(self, *args):
        """
        prev(self, ud) -> bool
        """
        return _idaapi.place_t_prev(self, *args)

    def next(self, *args):
        """
        next(self, ud) -> bool
        """
        return _idaapi.place_t_next(self, *args)

    def beginning(self, *args):
        """
        beginning(self, ud) -> bool
        """
        return _idaapi.place_t_beginning(self, *args)

    def ending(self, *args):
        """
        ending(self, ud) -> bool
        """
        return _idaapi.place_t_ending(self, *args)

    def generate(self, *args):
        """
        generate(self, ud, lines, maxsize, default_lnnum, pfx_color, bgcolor) -> int
        """
        return _idaapi.place_t_generate(self, *args)

    def as_idaplace_t(*args):
        """
        as_idaplace_t(p) -> idaplace_t
        """
        return _idaapi.place_t_as_idaplace_t(*args)

    as_idaplace_t = staticmethod(as_idaplace_t)
    def as_enumplace_t(*args):
        """
        as_enumplace_t(p) -> enumplace_t
        """
        return _idaapi.place_t_as_enumplace_t(*args)

    as_enumplace_t = staticmethod(as_enumplace_t)
    def as_structplace_t(*args):
        """
        as_structplace_t(p) -> structplace_t
        """
        return _idaapi.place_t_as_structplace_t(*args)

    as_structplace_t = staticmethod(as_structplace_t)
    def as_simpleline_place_t(*args):
        """
        as_simpleline_place_t(p) -> simpleline_place_t
        """
        return _idaapi.place_t_as_simpleline_place_t(*args)

    as_simpleline_place_t = staticmethod(as_simpleline_place_t)
    __swig_destroy__ = _idaapi.delete_place_t
    __del__ = lambda self : None;
place_t_swigregister = _idaapi.place_t_swigregister
place_t_swigregister(place_t)

def place_t_as_idaplace_t(*args):
  """
  place_t_as_idaplace_t(p) -> idaplace_t
  """
  return _idaapi.place_t_as_idaplace_t(*args)

def place_t_as_enumplace_t(*args):
  """
  place_t_as_enumplace_t(p) -> enumplace_t
  """
  return _idaapi.place_t_as_enumplace_t(*args)

def place_t_as_structplace_t(*args):
  """
  place_t_as_structplace_t(p) -> structplace_t
  """
  return _idaapi.place_t_as_structplace_t(*args)

def place_t_as_simpleline_place_t(*args):
  """
  place_t_as_simpleline_place_t(p) -> simpleline_place_t
  """
  return _idaapi.place_t_as_simpleline_place_t(*args)

class simpleline_t(object):
    """
    Proxy of C++ simpleline_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    line = _swig_property(_idaapi.simpleline_t_line_get, _idaapi.simpleline_t_line_set)
    color = _swig_property(_idaapi.simpleline_t_color_get, _idaapi.simpleline_t_color_set)
    bgcolor = _swig_property(_idaapi.simpleline_t_bgcolor_get, _idaapi.simpleline_t_bgcolor_set)
    def __init__(self, *args):
        """
        __init__(self) -> simpleline_t
        __init__(self, c, str) -> simpleline_t
        __init__(self, str) -> simpleline_t
        __init__(self, str) -> simpleline_t
        """
        this = _idaapi.new_simpleline_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_simpleline_t
    __del__ = lambda self : None;
simpleline_t_swigregister = _idaapi.simpleline_t_swigregister
simpleline_t_swigregister(simpleline_t)

class simpleline_place_t(place_t):
    """
    Proxy of C++ simpleline_place_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    n = _swig_property(_idaapi.simpleline_place_t_n_get, _idaapi.simpleline_place_t_n_set)
    __swig_destroy__ = _idaapi.delete_simpleline_place_t
    __del__ = lambda self : None;
simpleline_place_t_swigregister = _idaapi.simpleline_place_t_swigregister
simpleline_place_t_swigregister(simpleline_place_t)

class idaplace_t(place_t):
    """
    Proxy of C++ idaplace_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.idaplace_t_ea_get, _idaapi.idaplace_t_ea_set)
    __swig_destroy__ = _idaapi.delete_idaplace_t
    __del__ = lambda self : None;
idaplace_t_swigregister = _idaapi.idaplace_t_swigregister
idaplace_t_swigregister(idaplace_t)

class enumplace_t(place_t):
    """
    Proxy of C++ enumplace_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    idx = _swig_property(_idaapi.enumplace_t_idx_get, _idaapi.enumplace_t_idx_set)
    bmask = _swig_property(_idaapi.enumplace_t_bmask_get, _idaapi.enumplace_t_bmask_set)
    value = _swig_property(_idaapi.enumplace_t_value_get, _idaapi.enumplace_t_value_set)
    serial = _swig_property(_idaapi.enumplace_t_serial_get, _idaapi.enumplace_t_serial_set)
    __swig_destroy__ = _idaapi.delete_enumplace_t
    __del__ = lambda self : None;
enumplace_t_swigregister = _idaapi.enumplace_t_swigregister
enumplace_t_swigregister(enumplace_t)

class structplace_t(place_t):
    """
    Proxy of C++ structplace_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    idx = _swig_property(_idaapi.structplace_t_idx_get, _idaapi.structplace_t_idx_set)
    offset = _swig_property(_idaapi.structplace_t_offset_get, _idaapi.structplace_t_offset_set)
    __swig_destroy__ = _idaapi.delete_structplace_t
    __del__ = lambda self : None;
structplace_t_swigregister = _idaapi.structplace_t_swigregister
structplace_t_swigregister(structplace_t)

class twinpos_t(object):
    """
    Proxy of C++ twinpos_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    at = _swig_property(_idaapi.twinpos_t_at_get, _idaapi.twinpos_t_at_set)
    x = _swig_property(_idaapi.twinpos_t_x_get, _idaapi.twinpos_t_x_set)
    def __init__(self, *args):
        """
        __init__(self) -> twinpos_t
        __init__(self, t) -> twinpos_t
        __init__(self, t, x0) -> twinpos_t
        """
        this = _idaapi.new_twinpos_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.twinpos_t___ne__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.twinpos_t___eq__(self, *args)

    def place_as_idaplace_t(self):
        return place_t.as_idaplace_t(self.at)
    def place_as_enumplace_t(self):
        return place_t.as_enumplace_t(self.at)
    def place_as_structplace_t(self):
        return place_t.as_structplace_t(self.at)
    def place_as_simpleline_place_t(self):
        return place_t.as_simpleline_place_t(self.at)

    def place(self, view):
        ptype = get_viewer_place_type(view)
        if ptype == TCCPT_IDAPLACE:
            return self.place_as_idaplace_t()
        elif ptype == TCCPT_ENUMPLACE:
            return self.place_as_enumplace_t()
        elif ptype == TCCPT_STRUCTPLACE:
            return self.place_as_structplace_t()
        elif ptype == TCCPT_SIMPLELINE_PLACE:
            return self.place_as_simpleline_place_t()
        else:
            return self.at

    __swig_destroy__ = _idaapi.delete_twinpos_t
    __del__ = lambda self : None;
twinpos_t_swigregister = _idaapi.twinpos_t_swigregister
twinpos_t_swigregister(twinpos_t)


def request_refresh(*args):
  """
  request_refresh(mask)
  """
  return _idaapi.request_refresh(*args)
BWN_UNKNOWN = _idaapi.BWN_UNKNOWN
BWN_EXPORTS = _idaapi.BWN_EXPORTS
BWN_IMPORTS = _idaapi.BWN_IMPORTS
BWN_NAMES = _idaapi.BWN_NAMES
BWN_FUNCS = _idaapi.BWN_FUNCS
BWN_STRINGS = _idaapi.BWN_STRINGS
BWN_SEGS = _idaapi.BWN_SEGS
BWN_SEGREGS = _idaapi.BWN_SEGREGS
BWN_SELS = _idaapi.BWN_SELS
BWN_SIGNS = _idaapi.BWN_SIGNS
BWN_TILS = _idaapi.BWN_TILS
BWN_LOCTYPS = _idaapi.BWN_LOCTYPS
BWN_CALLS = _idaapi.BWN_CALLS
BWN_PROBS = _idaapi.BWN_PROBS
BWN_BPTS = _idaapi.BWN_BPTS
BWN_THREADS = _idaapi.BWN_THREADS
BWN_MODULES = _idaapi.BWN_MODULES
BWN_TRACE = _idaapi.BWN_TRACE
BWN_CALL_STACK = _idaapi.BWN_CALL_STACK
BWN_XREFS = _idaapi.BWN_XREFS
BWN_SEARCH = _idaapi.BWN_SEARCH
BWN_FRAME = _idaapi.BWN_FRAME
BWN_NAVBAND = _idaapi.BWN_NAVBAND
BWN_ENUMS = _idaapi.BWN_ENUMS
BWN_STRUCTS = _idaapi.BWN_STRUCTS
BWN_DISASM = _idaapi.BWN_DISASM
BWN_DUMP = _idaapi.BWN_DUMP
BWN_NOTEPAD = _idaapi.BWN_NOTEPAD
BWN_OUTPUT = _idaapi.BWN_OUTPUT
BWN_CLI = _idaapi.BWN_CLI
BWN_WATCH = _idaapi.BWN_WATCH
BWN_LOCALS = _idaapi.BWN_LOCALS
BWN_STKVIEW = _idaapi.BWN_STKVIEW
BWN_CHOOSER = _idaapi.BWN_CHOOSER
BWN_SHORTCUTCSR = _idaapi.BWN_SHORTCUTCSR
BWN_SHORTCUTWIN = _idaapi.BWN_SHORTCUTWIN
BWN_CPUREGS = _idaapi.BWN_CPUREGS
BWN_SO_STRUCTS = _idaapi.BWN_SO_STRUCTS
BWN_SO_OFFSETS = _idaapi.BWN_SO_OFFSETS
BWN_STACK = _idaapi.BWN_STACK
BWN_DISASMS = _idaapi.BWN_DISASMS
BWN_DUMPS = _idaapi.BWN_DUMPS
BWN_SEARCHS = _idaapi.BWN_SEARCHS
IWID_EXPORTS = _idaapi.IWID_EXPORTS
IWID_IMPORTS = _idaapi.IWID_IMPORTS
IWID_NAMES = _idaapi.IWID_NAMES
IWID_FUNCS = _idaapi.IWID_FUNCS
IWID_STRINGS = _idaapi.IWID_STRINGS
IWID_SEGS = _idaapi.IWID_SEGS
IWID_SEGREGS = _idaapi.IWID_SEGREGS
IWID_SELS = _idaapi.IWID_SELS
IWID_SIGNS = _idaapi.IWID_SIGNS
IWID_TILS = _idaapi.IWID_TILS
IWID_LOCTYPS = _idaapi.IWID_LOCTYPS
IWID_CALLS = _idaapi.IWID_CALLS
IWID_PROBS = _idaapi.IWID_PROBS
IWID_BPTS = _idaapi.IWID_BPTS
IWID_THREADS = _idaapi.IWID_THREADS
IWID_MODULES = _idaapi.IWID_MODULES
IWID_TRACE = _idaapi.IWID_TRACE
IWID_STACK = _idaapi.IWID_STACK
IWID_XREFS = _idaapi.IWID_XREFS
IWID_SEARCHS = _idaapi.IWID_SEARCHS
IWID_FRAME = _idaapi.IWID_FRAME
IWID_NAVBAND = _idaapi.IWID_NAVBAND
IWID_ENUMS = _idaapi.IWID_ENUMS
IWID_STRUCTS = _idaapi.IWID_STRUCTS
IWID_DISASMS = _idaapi.IWID_DISASMS
IWID_DUMPS = _idaapi.IWID_DUMPS
IWID_NOTEPAD = _idaapi.IWID_NOTEPAD
IWID_IDAMEMOS = _idaapi.IWID_IDAMEMOS
IWID_ALL = _idaapi.IWID_ALL

def is_chooser_tform(*args):
  """
  is_chooser_tform(t) -> bool
  """
  return _idaapi.is_chooser_tform(*args)
CHOOSER_NO_SELECTION = _idaapi.CHOOSER_NO_SELECTION
CHOOSER_MULTI_SELECTION = _idaapi.CHOOSER_MULTI_SELECTION
CHOOSER_HOTKEY = _idaapi.CHOOSER_HOTKEY
CHOOSER_MENU_EDIT = _idaapi.CHOOSER_MENU_EDIT
CHOOSER_MENU_JUMP = _idaapi.CHOOSER_MENU_JUMP
CHOOSER_MENU_SEARCH = _idaapi.CHOOSER_MENU_SEARCH
CHOOSER_POPUP_MENU = _idaapi.CHOOSER_POPUP_MENU
CVH_USERDATA = _idaapi.CVH_USERDATA
CVH_KEYDOWN = _idaapi.CVH_KEYDOWN
CVH_POPUP = _idaapi.CVH_POPUP
CVH_DBLCLICK = _idaapi.CVH_DBLCLICK
CVH_CURPOS = _idaapi.CVH_CURPOS
CVH_CLOSE = _idaapi.CVH_CLOSE
CVH_CLICK = _idaapi.CVH_CLICK
CVH_QT_AWARE = _idaapi.CVH_QT_AWARE
CVH_HELP = _idaapi.CVH_HELP
CVH_MOUSEMOVE = _idaapi.CVH_MOUSEMOVE
CDVH_USERDATA = _idaapi.CDVH_USERDATA
CDVH_SRCVIEW = _idaapi.CDVH_SRCVIEW
CDVH_LINES_CLICK = _idaapi.CDVH_LINES_CLICK
CDVH_LINES_DBLCLICK = _idaapi.CDVH_LINES_DBLCLICK
CDVH_LINES_POPUP = _idaapi.CDVH_LINES_POPUP
CDVH_LINES_DRAWICON = _idaapi.CDVH_LINES_DRAWICON
CDVH_LINES_LINENUM = _idaapi.CDVH_LINES_LINENUM
CDVH_LINES_ICONMARGIN = _idaapi.CDVH_LINES_ICONMARGIN
CDVH_LINES_RADIX = _idaapi.CDVH_LINES_RADIX
CDVH_LINES_ALIGNMENT = _idaapi.CDVH_LINES_ALIGNMENT
msg_activated = _idaapi.msg_activated
msg_deactivated = _idaapi.msg_deactivated
obsolete_msg_popup = _idaapi.obsolete_msg_popup
msg_click = _idaapi.msg_click
msg_dblclick = _idaapi.msg_dblclick
msg_closed = _idaapi.msg_closed
msg_keydown = _idaapi.msg_keydown
class renderer_pos_info_t(object):
    """
    Proxy of C++ renderer_pos_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> renderer_pos_info_t
        """
        this = _idaapi.new_renderer_pos_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    node = _swig_property(_idaapi.renderer_pos_info_t_node_get, _idaapi.renderer_pos_info_t_node_set)
    cx = _swig_property(_idaapi.renderer_pos_info_t_cx_get, _idaapi.renderer_pos_info_t_cx_set)
    cy = _swig_property(_idaapi.renderer_pos_info_t_cy_get, _idaapi.renderer_pos_info_t_cy_set)
    sx = _swig_property(_idaapi.renderer_pos_info_t_sx_get, _idaapi.renderer_pos_info_t_sx_set)
    __swig_destroy__ = _idaapi.delete_renderer_pos_info_t
    __del__ = lambda self : None;
renderer_pos_info_t_swigregister = _idaapi.renderer_pos_info_t_swigregister
renderer_pos_info_t_swigregister(renderer_pos_info_t)
EMPTY_SEL = cvar.EMPTY_SEL
START_SEL = cvar.START_SEL
END_SEL = cvar.END_SEL

view_activated = _idaapi.view_activated
view_deactivated = _idaapi.view_deactivated
view_keydown = _idaapi.view_keydown
obsolete_view_popup = _idaapi.obsolete_view_popup
view_click = _idaapi.view_click
view_dblclick = _idaapi.view_dblclick
view_curpos = _idaapi.view_curpos
view_created = _idaapi.view_created
view_close = _idaapi.view_close
view_switched = _idaapi.view_switched
view_mouse_over = _idaapi.view_mouse_over
MFF_FAST = _idaapi.MFF_FAST
MFF_READ = _idaapi.MFF_READ
MFF_WRITE = _idaapi.MFF_WRITE
MFF_NOWAIT = _idaapi.MFF_NOWAIT
class ui_requests_t(object):
    """
    Proxy of C++ ui_requests_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> ui_requests_t
        """
        this = _idaapi.new_ui_requests_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ui_requests_t
    __del__ = lambda self : None;
ui_requests_t_swigregister = _idaapi.ui_requests_t_swigregister
ui_requests_t_swigregister(ui_requests_t)

UIJMP_ACTIVATE = _idaapi.UIJMP_ACTIVATE
UIJMP_DONTPUSH = _idaapi.UIJMP_DONTPUSH
UIJMP_IDAVIEW = _idaapi.UIJMP_IDAVIEW
class action_ctx_base_t(object):
    """
    Proxy of C++ action_ctx_base_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> action_ctx_base_t
        """
        this = _idaapi.new_action_ctx_base_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset(self, *args):
        """
        reset(self)
        """
        return _idaapi.action_ctx_base_t_reset(self, *args)

    form = _swig_property(_idaapi.action_ctx_base_t_form_get, _idaapi.action_ctx_base_t_form_set)
    form_type = _swig_property(_idaapi.action_ctx_base_t_form_type_get, _idaapi.action_ctx_base_t_form_type_set)
    form_title = _swig_property(_idaapi.action_ctx_base_t_form_title_get, _idaapi.action_ctx_base_t_form_title_set)
    chooser_selection = _swig_property(_idaapi.action_ctx_base_t_chooser_selection_get, _idaapi.action_ctx_base_t_chooser_selection_set)
    action = _swig_property(_idaapi.action_ctx_base_t_action_get, _idaapi.action_ctx_base_t_action_set)
    cur_flags = _swig_property(_idaapi.action_ctx_base_t_cur_flags_get, _idaapi.action_ctx_base_t_cur_flags_set)
    def has_flag(self, *args):
        """
        has_flag(self, flag) -> bool
        """
        return _idaapi.action_ctx_base_t_has_flag(self, *args)

    cur_ea = _swig_property(_idaapi.action_ctx_base_t_cur_ea_get, _idaapi.action_ctx_base_t_cur_ea_set)
    cur_extracted_ea = _swig_property(_idaapi.action_ctx_base_t_cur_extracted_ea_get, _idaapi.action_ctx_base_t_cur_extracted_ea_set)
    cur_func = _swig_property(_idaapi.action_ctx_base_t_cur_func_get, _idaapi.action_ctx_base_t_cur_func_set)
    cur_fchunk = _swig_property(_idaapi.action_ctx_base_t_cur_fchunk_get, _idaapi.action_ctx_base_t_cur_fchunk_set)
    cur_struc = _swig_property(_idaapi.action_ctx_base_t_cur_struc_get, _idaapi.action_ctx_base_t_cur_struc_set)
    cur_strmem = _swig_property(_idaapi.action_ctx_base_t_cur_strmem_get, _idaapi.action_ctx_base_t_cur_strmem_set)
    cur_enum = _swig_property(_idaapi.action_ctx_base_t_cur_enum_get, _idaapi.action_ctx_base_t_cur_enum_set)
    cur_seg = _swig_property(_idaapi.action_ctx_base_t_cur_seg_get, _idaapi.action_ctx_base_t_cur_seg_set)
    __swig_destroy__ = _idaapi.delete_action_ctx_base_t
    __del__ = lambda self : None;
action_ctx_base_t_swigregister = _idaapi.action_ctx_base_t_swigregister
action_ctx_base_t_swigregister(action_ctx_base_t)
ACF_HAS_SELECTION = _idaapi.ACF_HAS_SELECTION
ACF_XTRN_EA = _idaapi.ACF_XTRN_EA

class action_activation_ctx_t(action_ctx_base_t):
    """
    Proxy of C++ action_activation_ctx_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> action_activation_ctx_t
        """
        this = _idaapi.new_action_activation_ctx_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_action_activation_ctx_t
    __del__ = lambda self : None;
action_activation_ctx_t_swigregister = _idaapi.action_activation_ctx_t_swigregister
action_activation_ctx_t_swigregister(action_activation_ctx_t)

class action_update_ctx_t(action_ctx_base_t):
    """
    Proxy of C++ action_update_ctx_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> action_update_ctx_t
        """
        this = _idaapi.new_action_update_ctx_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_action_update_ctx_t
    __del__ = lambda self : None;
action_update_ctx_t_swigregister = _idaapi.action_update_ctx_t_swigregister
action_update_ctx_t_swigregister(action_update_ctx_t)

AHF_VERSION = _idaapi.AHF_VERSION
AHF_VERSION_MASK = _idaapi.AHF_VERSION_MASK
AST_ENABLE_ALWAYS = _idaapi.AST_ENABLE_ALWAYS
AST_ENABLE_FOR_IDB = _idaapi.AST_ENABLE_FOR_IDB
AST_ENABLE_FOR_FORM = _idaapi.AST_ENABLE_FOR_FORM
AST_ENABLE = _idaapi.AST_ENABLE
AST_DISABLE_ALWAYS = _idaapi.AST_DISABLE_ALWAYS
AST_DISABLE_FOR_IDB = _idaapi.AST_DISABLE_FOR_IDB
AST_DISABLE_FOR_FORM = _idaapi.AST_DISABLE_FOR_FORM
AST_DISABLE = _idaapi.AST_DISABLE

def is_action_enabled(*args):
  """
  is_action_enabled(s) -> bool
  """
  return _idaapi.is_action_enabled(*args)
class action_desc_t(object):
    """
    Proxy of C++ action_desc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cb = _swig_property(_idaapi.action_desc_t_cb_get, _idaapi.action_desc_t_cb_set)
    name = _swig_property(_idaapi.action_desc_t_name_get, _idaapi.action_desc_t_name_set)
    label = _swig_property(_idaapi.action_desc_t_label_get, _idaapi.action_desc_t_label_set)
    owner = _swig_property(_idaapi.action_desc_t_owner_get, _idaapi.action_desc_t_owner_set)
    shortcut = _swig_property(_idaapi.action_desc_t_shortcut_get, _idaapi.action_desc_t_shortcut_set)
    tooltip = _swig_property(_idaapi.action_desc_t_tooltip_get, _idaapi.action_desc_t_tooltip_set)
    icon = _swig_property(_idaapi.action_desc_t_icon_get, _idaapi.action_desc_t_icon_set)
    def __init__(self, *args):
        """
        __init__(self, name, label, handler, shortcut=None, tooltip=None, icon=-1) -> action_desc_t
        """
        this = _idaapi.new_action_desc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_action_desc_t
    __del__ = lambda self : None;
action_desc_t_swigregister = _idaapi.action_desc_t_swigregister
action_desc_t_swigregister(action_desc_t)

AA_NONE = _idaapi.AA_NONE
AA_LABEL = _idaapi.AA_LABEL
AA_SHORTCUT = _idaapi.AA_SHORTCUT
AA_TOOLTIP = _idaapi.AA_TOOLTIP
AA_ICON = _idaapi.AA_ICON
AA_STATE = _idaapi.AA_STATE
AA_CHECKABLE = _idaapi.AA_CHECKABLE
AA_CHECKED = _idaapi.AA_CHECKED
AA_VISIBILITY = _idaapi.AA_VISIBILITY

def cancel_exec_request(*args):
  """
  cancel_exec_request(req_id) -> bool
  """
  return _idaapi.cancel_exec_request(*args)

def banner(*args):
  """
  banner(wait) -> bool
  """
  return _idaapi.banner(*args)

def is_msg_inited(*args):
  """
  is_msg_inited() -> bool
  """
  return _idaapi.is_msg_inited(*args)

def refresh_idaview(*args):
  """
  refresh_idaview()
  """
  return _idaapi.refresh_idaview(*args)

def refresh_idaview_anyway(*args):
  """
  refresh_idaview_anyway()
  """
  return _idaapi.refresh_idaview_anyway(*args)

def analyzer_options(*args):
  """
  analyzer_options()
  """
  return _idaapi.analyzer_options(*args)

def get_screen_ea(*args):
  """
  get_screen_ea() -> ea_t
  """
  return _idaapi.get_screen_ea(*args)

def get_opnum(*args):
  """
  get_opnum() -> int
  """
  return _idaapi.get_opnum(*args)

def get_cursor(*args):
  """
  get_cursor() -> bool
  """
  return _idaapi.get_cursor(*args)

def get_output_cursor(*args):
  """
  get_output_cursor() -> bool
  """
  return _idaapi.get_output_cursor(*args)

def get_curline(*args):
  """
  get_curline() -> char *
  """
  return _idaapi.get_curline(*args)

def read_selection(*args):
  """
  read_selection() -> bool
  """
  return _idaapi.read_selection(*args)

def unmark_selection(*args):
  """
  unmark_selection()
  """
  return _idaapi.unmark_selection(*args)

def open_url(*args):
  """
  open_url(url)
  """
  return _idaapi.open_url(*args)

def get_hexdump_ea(*args):
  """
  get_hexdump_ea(hexdump_num) -> ea_t
  """
  return _idaapi.get_hexdump_ea(*args)

def get_key_code(*args):
  """
  get_key_code(keyname) -> ushort
  """
  return _idaapi.get_key_code(*args)

def lookup_key_code(*args):
  """
  lookup_key_code(key, shift, is_qt) -> ushort
  """
  return _idaapi.lookup_key_code(*args)

def refresh_navband(*args):
  """
  refresh_navband(force)
  """
  return _idaapi.refresh_navband(*args)

def refresh_chooser(*args):
  """
  refresh_chooser(title) -> bool
  """
  return _idaapi.refresh_chooser(*args)

def close_chooser(*args):
  """
  close_chooser(title) -> bool
  """
  return _idaapi.close_chooser(*args)

def set_dock_pos(*args):
  """
  set_dock_pos(src_ctrl, dest_ctrl, orient, left=0, top=0, right=0, bottom=0) -> bool


  Sets the dock orientation of a window relatively to another window.
  
  @param src: Source docking control
  @param dest: Destination docking control
  @param orient: One of DOR_XXXX constants
  @param left, top, right, bottom: These parameter if DOR_FLOATING is used, or if you want to specify the width of docked windows
  @return: Boolean
  
  Example:
      set_dock_pos('Structures', 'Enums', DOR_RIGHT) <- docks the Structures window to the right of Enums window
  """
  return _idaapi.set_dock_pos(*args)

def free_custom_icon(*args):
  """
  free_custom_icon(icon_id)


  Frees an icon loaded with load_custom_icon()
  """
  return _idaapi.free_custom_icon(*args)
class __qtimer_t(object):
    """
    Proxy of C++ __qtimer_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> __qtimer_t
        """
        this = _idaapi.new___qtimer_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete___qtimer_t
    __del__ = lambda self : None;
__qtimer_t_swigregister = _idaapi.__qtimer_t_swigregister
__qtimer_t_swigregister(__qtimer_t)


def attach_action_to_menu(*args):
  """
  attach_action_to_menu(menupath, name, flags) -> bool
  """
  return _idaapi.attach_action_to_menu(*args)

def detach_action_from_menu(*args):
  """
  detach_action_from_menu(menupath, name) -> bool
  """
  return _idaapi.detach_action_from_menu(*args)

def attach_action_to_toolbar(*args):
  """
  attach_action_to_toolbar(toolbar_name, name) -> bool
  """
  return _idaapi.attach_action_to_toolbar(*args)

def detach_action_from_toolbar(*args):
  """
  detach_action_from_toolbar(toolbar_name, name) -> bool
  """
  return _idaapi.detach_action_from_toolbar(*args)

def register_and_attach_to_menu(*args):
  """
  register_and_attach_to_menu(menupath, name, label, shortcut, flags, handler, owner) -> bool
  """
  return _idaapi.register_and_attach_to_menu(*args)

def set_menu_item_icon(*args):
  """
  set_menu_item_icon(item_name, icon_id) -> bool
  """
  return _idaapi.set_menu_item_icon(*args)

def enable_menu_item(*args):
  """
  enable_menu_item(item_name, enable) -> bool
  """
  return _idaapi.enable_menu_item(*args)

def create_tform(*args):
  """
  create_tform(caption, handle) -> TForm *
  """
  return _idaapi.create_tform(*args)

def open_tform(*args):
  """
  open_tform(form, options)
  """
  return _idaapi.open_tform(*args)

def close_tform(*args):
  """
  close_tform(form, options)
  """
  return _idaapi.close_tform(*args)

def switchto_tform(*args):
  """
  switchto_tform(form, take_focus)
  """
  return _idaapi.switchto_tform(*args)

def find_tform(*args):
  """
  find_tform(caption) -> TForm *
  """
  return _idaapi.find_tform(*args)

def get_current_tform(*args):
  """
  get_current_tform() -> TForm *
  """
  return _idaapi.get_current_tform(*args)

def get_tform_type(*args):
  """
  get_tform_type(form) -> tform_type_t
  """
  return _idaapi.get_tform_type(*args)

def get_tform_title(*args):
  """
  get_tform_title(form) -> bool
  """
  return _idaapi.get_tform_title(*args)

def create_ea_viewer(*args):
  """
  create_ea_viewer(title, parent, minplace, maxplace, curplace, y, ud, flags=0, fillloc=None, jumploc=None) -> TCustomControl *
  """
  return _idaapi.create_ea_viewer(*args)

def ea_viewer_history_push_and_jump(*args):
  """
  ea_viewer_history_push_and_jump(v, ea, x, y, lnnum) -> bool
  """
  return _idaapi.ea_viewer_history_push_and_jump(*args)

def get_ea_viewer_history_info(*args):
  """
  get_ea_viewer_history_info(nback, nfwd, v) -> bool
  """
  return _idaapi.get_ea_viewer_history_info(*args)

def repaint_custom_viewer(*args):
  """
  repaint_custom_viewer(custom_viewer)
  """
  return _idaapi.repaint_custom_viewer(*args)

def jumpto(*args):
  """
    jumpto(ea, opnum=-1, uijmp_flags=0x0001) -> bool
    jumpto(custom_viewer, place, x, y) -> bool
    """
  return _idaapi.jumpto(*args)

def get_custom_viewer_place(*args):
  """
  get_custom_viewer_place(custom_viewer, mouse) -> place_t
  """
  return _idaapi.get_custom_viewer_place(*args)

def is_idaq(*args):
  """
  is_idaq() -> bool


  Returns True or False depending if IDAPython is hosted by IDAQ
  """
  return _idaapi.is_idaq(*args)

def attach_action_to_popup(*args):
  """
    attach_action_to_popup(tcc, popup_handle, name, popuppath=None, flags=0) -> bool
    attach_action_to_popup(form, popup_handle, name, popuppath=None, flags=0) -> bool
    """
  return _idaapi.attach_action_to_popup(*args)

def detach_action_from_popup(*args):
  """
  detach_action_from_popup(form, name) -> bool
  """
  return _idaapi.detach_action_from_popup(*args)

def update_action_label(*args):
  """
  update_action_label(name, label) -> bool
  """
  return _idaapi.update_action_label(*args)

def update_action_shortcut(*args):
  """
  update_action_shortcut(name, shortcut) -> bool
  """
  return _idaapi.update_action_shortcut(*args)

def update_action_tooltip(*args):
  """
  update_action_tooltip(name, tooltip) -> bool
  """
  return _idaapi.update_action_tooltip(*args)

def update_action_icon(*args):
  """
  update_action_icon(name, icon) -> bool
  """
  return _idaapi.update_action_icon(*args)

def update_action_state(*args):
  """
  update_action_state(name, state) -> bool
  """
  return _idaapi.update_action_state(*args)

def update_action_checkable(*args):
  """
  update_action_checkable(name, checkable) -> bool
  """
  return _idaapi.update_action_checkable(*args)

def update_action_checked(*args):
  """
  update_action_checked(name, checked) -> bool
  """
  return _idaapi.update_action_checked(*args)

def update_action_visibility(*args):
  """
  update_action_visibility(name, visible) -> bool
  """
  return _idaapi.update_action_visibility(*args)

def get_action_label(*args):
  """
  get_action_label(name) -> bool
  """
  return _idaapi.get_action_label(*args)

def get_action_shortcut(*args):
  """
  get_action_shortcut(name) -> bool
  """
  return _idaapi.get_action_shortcut(*args)

def get_action_tooltip(*args):
  """
  get_action_tooltip(name) -> bool
  """
  return _idaapi.get_action_tooltip(*args)

def get_action_icon(*args):
  """
  get_action_icon(name) -> bool
  """
  return _idaapi.get_action_icon(*args)

def get_action_state(*args):
  """
  get_action_state(name) -> bool
  """
  return _idaapi.get_action_state(*args)

def get_action_checkable(*args):
  """
  get_action_checkable(name) -> bool
  """
  return _idaapi.get_action_checkable(*args)

def get_action_checked(*args):
  """
  get_action_checked(name) -> bool
  """
  return _idaapi.get_action_checked(*args)

def get_action_visibility(*args):
  """
  get_action_visibility(name) -> bool
  """
  return _idaapi.get_action_visibility(*args)

def set_custom_viewer_qt_aware(*args):
  """
  set_custom_viewer_qt_aware(custom_viewer) -> bool
  """
  return _idaapi.set_custom_viewer_qt_aware(*args)

def get_custom_viewer_curline(*args):
  """
  get_custom_viewer_curline(custom_viewer, mouse) -> char const *
  """
  return _idaapi.get_custom_viewer_curline(*args)

def get_output_curline(*args):
  """
  get_output_curline(mouse) -> bool
  """
  return _idaapi.get_output_curline(*args)

def get_output_selected_text(*args):
  """
  get_output_selected_text() -> bool
  """
  return _idaapi.get_output_selected_text(*args)

def get_tform_idaview(*args):
  """
  get_tform_idaview(parent) -> TCustomControl *
  """
  return _idaapi.get_tform_idaview(*args)

def get_current_viewer(*args):
  """
  get_current_viewer() -> TCustomControl *
  """
  return _idaapi.get_current_viewer(*args)

def get_view_renderer_type(*args):
  """
  get_view_renderer_type(v) -> tcc_renderer_type_t
  """
  return _idaapi.get_view_renderer_type(*args)

def set_view_renderer_type(*args):
  """
  set_view_renderer_type(v, rt)
  """
  return _idaapi.set_view_renderer_type(*args)

def readsel2(*args):
  """
  readsel2(v, p1, p2) -> bool


  Read the user selection, and store its information in p0 (from) and p1 (to).
  
  This can be used as follows:
  
  
  >>> p0 = idaapi.twinpos_t()
  p1 = idaapi.twinpos_t()
  view = idaapi.get_current_viewer()
  idaapi.readsel2(view, p0, p1)
  
  
  At that point, p0 and p1 hold information for the selection.
  But, the 'at' property of p0 and p1 is not properly typed.
  To specialize it, call #place() on it, passing it the view
  they were retrieved from. Like so:
  
  
  >>> place0 = p0.place(view)
  place1 = p1.place(view)
  
  
  This will effectively "cast" the place into a specialized type,
  holding proper information, depending on the view type (e.g.,
  disassembly, structures, enums, ...)
  
  @param view: The view to retrieve the selection for.
  @param p0: Storage for the "from" part of the selection.
  @param p1: Storage for the "to" part of the selection.
  @return: a bool value indicating success.
  """
  return _idaapi.readsel2(*args)

def create_code_viewer(*args):
  """
  create_code_viewer(parent, custview, flags=0) -> TCustomControl *
  """
  return _idaapi.create_code_viewer(*args)

def set_code_viewer_handler(*args):
  """
  set_code_viewer_handler(code_viewer, handler_id, handler_or_data) -> void *
  """
  return _idaapi.set_code_viewer_handler(*args)

def set_code_viewer_user_data(*args):
  """
  set_code_viewer_user_data(code_viewer, ud) -> bool
  """
  return _idaapi.set_code_viewer_user_data(*args)

def get_viewer_user_data(*args):
  """
  get_viewer_user_data(viewer) -> void *
  """
  return _idaapi.get_viewer_user_data(*args)

def get_viewer_place_type(*args):
  """
  get_viewer_place_type(viewer) -> tcc_place_type_t
  """
  return _idaapi.get_viewer_place_type(*args)

def set_code_viewer_line_handlers(*args):
  """
  set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler)
  """
  return _idaapi.set_code_viewer_line_handlers(*args)

def set_code_viewer_lines_icon_margin(*args):
  """
  set_code_viewer_lines_icon_margin(code_viewer, margin) -> bool
  """
  return _idaapi.set_code_viewer_lines_icon_margin(*args)

def set_code_viewer_lines_alignment(*args):
  """
  set_code_viewer_lines_alignment(code_viewer, align) -> bool
  """
  return _idaapi.set_code_viewer_lines_alignment(*args)

def set_code_viewer_lines_radix(*args):
  """
  set_code_viewer_lines_radix(code_viewer, radix) -> bool
  """
  return _idaapi.set_code_viewer_lines_radix(*args)

def set_code_viewer_is_source(*args):
  """
  set_code_viewer_is_source(code_viewer) -> bool
  """
  return _idaapi.set_code_viewer_is_source(*args)

def get_tab_size(*args):
  """
  get_tab_size(path) -> int
  """
  return _idaapi.get_tab_size(*args)

def clearBreak(*args):
  """
  clearBreak()
  """
  return _idaapi.clearBreak(*args)

def setBreak(*args):
  """
  setBreak()
  """
  return _idaapi.setBreak(*args)

def wasBreak(*args):
  """
  wasBreak() -> bool
  """
  return _idaapi.wasBreak(*args)

def ui_load_new_file(*args):
  """
  ui_load_new_file(filename, li, neflags) -> bool
  """
  return _idaapi.ui_load_new_file(*args)

def ui_run_debugger(*args):
  """
  ui_run_debugger(dbgopts, $ignore, argc, argv) -> bool
  """
  return _idaapi.ui_run_debugger(*args)

def load_dbg_dbginfo(*args):
  """
  load_dbg_dbginfo(path, li=None, base=BADADDR, verbose=False) -> bool
  """
  return _idaapi.load_dbg_dbginfo(*args)

def add_idc_hotkey(*args):
  """
  add_idc_hotkey(hotkey, idcfunc) -> int
  """
  return _idaapi.add_idc_hotkey(*args)

def del_idc_hotkey(*args):
  """
  del_idc_hotkey(hotkey) -> bool
  """
  return _idaapi.del_idc_hotkey(*args)

def get_user_strlist_options(*args):
  """
  get_user_strlist_options(out)
  """
  return _idaapi.get_user_strlist_options(*args)

def open_exports_window(*args):
  """
  open_exports_window(ea) -> TForm *
  """
  return _idaapi.open_exports_window(*args)

def open_imports_window(*args):
  """
  open_imports_window(ea) -> TForm *
  """
  return _idaapi.open_imports_window(*args)

def open_names_window(*args):
  """
  open_names_window(ea) -> TForm *
  """
  return _idaapi.open_names_window(*args)

def open_funcs_window(*args):
  """
  open_funcs_window(ea) -> TForm *
  """
  return _idaapi.open_funcs_window(*args)

def open_strings_window(*args):
  """
  open_strings_window(ea, selstart=BADADDR, selend=BADADDR) -> TForm *
  """
  return _idaapi.open_strings_window(*args)

def open_segments_window(*args):
  """
  open_segments_window(ea) -> TForm *
  """
  return _idaapi.open_segments_window(*args)

def open_segregs_window(*args):
  """
  open_segregs_window(ea) -> TForm *
  """
  return _idaapi.open_segregs_window(*args)

def open_selectors_window(*args):
  """
  open_selectors_window() -> TForm *
  """
  return _idaapi.open_selectors_window(*args)

def open_signatures_window(*args):
  """
  open_signatures_window() -> TForm *
  """
  return _idaapi.open_signatures_window(*args)

def open_tils_window(*args):
  """
  open_tils_window() -> TForm *
  """
  return _idaapi.open_tils_window(*args)

def open_loctypes_window(*args):
  """
  open_loctypes_window(ordinal) -> TForm *
  """
  return _idaapi.open_loctypes_window(*args)

def open_calls_window(*args):
  """
  open_calls_window(ea) -> TForm *
  """
  return _idaapi.open_calls_window(*args)

def open_problems_window(*args):
  """
  open_problems_window(ea) -> TForm *
  """
  return _idaapi.open_problems_window(*args)

def open_bpts_window(*args):
  """
  open_bpts_window(ea) -> TForm *
  """
  return _idaapi.open_bpts_window(*args)

def open_threads_window(*args):
  """
  open_threads_window() -> TForm *
  """
  return _idaapi.open_threads_window(*args)

def open_modules_window(*args):
  """
  open_modules_window() -> TForm *
  """
  return _idaapi.open_modules_window(*args)

def open_trace_window(*args):
  """
  open_trace_window() -> TForm *
  """
  return _idaapi.open_trace_window(*args)

def open_stack_window(*args):
  """
  open_stack_window() -> TForm *
  """
  return _idaapi.open_stack_window(*args)

def open_xrefs_window(*args):
  """
  open_xrefs_window(ea) -> TForm *
  """
  return _idaapi.open_xrefs_window(*args)

def open_frame_window(*args):
  """
  open_frame_window(pfn, offset) -> TForm *
  """
  return _idaapi.open_frame_window(*args)

def open_navband_window(*args):
  """
  open_navband_window(ea, zoom) -> TForm *
  """
  return _idaapi.open_navband_window(*args)

def open_enums_window(*args):
  """
  open_enums_window(const_id=BADADDR) -> TForm *
  """
  return _idaapi.open_enums_window(*args)

def open_structs_window(*args):
  """
  open_structs_window(id=BADADDR, offset=0) -> TForm *
  """
  return _idaapi.open_structs_window(*args)

def open_disasm_window(*args):
  """
  open_disasm_window(window_title, ranges=None) -> TForm *
  """
  return _idaapi.open_disasm_window(*args)

def open_hexdump_window(*args):
  """
  open_hexdump_window(window_title) -> TForm *
  """
  return _idaapi.open_hexdump_window(*args)

def open_notepad_window(*args):
  """
  open_notepad_window() -> TForm *
  """
  return _idaapi.open_notepad_window(*args)

def choose_til(*args):
  """
  choose_til() -> bool
  """
  return _idaapi.choose_til(*args)

def choose_entry(*args):
  """
  choose_entry(title) -> ea_t
  """
  return _idaapi.choose_entry(*args)

def choose_name(*args):
  """
  choose_name(title) -> ea_t
  """
  return _idaapi.choose_name(*args)

def choose_stkvar_xref(*args):
  """
  choose_stkvar_xref(pfn, mptr) -> ea_t
  """
  return _idaapi.choose_stkvar_xref(*args)

def choose_xref(*args):
  """
  choose_xref(to) -> ea_t
  """
  return _idaapi.choose_xref(*args)

def choose_enum(*args):
  """
  choose_enum(title, default_id) -> enum_t
  """
  return _idaapi.choose_enum(*args)

def choose_enum_by_value(*args):
  """
  choose_enum_by_value(title, default_id, value, nbytes) -> enum_t
  """
  return _idaapi.choose_enum_by_value(*args)

def choose_func(*args):
  """
  choose_func(title, default_ea) -> func_t
  """
  return _idaapi.choose_func(*args)

def choose_segm(*args):
  """
  choose_segm(title, default_ea) -> segment_t
  """
  return _idaapi.choose_segm(*args)

def choose_struc(*args):
  """
  choose_struc(title) -> struc_t
  """
  return _idaapi.choose_struc(*args)

def choose_srcp(*args):
  """
  choose_srcp(title) -> segreg_area_t
  """
  return _idaapi.choose_srcp(*args)

def get_chooser_obj(*args):
  """
  get_chooser_obj(chooser_caption) -> void *
  """
  return _idaapi.get_chooser_obj(*args)

def enable_chooser_item_attrs(*args):
  """
  enable_chooser_item_attrs(chooser_caption, enable) -> bool
  """
  return _idaapi.enable_chooser_item_attrs(*args)

def show_wait_box(*args):
  """
  show_wait_box(format)
  """
  return _idaapi.show_wait_box(*args)

def hide_wait_box(*args):
  """
  hide_wait_box()
  """
  return _idaapi.hide_wait_box(*args)

def replace_wait_box(*args):
  """
  replace_wait_box(format)
  """
  return _idaapi.replace_wait_box(*args)

def beep(*args):
  """
  beep(beep_type=beep_default)
  """
  return _idaapi.beep(*args)

def askfile2_cv(*args):
  """
  askfile2_cv(forsave, defdir, filters, format, va) -> char *
  """
  return _idaapi.askfile2_cv(*args)

def ask_for_feedback(*args):
  """
  ask_for_feedback(format)
  """
  return _idaapi.ask_for_feedback(*args)

def askident(*args):
  """
  askident(defval, format) -> char *
  """
  return _idaapi.askident(*args)

def _askaddr(*args):
  """
  _askaddr(addr, format) -> bool
  """
  return _idaapi._askaddr(*args)

def _askseg(*args):
  """
  _askseg(sel, format) -> bool
  """
  return _idaapi._askseg(*args)

def _asklong(*args):
  """
  _asklong(value, format) -> bool
  """
  return _idaapi._asklong(*args)

def vaskqstr(*args):
  """
  vaskqstr(str, format, va) -> bool
  """
  return _idaapi.vaskqstr(*args)

def vumsg(*args):
  """
  vumsg(format, va) -> int
  """
  return _idaapi.vumsg(*args)

def display_copyright_warning(*args):
  """
  display_copyright_warning() -> bool
  """
  return _idaapi.display_copyright_warning(*args)

def add_output_popup(*args):
  """
  add_output_popup(n, c, u)
  """
  return _idaapi.add_output_popup(*args)

def add_chooser_command(*args):
  """
    add_chooser_command(chooser_caption, cmd_caption, chooser_cb, menu_index=-1, icon=-1, flags=0) -> bool
    add_chooser_command(chooser_caption, cmd_caption, chooser_cb, hotkey, menu_index=-1, icon=-1, flags=0) -> bool
    """
  return _idaapi.add_chooser_command(*args)

def choose_segreg(*args):
  """
  choose_segreg(title) -> segreg_t
  """
  return _idaapi.choose_segreg(*args)

def error(*args):
  """
  error(format)
  """
  return _idaapi.error(*args)

def warning(*args):
  """
  warning(format)
  """
  return _idaapi.warning(*args)

def info(*args):
  """
  info(format)
  """
  return _idaapi.info(*args)

def nomem(*args):
  """
  nomem(format)
  """
  return _idaapi.nomem(*args)
ASKBTN_YES = _idaapi.ASKBTN_YES
ASKBTN_NO = _idaapi.ASKBTN_NO
ASKBTN_CANCEL = _idaapi.ASKBTN_CANCEL
ASKBTN_BTN1 = _idaapi.ASKBTN_BTN1
ASKBTN_BTN2 = _idaapi.ASKBTN_BTN2
ASKBTN_BTN3 = _idaapi.ASKBTN_BTN3

def askyn_c(*args):
  """
  askyn_c(deflt, format) -> int
  """
  return _idaapi.askyn_c(*args)

def askbuttons_c(*args):
  """
  askbuttons_c(Yes, No, Cancel, deflt, format) -> int
  """
  return _idaapi.askbuttons_c(*args)

def askstr(*args):
  """
  askstr(hist, defval, format) -> char *
  """
  return _idaapi.askstr(*args)
HIST_SEG = _idaapi.HIST_SEG
HIST_CMT = _idaapi.HIST_CMT
HIST_SRCH = _idaapi.HIST_SRCH
HIST_ADDR = _idaapi.HIST_ADDR
HIST_IDENT = _idaapi.HIST_IDENT
HIST_NUM = _idaapi.HIST_NUM
HIST_FILE = _idaapi.HIST_FILE
HIST_TYPE = _idaapi.HIST_TYPE
HIST_CMD = _idaapi.HIST_CMD
HIST_DIR = _idaapi.HIST_DIR

def askqstr(*args):
  """
  askqstr(str, format) -> bool
  """
  return _idaapi.askqstr(*args)

def askfile_c(*args):
  """
  askfile_c(savefile, defval, format) -> char *
  """
  return _idaapi.askfile_c(*args)

def askfile2_c(*args):
  """
  askfile2_c(forsave, defdir, filters, format) -> char *
  """
  return _idaapi.askfile2_c(*args)
class addon_info_t(object):
    """
    Proxy of C++ addon_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cb = _swig_property(_idaapi.addon_info_t_cb_get, _idaapi.addon_info_t_cb_set)
    id = _swig_property(_idaapi.addon_info_t_id_get, _idaapi.addon_info_t_id_set)
    name = _swig_property(_idaapi.addon_info_t_name_get, _idaapi.addon_info_t_name_set)
    producer = _swig_property(_idaapi.addon_info_t_producer_get, _idaapi.addon_info_t_producer_set)
    version = _swig_property(_idaapi.addon_info_t_version_get, _idaapi.addon_info_t_version_set)
    url = _swig_property(_idaapi.addon_info_t_url_get, _idaapi.addon_info_t_url_set)
    freeform = _swig_property(_idaapi.addon_info_t_freeform_get, _idaapi.addon_info_t_freeform_set)
    custom_data = _swig_property(_idaapi.addon_info_t_custom_data_get, _idaapi.addon_info_t_custom_data_set)
    custom_size = _swig_property(_idaapi.addon_info_t_custom_size_get, _idaapi.addon_info_t_custom_size_set)
    def __init__(self, *args):
        """
        __init__(self) -> addon_info_t
        """
        this = _idaapi.new_addon_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_addon_info_t
    __del__ = lambda self : None;
addon_info_t_swigregister = _idaapi.addon_info_t_swigregister
addon_info_t_swigregister(addon_info_t)


def register_addon(*args):
  """
  register_addon(info) -> int
  """
  return _idaapi.register_addon(*args)

def addon_count(*args):
  """
  addon_count() -> int
  """
  return _idaapi.addon_count(*args)

def get_addon_info(*args):
  """
  get_addon_info(id, info) -> bool
  """
  return _idaapi.get_addon_info(*args)

def get_addon_info_idx(*args):
  """
  get_addon_info_idx(index, info) -> bool
  """
  return _idaapi.get_addon_info_idx(*args)

def add_spaces(*args):
  """
  add_spaces(str, bufsize, len) -> char *
  """
  return _idaapi.add_spaces(*args)
class strarray_t(object):
    """
    Proxy of C++ strarray_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    code = _swig_property(_idaapi.strarray_t_code_get, _idaapi.strarray_t_code_set)
    text = _swig_property(_idaapi.strarray_t_text_get, _idaapi.strarray_t_text_set)
    def __init__(self, *args):
        """
        __init__(self) -> strarray_t
        """
        this = _idaapi.new_strarray_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_strarray_t
    __del__ = lambda self : None;
strarray_t_swigregister = _idaapi.strarray_t_swigregister
strarray_t_swigregister(strarray_t)


def strarray(*args):
  """
  strarray(array, array_size, code) -> char const *
  """
  return _idaapi.strarray(*args)
IK_CANCEL = _idaapi.IK_CANCEL
IK_BACK = _idaapi.IK_BACK
IK_TAB = _idaapi.IK_TAB
IK_CLEAR = _idaapi.IK_CLEAR
IK_RETURN = _idaapi.IK_RETURN
IK_SHIFT = _idaapi.IK_SHIFT
IK_CONTROL = _idaapi.IK_CONTROL
IK_MENU = _idaapi.IK_MENU
IK_PAUSE = _idaapi.IK_PAUSE
IK_CAPITAL = _idaapi.IK_CAPITAL
IK_KANA = _idaapi.IK_KANA
IK_ESCAPE = _idaapi.IK_ESCAPE
IK_MODECHANGE = _idaapi.IK_MODECHANGE
IK_SPACE = _idaapi.IK_SPACE
IK_PRIOR = _idaapi.IK_PRIOR
IK_NEXT = _idaapi.IK_NEXT
IK_END = _idaapi.IK_END
IK_HOME = _idaapi.IK_HOME
IK_LEFT = _idaapi.IK_LEFT
IK_UP = _idaapi.IK_UP
IK_RIGHT = _idaapi.IK_RIGHT
IK_DOWN = _idaapi.IK_DOWN
IK_SELECT = _idaapi.IK_SELECT
IK_PRINT = _idaapi.IK_PRINT
IK_EXECUTE = _idaapi.IK_EXECUTE
IK_SNAPSHOT = _idaapi.IK_SNAPSHOT
IK_INSERT = _idaapi.IK_INSERT
IK_DELETE = _idaapi.IK_DELETE
IK_HELP = _idaapi.IK_HELP
IK_LWIN = _idaapi.IK_LWIN
IK_RWIN = _idaapi.IK_RWIN
IK_APPS = _idaapi.IK_APPS
IK_SLEEP = _idaapi.IK_SLEEP
IK_NUMPAD0 = _idaapi.IK_NUMPAD0
IK_NUMPAD1 = _idaapi.IK_NUMPAD1
IK_NUMPAD2 = _idaapi.IK_NUMPAD2
IK_NUMPAD3 = _idaapi.IK_NUMPAD3
IK_NUMPAD4 = _idaapi.IK_NUMPAD4
IK_NUMPAD5 = _idaapi.IK_NUMPAD5
IK_NUMPAD6 = _idaapi.IK_NUMPAD6
IK_NUMPAD7 = _idaapi.IK_NUMPAD7
IK_NUMPAD8 = _idaapi.IK_NUMPAD8
IK_NUMPAD9 = _idaapi.IK_NUMPAD9
IK_MULTIPLY = _idaapi.IK_MULTIPLY
IK_ADD = _idaapi.IK_ADD
IK_SEPARATOR = _idaapi.IK_SEPARATOR
IK_SUBTRACT = _idaapi.IK_SUBTRACT
IK_DECIMAL = _idaapi.IK_DECIMAL
IK_DIVIDE = _idaapi.IK_DIVIDE
IK_F1 = _idaapi.IK_F1
IK_F2 = _idaapi.IK_F2
IK_F3 = _idaapi.IK_F3
IK_F4 = _idaapi.IK_F4
IK_F5 = _idaapi.IK_F5
IK_F6 = _idaapi.IK_F6
IK_F7 = _idaapi.IK_F7
IK_F8 = _idaapi.IK_F8
IK_F9 = _idaapi.IK_F9
IK_F10 = _idaapi.IK_F10
IK_F11 = _idaapi.IK_F11
IK_F12 = _idaapi.IK_F12
IK_F13 = _idaapi.IK_F13
IK_F14 = _idaapi.IK_F14
IK_F15 = _idaapi.IK_F15
IK_F16 = _idaapi.IK_F16
IK_F17 = _idaapi.IK_F17
IK_F18 = _idaapi.IK_F18
IK_F19 = _idaapi.IK_F19
IK_F20 = _idaapi.IK_F20
IK_F21 = _idaapi.IK_F21
IK_F22 = _idaapi.IK_F22
IK_F23 = _idaapi.IK_F23
IK_F24 = _idaapi.IK_F24
IK_NUMLOCK = _idaapi.IK_NUMLOCK
IK_SCROLL = _idaapi.IK_SCROLL
IK_OEM_FJ_MASSHOU = _idaapi.IK_OEM_FJ_MASSHOU
IK_OEM_FJ_TOUROKU = _idaapi.IK_OEM_FJ_TOUROKU
IK_LSHIFT = _idaapi.IK_LSHIFT
IK_RSHIFT = _idaapi.IK_RSHIFT
IK_LCONTROL = _idaapi.IK_LCONTROL
IK_RCONTROL = _idaapi.IK_RCONTROL
IK_LMENU = _idaapi.IK_LMENU
IK_RMENU = _idaapi.IK_RMENU
IK_BROWSER_BACK = _idaapi.IK_BROWSER_BACK
IK_BROWSER_FORWARD = _idaapi.IK_BROWSER_FORWARD
IK_BROWSER_REFRESH = _idaapi.IK_BROWSER_REFRESH
IK_BROWSER_STOP = _idaapi.IK_BROWSER_STOP
IK_BROWSER_SEARCH = _idaapi.IK_BROWSER_SEARCH
IK_BROWSER_FAVORITES = _idaapi.IK_BROWSER_FAVORITES
IK_BROWSER_HOME = _idaapi.IK_BROWSER_HOME
IK_VOLUME_MUTE = _idaapi.IK_VOLUME_MUTE
IK_VOLUME_DOWN = _idaapi.IK_VOLUME_DOWN
IK_VOLUME_UP = _idaapi.IK_VOLUME_UP
IK_MEDIA_NEXT_TRACK = _idaapi.IK_MEDIA_NEXT_TRACK
IK_MEDIA_PREV_TRACK = _idaapi.IK_MEDIA_PREV_TRACK
IK_MEDIA_STOP = _idaapi.IK_MEDIA_STOP
IK_MEDIA_PLAY_PAUSE = _idaapi.IK_MEDIA_PLAY_PAUSE
IK_LAUNCH_MAIL = _idaapi.IK_LAUNCH_MAIL
IK_LAUNCH_MEDIA_SELECT = _idaapi.IK_LAUNCH_MEDIA_SELECT
IK_LAUNCH_APP1 = _idaapi.IK_LAUNCH_APP1
IK_LAUNCH_APP2 = _idaapi.IK_LAUNCH_APP2
IK_OEM_1 = _idaapi.IK_OEM_1
IK_OEM_PLUS = _idaapi.IK_OEM_PLUS
IK_OEM_COMMA = _idaapi.IK_OEM_COMMA
IK_OEM_MINUS = _idaapi.IK_OEM_MINUS
IK_OEM_PERIOD = _idaapi.IK_OEM_PERIOD
IK_OEM_2 = _idaapi.IK_OEM_2
IK_OEM_3 = _idaapi.IK_OEM_3
IK_OEM_4 = _idaapi.IK_OEM_4
IK_OEM_5 = _idaapi.IK_OEM_5
IK_OEM_6 = _idaapi.IK_OEM_6
IK_OEM_7 = _idaapi.IK_OEM_7
IK_OEM_102 = _idaapi.IK_OEM_102
IK_PLAY = _idaapi.IK_PLAY
IK_ZOOM = _idaapi.IK_ZOOM
IK_OEM_CLEAR = _idaapi.IK_OEM_CLEAR
CB_INIT = _idaapi.CB_INIT
CB_YES = _idaapi.CB_YES
CB_CLOSE = _idaapi.CB_CLOSE
class disasm_text_t(object):
    """
    Proxy of C++ qvector<(disasm_line_t)> class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> disasm_text_t
        __init__(self, x) -> disasm_text_t
        """
        this = _idaapi.new_disasm_text_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_disasm_text_t
    __del__ = lambda self : None;
    def push_back(self, *args):
        """
        push_back(self, x)
        push_back(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_push_back(self, *args)

    def pop_back(self, *args):
        """
        pop_back(self)
        """
        return _idaapi.disasm_text_t_pop_back(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.disasm_text_t_size(self, *args)

    def empty(self, *args):
        """
        empty(self) -> bool
        """
        return _idaapi.disasm_text_t_empty(self, *args)

    def at(self, *args):
        """
        at(self, _idx) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_at(self, *args)

    def front(self, *args):
        """
        front(self) -> disasm_line_t
        front(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_front(self, *args)

    def back(self, *args):
        """
        back(self) -> disasm_line_t
        back(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_back(self, *args)

    def qclear(self, *args):
        """
        qclear(self)
        """
        return _idaapi.disasm_text_t_qclear(self, *args)

    def clear(self, *args):
        """
        clear(self)
        """
        return _idaapi.disasm_text_t_clear(self, *args)

    def resize(self, *args):
        """
        resize(self, _newsize, x)
        resize(self, _newsize)
        """
        return _idaapi.disasm_text_t_resize(self, *args)

    def grow(self, *args):
        """
        grow(self, x=disasm_line_t())
        """
        return _idaapi.disasm_text_t_grow(self, *args)

    def capacity(self, *args):
        """
        capacity(self) -> size_t
        """
        return _idaapi.disasm_text_t_capacity(self, *args)

    def reserve(self, *args):
        """
        reserve(self, cnt)
        """
        return _idaapi.disasm_text_t_reserve(self, *args)

    def truncate(self, *args):
        """
        truncate(self)
        """
        return _idaapi.disasm_text_t_truncate(self, *args)

    def swap(self, *args):
        """
        swap(self, r)
        """
        return _idaapi.disasm_text_t_swap(self, *args)

    def extract(self, *args):
        """
        extract(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_extract(self, *args)

    def inject(self, *args):
        """
        inject(self, s, len)
        """
        return _idaapi.disasm_text_t_inject(self, *args)

    def begin(self, *args):
        """
        begin(self) -> disasm_line_t
        begin(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_begin(self, *args)

    def end(self, *args):
        """
        end(self) -> disasm_line_t
        end(self) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_end(self, *args)

    def insert(self, *args):
        """
        insert(self, it, x) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_insert(self, *args)

    def erase(self, *args):
        """
        erase(self, it) -> disasm_line_t
        erase(self, first, last) -> disasm_line_t
        """
        return _idaapi.disasm_text_t_erase(self, *args)

    def __len__(self, *args):
        """
        __len__(self) -> size_t
        """
        return _idaapi.disasm_text_t___len__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, i) -> disasm_line_t
        """
        return _idaapi.disasm_text_t___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, i, v)
        """
        return _idaapi.disasm_text_t___setitem__(self, *args)

    __iter__ = _bounded_getitem_iterator

disasm_text_t_swigregister = _idaapi.disasm_text_t_swigregister
disasm_text_t_swigregister(disasm_text_t)


def choose_choose(*args):
  """
    choose_choose(self, flags, x0, y0, x1, y1, width, deflt, icon) -> uint32
    choose_choose(self, flags, x0, y0, x1, y1, width, deflt, icon) -> uint32
    """
  return _idaapi.choose_choose(*args)
#<pycode(py_kernwin)>
DP_LEFT           = 0x0001
DP_TOP            = 0x0002
DP_RIGHT          = 0x0004
DP_BOTTOM         = 0x0008
DP_INSIDE         = 0x0010
# if not before, then it is after
# (use DP_INSIDE | DP_BEFORE to insert a tab before a given tab)
# this flag alone cannot be used to determine orientation
DP_BEFORE         = 0x0020
# used with combination of other flags
DP_TAB            = 0x0040
DP_FLOATING       = 0x0080

# ----------------------------------------------------------------------
def 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

    If file_name is passed then the other two arguments are ignored.

    @param file_name: The icon file name
    @param data: The icon data
    @param format: The icon data format

    @return: Icon id or 0 on failure.
             Use free_custom_icon() to free it
    """
    if file_name is not None:
       return _idaapi.py_load_custom_icon_fn(file_name)
    elif not (data is None and format is None):
       return _idaapi.py_load_custom_icon_data(data, format)
    else:
      return 0

# ----------------------------------------------------------------------
def asklong(defval, format):
    res, val = _idaapi._asklong(defval, format)

    if res == 1:
        return val
    else:
        return None

# ----------------------------------------------------------------------
def askaddr(defval, format):
    res, ea = _idaapi._askaddr(defval, format)

    if res == 1:
        return ea
    else:
        return None

# ----------------------------------------------------------------------
def askseg(defval, format):
    res, sel = _idaapi._askseg(defval, format)

    if res == 1:
        return sel
    else:
        return None

# ----------------------------------------------------------------------
class action_handler_t:
    def __init__(self):
        pass

    def activate(self, ctx):
	return 0

    def update(self, ctx):
        pass



class Choose2(object):
    """
    Choose2 wrapper class.

    Some constants are defined in this class. Please refer to kernwin.hpp for more information.
    """

    CH_MODAL        = 0x01
    """
    Modal chooser
    """

    CH_MULTI        = 0x02
    """
    Allow multi selection
    """

    CH_MULTI_EDIT   = 0x04
    CH_NOBTNS       = 0x08
    CH_ATTRS        = 0x10
    CH_NOIDB        = 0x20
    """
    use the chooser even without an open database, same as x0=-2
    """
    CH_UTF8         = 0x40
    """
    string encoding is utf-8
    """

    CH_BUILTIN_MASK = 0xF80000

    # column flags (are specified in the widths array)
    CHCOL_PLAIN  =  0x00000000
    CHCOL_PATH   =  0x00010000
    CHCOL_HEX    =  0x00020000
    CHCOL_DEC    =  0x00030000
    CHCOL_FORMAT =  0x00070000


    def __init__(self, title, cols, flags=0, popup_names=None,
                 icon=-1, x1=-1, y1=-1, x2=-1, y2=-1, deflt=-1,
                 embedded=False, width=None, height=None):
        """
        Constructs a chooser window.
        @param title: The chooser title
        @param cols: a list of colums; each list item is a list of two items
            example: [ ["Address", 10 | Choose2.CHCOL_HEX], ["Name", 30 | Choose2.CHCOL_PLAIN] ]
        @param flags: One of CH_XXXX constants
        @param deflt: Default starting item
        @param popup_names: list of new captions to replace this list ["Insert", "Delete", "Edit", "Refresh"]
        @param icon: Icon index (the icon should exist in ida resources or an index to a custom loaded icon)
        @param x1, y1, x2, y2: The default location
        @param embedded: Create as embedded chooser
        @param width: Embedded chooser width
        @param height: Embedded chooser height
        """
        self.title = title
        self.flags = flags
        self.cols = cols
        self.deflt = deflt
        self.popup_names = popup_names
        self.icon = icon
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2
        self.embedded = embedded
        if embedded:
	        self.x1 = width
	        self.y1 = height


    def Embedded(self):
        """
        Creates an embedded chooser (as opposed to Show())
        @return: Returns 1 on success
        """
        return _idaapi.choose2_create(self, True)


    def GetEmbSelection(self):
        """
        Returns the selection associated with an embedded chooser

        @return:
            - None if chooser is not embedded
            - A list with selection indices (0-based)
        """
        return _idaapi.choose2_get_embedded_selection(self)


    def Show(self, modal=False):
        """
        Activates or creates a chooser window
        @param modal: Display as modal dialog
        @return: For modal choosers it will return the selected item index (0-based)
        """
        if modal:
            self.flags |= Choose2.CH_MODAL

            # Disable the timeout
            old = _idaapi.set_script_timeout(0)
            n = _idaapi.choose2_create(self, False)
            _idaapi.set_script_timeout(old)

            # Delete the modal chooser instance
            self.Close()

            return n
        else:
            self.flags &= ~Choose2.CH_MODAL
            return _idaapi.choose2_create(self, False)


    def Activate(self):
        """
        Activates a visible chooser
        """
        return _idaapi.choose2_activate(self)


    def Refresh(self):
        """
        Causes the refresh callback to trigger
        """
        return _idaapi.choose2_refresh(self)


    def Close(self):
        """
        Closes the chooser
        """
        return _idaapi.choose2_close(self)


    def AddCommand(self,
                   caption,
                   flags = _idaapi.CHOOSER_POPUP_MENU,
                   menu_index = -1,
                   icon = -1,
				   emb=None):
        """
        Deprecated: Use
          - register_action()
          - attach_action_to_menu()
          - attach_action_to_popup()
        """
        # Use the 'emb' as a sentinel. It will be passed the correct value from the EmbeddedChooserControl
        if self.embedded and ((emb is None) or (emb != 2002)):
            raise RuntimeError("Please add a command through EmbeddedChooserControl.AddCommand()")
        return _idaapi.choose2_add_command(self, caption, flags, menu_index, icon)

    #
    # Implement these methods in the subclass:
    #
#<pydoc>
#    def OnClose(self):
#        """
#        Called when the window is being closed.
#        This callback is mandatory.
#        @return: nothing
#        """
#        pass
#
#    def OnGetLine(self, n):
#        """Called when the chooser window requires lines.
#        This callback is mandatory.
#        @param n: Line number (0-based)
#        @return: The user should return a list with ncols elements.
#            example: a list [col1, col2, col3, ...] describing the n-th line
#        """
#        return ["col1 val", "col2 val"]
#
#    def OnGetSize(self):
#        """Returns the element count.
#        This callback is mandatory.
#        @return: Number of elements
#        """
#        return len(self.the_list)
#
#    def OnEditLine(self, n):
#        """
#        Called when an item is being edited.
#        @param n: Line number (0-based)
#        @return: Nothing
#        """
#        pass
#
#    def OnInsertLine(self):
#        """
#        Called when 'Insert' is selected either via the hotkey or popup menu.
#        @return: Nothing
#        """
#        pass
#
#    def OnSelectLine(self, n):
#        """
#        Called when a line is selected and then Ok or double click was pressed
#        @param n: Line number (0-based)
#        """
#        pass
#
#    def OnSelectionChange(self, sel_list):
#        """
#        Called when the selection changes
#        @param sel_list: A list of selected item indices
#        """
#        pass
#
#    def OnDeleteLine(self, n):
#        """
#        Called when a line is about to be deleted
#        @param n: Line number (0-based)
#        """
#        return self.n
#
#    def OnRefresh(self, n):
#        """
#        Triggered when the 'Refresh' is called from the popup menu item.
#
#        @param n: The currently selected line (0-based) at the time of the refresh call
#        @return: Return the number of elements
#        """
#        return self.n
#
#    def OnRefreshed(self):
#        """
#        Triggered when a refresh happens (for example due to column sorting)
#        @param n: Line number (0-based)
#        @return: Return the number of elements
#        """
#        return self.n
#
#    def OnCommand(self, n, cmd_id):
#        """Return int ; check add_chooser_command()"""
#        return 0
#
#    def OnGetIcon(self, n):
#        """
#        Return icon number for a given item (or -1 if no icon is avail)
#        @param n: Line number (0-based)
#        """
#        return -1
#
#    def OnGetLineAttr(self, n):
#        """
#        Return list [bgcolor, flags=CHITEM_XXXX] or None; check chooser_item_attrs_t
#        @param n: Line number (0-based)
#        """
#        return [0x0, CHITEM_BOLD]
#</pydoc>


#ICON WARNING|QUESTION|INFO|NONE
#AUTOHIDE NONE|DATABASE|REGISTRY|SESSION
#HIDECANCEL
#BUTTON YES|NO|CANCEL "Value|NONE"
#STARTITEM {id:ItemName}
#HELP / ENDHELP
try:
    import types
    from ctypes import *
    # On Windows, we use stdcall

    # Callback for buttons
    # typedef void (idaapi *formcb_t)(TView *fields[], int code);

    _FORMCB_T = WINFUNCTYPE(None, c_void_p, c_int)

    # Callback for form change
    # typedef int (idaapi *formchgcb_t)(int field_id, form_actions_t &fa);
    _FORMCHGCB_T = WINFUNCTYPE(c_int, c_int, c_void_p)
except:
    try:
        _FORMCB_T    = CFUNCTYPE(None, c_void_p, c_int)
        _FORMCHGCB_T = CFUNCTYPE(c_int, c_int, c_void_p)
    except:
        _FORMCHGCB_T = _FORMCB_T = None


# -----------------------------------------------------------------------
# textctrl_info_t clinked object
class textctrl_info_t(py_clinked_object_t):
    """
    Class representing textctrl_info_t
    """

    # Some constants
    TXTF_AUTOINDENT = 0x0001
    """
    Auto-indent on new line
    """
    TXTF_ACCEPTTABS = 0x0002
    """
    Tab key inserts 'tabsize' spaces
    """
    TXTF_READONLY   = 0x0004
    """
    Text cannot be edited (but can be selected and copied)
    """
    TXTF_SELECTED   = 0x0008
    """
    Shows the field with its text selected
    """
    TXTF_MODIFIED   = 0x0010
    """
    Gets/sets the modified status
    """
    TXTF_FIXEDFONT  = 0x0020
    """
    The control uses IDA's fixed font
    """

    def __init__(self, text="", flags=0, tabsize=0):
        py_clinked_object_t.__init__(self)
        if text:
            self.text = text
        if flags:
            self.flags = flags
        if tabsize:
            self.tabsize = tabsize

    def _create_clink(self):
        return _idaapi.textctrl_info_t_create()

    def _del_clink(self, lnk):
        return _idaapi.textctrl_info_t_destroy(lnk)

    def _get_clink_ptr(self):
        return _idaapi.textctrl_info_t_get_clink_ptr(self)

    def assign(self, other):
        """
        Copies the contents of 'other' to 'self'
        """
        return _idaapi.textctrl_info_t_assign(self, other)

    def __set_text(self, s):
        """
        Sets the text value
        """
        return _idaapi.textctrl_info_t_set_text(self, s)

    def __get_text(self):
        """
        Sets the text value
        """
        return _idaapi.textctrl_info_t_get_text(self)

    def __set_flags__(self, flags):
        """
        Sets the flags value
        """
        return _idaapi.textctrl_info_t_set_flags(self, flags)

    def __get_flags__(self):
        """
        Returns the flags value
        """
        return _idaapi.textctrl_info_t_get_flags(self)

    def __set_tabsize__(self, tabsize):
        """
        Sets the tabsize value
        """
        return _idaapi.textctrl_info_t_set_tabsize(self, tabsize)

    def __get_tabsize__(self):
        """
        Returns the tabsize value
        """
        return _idaapi.textctrl_info_t_get_tabsize(self)

    value   = property(__get_text, __set_text)
    """
    Alias for the text property
    """
    text    = property(__get_text, __set_text)
    """
    Text value
    """
    flags   = property(__get_flags__, __set_flags__)
    """
    Flags value
    """
    tabsize = property(__get_tabsize__, __set_tabsize__)

# -----------------------------------------------------------------------
class Form(object):

    FT_ASCII = 'A'
    """
    Ascii string - char *
    """
    FT_SEG = 'S'
    """
    Segment - sel_t *
    """
    FT_HEX = 'N'
    """
    Hex number - uval_t *
    """
    FT_SHEX = 'n'
    """
    Signed hex number - sval_t *
    """
    FT_COLOR = 'K'
    """
    Color button - bgcolor_t *
    """
    FT_ADDR = '$'
    """
    Address - ea_t *
    """
    FT_UINT64 = 'L'
    """
    default base uint64 - uint64
    """
    FT_INT64 = 'l'
    """
    default base int64 - int64
    """
    FT_RAWHEX = 'M'
    """
    Hex number, no 0x prefix - uval_t *
    """
    FT_FILE = 'f'
    """
    File browse - char * at least QMAXPATH
    """
    FT_DEC = 'D'
    """
    Decimal number - sval_t *
    """
    FT_OCT = 'O'
    """
    Octal number, C notation - sval_t *
    """
    FT_BIN = 'Y'
    """
    Binary number, 0b prefix - sval_t *
    """
    FT_CHAR = 'H'
    """
    Char value -- sval_t *
    """
    FT_IDENT = 'I'
    """
    Identifier - char * at least MAXNAMELEN
    """
    FT_BUTTON = 'B'
    """
    Button - def handler(code)
    """
    FT_DIR = 'F'
    """
    Path to directory - char * at least QMAXPATH
    """
    FT_TYPE = 'T'
    """
    Type declaration - char * at least MAXSTR
    """
    _FT_USHORT = '_US'
    """
    Unsigned short
    """
    FT_FORMCHG = '%/'
    """
    Form change callback - formchgcb_t
    """
    FT_ECHOOSER = 'E'
    """
    Embedded chooser - idaapi.Choose2
    """
    FT_MULTI_LINE_TEXT = 't'
    """
    Multi text control - textctrl_info_t
    """
    FT_DROPDOWN_LIST   = 'b'
    """
    Dropdown list control - Form.DropdownControl
    """

    FT_CHKGRP = 'C'
    FT_CHKGRP2= 'c'
    FT_RADGRP = 'R'
    FT_RADGRP2= 'r'

    @staticmethod
    def fieldtype_to_ctype(tp, i64 = False):
        """
        Factory method returning a ctype class corresponding to the field type string
        """
        if tp in (Form.FT_SEG, Form.FT_HEX, Form.FT_RAWHEX, Form.FT_ADDR):
            return c_ulonglong if i64 else c_ulong
        elif tp in (Form.FT_SHEX, Form.FT_DEC, Form.FT_OCT, Form.FT_BIN, Form.FT_CHAR):
            return c_longlong if i64 else c_long
        elif tp == Form.FT_UINT64:
            return c_ulonglong
        elif tp == Form.FT_INT64:
            return c_longlong
        elif tp == Form.FT_COLOR:
            return c_ulong
        elif tp == Form._FT_USHORT:
            return c_ushort
        elif tp in (Form.FT_FORMCHG, Form.FT_ECHOOSER):
            return c_void_p
        else:
            return None


    #
    # Generic argument helper classes
    #
    class NumericArgument(object):
        """
        Argument representing various integer arguments (ushort, uint32, uint64, etc...)
        @param tp: One of Form.FT_XXX
        """
        DefI64 = False
        def __init__(self, tp, value):
            cls = Form.fieldtype_to_ctype(tp, self.DefI64)
            if cls is None:
                raise TypeError("Invalid numeric field type: %s" % tp)
            # Get a pointer type to the ctype type
            self.arg = pointer(cls(value))

        def __set_value(self, v):
            self.arg.contents.value = v
        value = property(lambda self: self.arg.contents.value, __set_value)


    class StringArgument(object):
        """
        Argument representing a character buffer
        """
        def __init__(self, size=None, value=None):
            if size is None:
                raise SyntaxError("The string size must be passed")

            if value is None:
                self.arg = create_string_buffer(size)
            else:
                self.arg = create_string_buffer(value, size)
            self.size = size

        def __set_value(self, v):
            self.arg.value = v
        value = property(lambda self: self.arg.value, __set_value)


    #
    # Base control class
    #
    class Control(object):
        def __init__(self):
            self.id = 0
            """
            Automatically assigned control ID
            """

            self.arg = None
            """
            Control argument value. This could be one element or a list/tuple (for multiple args per control)
            """

            self.form = None
            """
            Reference to the parent form. It is filled by Form.Add()
            """


        def get_tag(self):
            """
            Control tag character. One of Form.FT_XXXX.
            The form class will expand the {} notation and replace them with the tags
            """
            pass

        def get_arg(self):
            """
            Control returns the parameter to be pushed on the stack
            (Of AskUsingForm())
            """
            return self.arg

        def free(self):
            """
            Free the control
            """
            # Release the parent form reference
            self.form = None


    #
    # Label controls
    #
    class LabelControl(Control):
        """
        Base class for static label control
        """
        def __init__(self, tp):
            Form.Control.__init__(self)
            self.tp = tp

        def get_tag(self):
            return '%%%d%s' % (self.id, self.tp)


    class StringLabel(LabelControl):
        """
        String label control
        """
        def __init__(self, value, tp=None, sz=1024):
            """
            Type field can be one of:
            A - ascii string
            T - type declaration
            I - ident
            F - folder
            f - file
            X - command
            """
            if tp is None:
                tp = Form.FT_ASCII
            Form.LabelControl.__init__(self, tp)
            self.size  = sz
            self.arg = create_string_buffer(value, sz)


    class NumericLabel(LabelControl, NumericArgument):
        """
        Numeric label control
        """
        def __init__(self, value, tp=None):
            if tp is None:
                tp = Form.FT_HEX
            Form.LabelControl.__init__(self, tp)
            Form.NumericArgument.__init__(self, tp, value)


    #
    # Group controls
    #
    class GroupItemControl(Control):
        """
        Base class for group control items
        """
        def __init__(self, tag, parent):
            Form.Control.__init__(self)
            self.tag = tag
            self.parent = parent
            # Item position (filled when form is compiled)
            self.pos = 0

        def assign_pos(self):
            self.pos = self.parent.next_child_pos()

        def get_tag(self):
            return "%s%d" % (self.tag, self.id)


    class ChkGroupItemControl(GroupItemControl):
        """
        Checkbox group item control
        """
        def __init__(self, tag, parent):
            Form.GroupItemControl.__init__(self, tag, parent)

        def __get_value(self):
            return (self.parent.value & (1 << self.pos)) != 0

        def __set_value(self, v):
            pv = self.parent.value
            if v:
                pv = pv | (1 << self.pos)
            else:
                pv = pv & ~(1 << self.pos)

            self.parent.value = pv

        checked = property(__get_value, __set_value)
        """
        Get/Sets checkbox item check status
        """


    class RadGroupItemControl(GroupItemControl):
        """
        Radiobox group item control
        """
        def __init__(self, tag, parent):
            Form.GroupItemControl.__init__(self, tag, parent)

        def __get_value(self):
            return self.parent.value == self.pos

        def __set_value(self, v):
            self.parent.value = self.pos

        selected = property(__get_value, __set_value)
        """
        Get/Sets radiobox item selection status
        """


    class GroupControl(Control, NumericArgument):
        """
        Base class for group controls
        """
        def __init__(self, children_names, tag, value=0):
            Form.Control.__init__(self)
            self.children_names = children_names
            self.tag = tag
            self._reset()
            Form.NumericArgument.__init__(self, Form._FT_USHORT, value)

        def _reset(self):
            self.childpos = 0

        def next_child_pos(self):
            v = self.childpos
            self.childpos += 1
            return v

        def get_tag(self):
            return "%d" % self.id


    class ChkGroupControl(GroupControl):
        """
        Checkbox group control class.
        It holds a set of checkbox controls
        """
        ItemClass = None
        """
        Group control item factory class instance
        We need this because later we won't be treating ChkGroupControl or RadGroupControl
        individually, instead we will be working with GroupControl in general.
        """
        def __init__(self, children_names, value=0, secondary=False):
            # Assign group item factory class
            if Form.ChkGroupControl.ItemClass is None:
                Form.ChkGroupControl.ItemClass = Form.ChkGroupItemControl

            Form.GroupControl.__init__(
                self,
                children_names,
                Form.FT_CHKGRP2 if secondary else Form.FT_CHKGRP,
                value)


    class RadGroupControl(GroupControl):
        """
        Radiobox group control class.
        It holds a set of radiobox controls
        """
        ItemClass = None
        def __init__(self, children_names, value=0, secondary=False):
            """
            Creates a radiogroup control.
            @param children_names: A tuple containing group item names
            @param value: Initial selected radio item
            @param secondory: Allows rendering one the same line as the previous group control.
                              Use this if you have another group control on the same line.
            """
            # Assign group item factory class
            if Form.RadGroupControl.ItemClass is None:
                Form.RadGroupControl.ItemClass = Form.RadGroupItemControl

            Form.GroupControl.__init__(
                self,
                children_names,
                Form.FT_RADGRP2 if secondary else Form.FT_RADGRP,
                value)


    #
    # Input controls
    #
    class InputControl(Control):
        """
        Generic form input control.
        It could be numeric control, string control, directory/file browsing, etc...
        """
        def __init__(self, tp, width, swidth, hlp = None):
            """
            @param width: Display width
            @param swidth: String width
            """
            Form.Control.__init__(self)
            self.tp = tp
            self.width = width
            self.switdh = swidth
            self.hlp = hlp

        def get_tag(self):
            return "%s%d:%s:%s:%s" % (
                self.tp, self.id,
                self.width,
                self.switdh,
                ":" if self.hlp is None else self.hlp)


    class NumericInput(InputControl, NumericArgument):
        """
        A composite class serving as a base numeric input control class
        """
        def __init__(self, tp=None, value=0, width=50, swidth=10, hlp=None):
            if tp is None:
                tp = Form.FT_HEX
            Form.InputControl.__init__(self, tp, width, swidth, hlp)
            Form.NumericArgument.__init__(self, self.tp, value)


    class ColorInput(NumericInput):
        """
        Color button input control
        """
        def __init__(self, value = 0):
            """
            @param value: Initial color value in RGB
            """
            Form.NumericInput.__init__(self, tp=Form.FT_COLOR, value=value)


    class StringInput(InputControl, StringArgument):
        """
        Base string input control class.
        This class also constructs a StringArgument
        """
        def __init__(self,
                     tp=None,
                     width=1024,
                     swidth=40,
                     hlp=None,
                     value=None,
                     size=None):
            """
            @param width: String size. But in some cases it has special meaning. For example in FileInput control.
                          If you want to define the string buffer size then pass the 'size' argument
            @param swidth: Control width
            @param value: Initial value
            @param size: String size
            """
            if tp is None:
                tp = Form.FT_ASCII
            if not size:
                size = width
            Form.InputControl.__init__(self, tp, width, swidth, hlp)
            Form.StringArgument.__init__(self, size=size, value=value)


    class FileInput(StringInput):
        """
        File Open/Save input control
        """
        def __init__(self,
                     width=512,
                     swidth=80,
                     save=False, open=False,
                     hlp=None, value=None):

            if save == open:
                raise ValueError("Invalid mode. Choose either open or save")
            if width < 512:
                raise ValueError("Invalid width. Must be greater than 512.")

            # The width field is overloaded in this control and is used
            # to denote the type of the FileInput dialog (save or load)
            # On the other hand it is passed as is to the StringArgument part
            Form.StringInput.__init__(
                self,
                tp=Form.FT_FILE,
                width="1" if save else "0",
                swidth=swidth,
                hlp=hlp,
                size=width,
                value=value)


    class DirInput(StringInput):
        """
        Directory browsing control
        """
        def __init__(self,
                     width=512,
                     swidth=80,
                     hlp=None,
                     value=None):

            if width < 512:
                raise ValueError("Invalid width. Must be greater than 512.")

            Form.StringInput.__init__(
                self,
                tp=Form.FT_DIR,
                width=width,
                swidth=swidth,
                hlp=hlp,
                size=width,
                value=value)


    class ButtonInput(InputControl):
        """
        Button control.
        A handler along with a 'code' (numeric value) can be associated with the button.
        This way one handler can handle many buttons based on the button code (or in other terms id or tag)
        """
        def __init__(self, handler, code="", swidth="", hlp=None):
            """
            @param handler: Button handler. A callback taking one argument which is the code.
            @param code: A code associated with the button and that is later passed to the handler.
            """
            Form.InputControl.__init__(
                self,
                Form.FT_BUTTON,
                code,
                swidth,
                hlp)
            self.arg = _FORMCB_T(lambda view, code, h=handler: h(code))


    class FormChangeCb(Control):
        """
        Form change handler.
        This can be thought of like a dialog procedure.
        Everytime a form action occurs, this handler will be called along with the control id.
        The programmer can then call various form actions accordingly:
          - EnableField
          - ShowField
          - MoveField
          - GetFieldValue
          - etc...

        Special control IDs: -1 (The form is initialized) and -2 (Ok has been clicked)

        """
        def __init__(self, handler):
            """
            Constructs the handler.
            @param handler: The handler (preferrably a member function of a class derived from the Form class).
            """
            Form.Control.__init__(self)

            # Save the handler
            self.handler = handler

            # Create a callback stub
            # We use this mechanism to create an intermediate step
            # where we can create an 'fa' adapter for use by Python
            self.arg = _FORMCHGCB_T(self.helper_cb)

        def helper_cb(self, fid, p_fa):
            # Remember the pointer to the forms_action in the parent form
            self.form.p_fa = p_fa

            # Call user's handler
            r = self.handler(fid)
            return 0 if r is None else r

        def get_tag(self):
            return Form.FT_FORMCHG

        def free(self):
            Form.Control.free(self)
            # Remove reference to the handler
            # (Normally the handler is a member function in the parent form)
            self.handler = None


    class EmbeddedChooserControl(InputControl):
        """
        Embedded chooser control.
        This control links to a Chooser2 control created with the 'embedded=True'
        """
        def __init__(self,
                     chooser=None,
                     swidth=40,
                     hlp=None):
            """
            Embedded chooser control

            @param chooser: A chooser2 instance (must be constructed with 'embedded=True')
            """

            # !! Make sure a chooser instance is passed !!
            if chooser is None or not isinstance(chooser, Choose2):
                raise ValueError("Invalid chooser passed.")

            # Create an embedded chooser structure from the Choose2 instance
            if chooser.Embedded() != 1:
                raise ValueError("Failed to create embedded chooser instance.")

            # Construct input control
            Form.InputControl.__init__(self, Form.FT_ECHOOSER, "", swidth)

            # Get a pointer to the chooser_info_t and the selection vector
            # (These two parameters are the needed arguments for the AskUsingForm())
            emb, sel = _idaapi.choose2_get_embedded(chooser)

            # Get a pointer to a c_void_p constructed from an address
            p_embedded = pointer(c_void_p.from_address(emb))
            p_sel      = pointer(c_void_p.from_address(sel))

            # - Create the embedded chooser info on control creation
            # - Do not free the embeded chooser because after we get the args
            #   via Compile() the user can still call Execute() which relies
            #   on the already computed args
            self.arg   = (p_embedded, p_sel)

            # Save chooser instance
            self.chooser = chooser

            # Add a bogus 'size' attribute
            self.size = 0


        value = property(lambda self: self.chooser)
        """
        Returns the embedded chooser instance
        """


        def AddCommand(self,
                       caption,
                       flags = _idaapi.CHOOSER_POPUP_MENU,
                       menu_index = -1,
                       icon = -1):
            """
            Adds a new embedded chooser command
            Save the returned value and later use it in the OnCommand handler

            @return: Returns a negative value on failure or the command index
            """
            if not self.form.title:
                raise ValueError("Form title is not set!")

            # Encode all information for the AddCommand() in the 'caption' parameter
            caption = "%s:%d:%s" % (self.form.title, self.id, caption)
            return self.chooser.AddCommand(caption, flags=flags, menu_index=menu_index, icon=icon, emb=2002)


        def free(self):
            """
            Frees the embedded chooser data
            """
            self.chooser.Close()
            self.chooser = None
            Form.Control.free(self)


    class DropdownListControl(InputControl, _qstrvec_t):
        """
        Dropdown control
        This control allows manipulating a dropdown control
        """
        def __init__(self, items=[], readonly=True, selval=0, width=50, swidth=50, hlp = None):
            """
            @param items: A string list of items used to prepopulate the control
            @param readonly: Specifies whether the dropdown list is editable or not
            @param selval: The preselected item index (when readonly) or text value (when editable)
            @param width: the control width (n/a if the dropdown list is readonly)
            @param swidth: string width
            """

            # Ignore the width if readonly was set
            if readonly:
                width = 0

            # Init the input control base class
            Form.InputControl.__init__(
                self,
                Form.FT_DROPDOWN_LIST,
                width,
                swidth,
                hlp)

            # Init the associated qstrvec
            _qstrvec_t.__init__(self, items)

            # Remember if readonly or not
            self.readonly = readonly

            if readonly:
                # Create a C integer and remember it
                self.__selval = c_int(selval)
                val_addr      = addressof(self.__selval)
            else:
                # Create an strvec with one qstring
                self.__selval = _qstrvec_t([selval])
                # Get address of the first element
                val_addr      = self.__selval.addressof(0)

            # Two arguments:
            # - argument #1: a pointer to the qstrvec containing the items
            # - argument #2: an integer to hold the selection
            #         or
            #            #2: a qstring to hold the dropdown text control value
            self.arg = (
                pointer(c_void_p.from_address(self.clink_ptr)),
                pointer(c_void_p.from_address(val_addr))
            )


        def __set_selval(self, val):
            if self.readonly:
                self.__selval.value = val
            else:
                self.__selval[0] = val

        def __get_selval(self):
            # Return the selection index
            # or the entered text value
            return self.__selval.value if self.readonly else self.__selval[0]

        value  = property(__get_selval, __set_selval)
        selval = property(__get_selval, __set_selval)
        """
        Read/write the selection value.
        The value is used as an item index in readonly mode or text value in editable mode
        This value can be used only after the form has been closed.
        """

        def free(self):
            self._free()


        def set_items(self, items):
            """
            Sets the dropdown list items
            """
            self.from_list(items)


    class MultiLineTextControl(InputControl, textctrl_info_t):
        """
        Multi line text control.
        This class inherits from textctrl_info_t. Thus the attributes are also inherited
        This control allows manipulating a multilinetext control
        """
        def __init__(self, text="", flags=0, tabsize=0, width=50, swidth=50, hlp = None):
            """
            @param text: Initial text value
            @param flags: One of textctrl_info_t.TXTF_.... values
            @param tabsize: Tab size
            @param width: Display width
            @param swidth: String width
            """
            # Init the input control base class
            Form.InputControl.__init__(self, Form.FT_MULTI_LINE_TEXT, width, swidth, hlp)

            # Init the associated textctrl_info base class
            textctrl_info_t.__init__(self, text=text, flags=flags, tabsize=tabsize)

            # Get the argument as a pointer from the embedded ti
            self.arg = pointer(c_void_p.from_address(self.clink_ptr))


        def free(self):
            self._free()


    #
    # Form class
    #
    def __init__(self, form, controls):
        """
        Contruct a Form class.
        This class wraps around AskUsingForm() or OpenForm() and provides an easier / alternative syntax for describing forms.
        The form control names are wrapped inside the opening and closing curly braces and the control themselves are
        defined and instantiated via various form controls (subclasses of Form).

        @param form: The form string
        @param controls: A dictionary containing the control name as a _key_ and control object as _value_
        """
        self._reset()
        self.form = form
        """
        Form string
        """
        self.controls = controls
        """
        Dictionary of controls
        """
        self.__args = None

        self.title = None
        """
        The Form title. It will be filled when the form is compiled
        """

        self.modal = True
        """
        By default, forms are modal
        """

        self.openform_flags = 0
        """
        If non-modal, these flags will be passed to OpenForm.
        This is an OR'ed combination of the PluginForm.FORM_* values.
        """


    def Free(self):
        """
        Frees all resources associated with a compiled form.
        Make sure you call this function when you finish using the form.
        """

        # Free all the controls
        for ctrl in self.__controls.values():
             ctrl.free()

        # Reset the controls
        # (Note that we are not removing the form control attributes, no need)
        self._reset()

        # Unregister, so we don't try and free it again at closing-time.
        _idaapi.py_unregister_compiled_form(self)


    def _reset(self):
        """
        Resets the Form class state variables
        """
        self.__controls = {}
        self.__ctrl_id = 1


    def __getitem__(self, name):
        """
        Returns a control object by name
        """
        return self.__controls[name]


    def Add(self, name, ctrl, mkattr = True):
        """
        Low level function. Prefer AddControls() to this function.
        This function adds one control to the form.

        @param name: Control name
        @param ctrl: Control object
        @param mkattr: Create control name / control object as a form attribute
        """
        # Assign a unique ID
        ctrl.id = self.__ctrl_id
        self.__ctrl_id += 1

        # Create attribute with control name
        if mkattr:
            setattr(self, name, ctrl)

        # Remember the control
        self.__controls[name] = ctrl

        # Link the form to the control via its form attribute
        ctrl.form = self

        # Is it a group? Add each child
        if isinstance(ctrl, Form.GroupControl):
            self._AddGroup(ctrl, mkattr)


    def FindControlById(self, id):
        """
        Finds a control instance given its id
        """
        for ctrl in self.__controls.values():
            if ctrl.id == id:
                return ctrl
        return None


    @staticmethod
    def _ParseFormTitle(form):
        """
        Parses the form's title from the form text
        """
        help_state = 0
        for i, line in enumerate(form.split("\n")):
            if line.startswith("STARTITEM ") or line.startswith("BUTTON "):
                continue
            # Skip "HELP" and remember state
            elif help_state == 0 and line == "HELP":
                help_state = 1 # Mark inside HELP
                continue
            elif help_state == 1 and line == "ENDHELP":
                help_state = 2 # Mark end of HELP
                continue
            return line.strip()

        return None


    def _AddGroup(self, Group, mkattr=True):
        """
        Internal function.
        This function expands the group item names and creates individual group item controls

        @param Group: The group class (checkbox or radio group class)
        """

        # Create group item controls for each child
        for child_name in Group.children_names:
            self.Add(
                child_name,
                # Use the class factory
                Group.ItemClass(Group.tag, Group),
                mkattr)


    def AddControls(self, controls, mkattr=True):
        """
        Adds controls from a dictionary.
        The dictionary key is the control name and the value is a Form.Control object
        @param controls: The control dictionary
        """
        for name, ctrl in controls.items():
            # Add the control
            self.Add(name, ctrl, mkattr)


    def CompileEx(self, form):
        """
        Low level function.
        Compiles (parses the form syntax and adds the control) the form string and
        returns the argument list to be passed the argument list to AskUsingForm().

        The form controls are wrapped inside curly braces: {ControlName}.

        A special operator can be used to return the ID of a given control by its name: {id:ControlName}.
        This is useful when you use the STARTITEM form keyword to set the initially focused control.

        @param form: Compiles the form and returns the arguments needed to be passed to AskUsingForm()
        """
        # First argument is the form string
        args = [None]

        # Second argument, if form is not modal, is the set of flags
        if not self.modal:
            args.append(self.openform_flags | 0x80) # Add FORM_QWIDGET

        ctrlcnt = 1

        # Reset all group control internal flags
        for ctrl in self.__controls.values():
            if isinstance(ctrl, Form.GroupControl):
                ctrl._reset()

        p = 0
        while True:
            i1 = form.find("{", p)
            # No more items?
            if i1 == -1:
                break

            # Check if escaped
            if (i1 != 0) and form[i1-1] == "\\":
                # Remove escape sequence and restart search
                form = form[:i1-1] + form[i1:]

                # Skip current marker
                p = i1

                # Continue search
                continue

            i2 = form.find("}", i1)
            if i2 == -1:
                raise SyntaxError("No matching closing brace '}'")

            # Parse control name
            ctrlname = form[i1+1:i2]
            if not ctrlname:
                raise ValueError("Control %d has an invalid name!" % ctrlcnt)

            # Is it the IDOF operator?
            if ctrlname.startswith("id:"):
                idfunc = True
                # Take actual ctrlname
                ctrlname = ctrlname[3:]
            else:
                idfunc = False

            # Find the control
            ctrl = self.__controls.get(ctrlname, None)
            if ctrl is None:
                raise ValueError("No matching control '%s'" % ctrlname)

            # Replace control name by tag
            if idfunc:
                tag = str(ctrl.id)
            else:
                tag = ctrl.get_tag()
            taglen = len(tag)
            form = form[:i1] + tag + form[i2+1:]

            # Set new position
            p = i1 + taglen

            # Was it an IDOF() ? No need to push parameters
            # Just ID substitution is fine
            if idfunc:
                continue


            # For GroupItem controls, there are no individual arguments
            # The argument is assigned for the group itself
            if isinstance(ctrl, Form.GroupItemControl):
                # GroupItem controls will have their position dynamically set
                ctrl.assign_pos()
            else:
                # Push argument(s)
                # (Some controls need more than one argument)
                arg = ctrl.get_arg()
                if isinstance(arg, (types.ListType, types.TupleType)):
                    # Push all args
                    args.extend(arg)
                else:
                    # Push one arg
                    args.append(arg)

            ctrlcnt += 1

        # If no FormChangeCb instance was passed, and thus there's no '%/'
        # in the resulting form string, let's provide a minimal one, so that
        # we will retrieve 'p_fa', and thus actions that rely on it will work.
        if form.find(Form.FT_FORMCHG) < 0:
            form = form + Form.FT_FORMCHG
            fccb = Form.FormChangeCb(lambda *args: 1)
            self.Add("___dummyfchgcb", fccb)
            # Regardless of the actual position of '%/' in the form
            # string, a formchange callback _must_ be right after
            # the form string.
            if self.modal:
                inspos = 1
            else:
                inspos = 2
            args.insert(inspos, fccb.get_arg())

        # Patch in the final form string
        args[0] = form

        self.title = self._ParseFormTitle(form)
        return args


    def Compile(self):
        """
        Compiles a form and returns the form object (self) and the argument list.
        The form object will contain object names corresponding to the form elements

        @return: It will raise an exception on failure. Otherwise the return value is ignored
        """

        # Reset controls
        self._reset()

        # Insert controls
        self.AddControls(self.controls)

        # Compile form and get args
        self.__args = self.CompileEx(self.form)

        # Register this form, to make sure it will be freed at closing-time.
        _idaapi.py_register_compiled_form(self)

        return (self, self.__args)


    def Compiled(self):
        """
        Checks if the form has already been compiled

        @return: Boolean
        """
        return self.__args is not None


    def _ChkCompiled(self):
        if not self.Compiled():
            raise SyntaxError("Form is not compiled")


    def Execute(self):
        """
        Displays a modal dialog containing the compiled form.
        @return: 1 - ok ; 0 - cancel
        """
        self._ChkCompiled()
        if not self.modal:
            raise SyntaxError("Form is not modal. Open() should be instead")

        return AskUsingForm(*self.__args)


    def Open(self):
        """
        Opens a widget containing the compiled form.
        """
        self._ChkCompiled()
        if self.modal:
            raise SyntaxError("Form is modal. Execute() should be instead")

        OpenForm(*self.__args)


    def EnableField(self, ctrl, enable):
        """
        Enable or disable an input field
        @return: False - no such control
        """
        return _idaapi.formchgcbfa_enable_field(self.p_fa, ctrl.id, enable)


    def ShowField(self, ctrl, show):
        """
        Show or hide an input field
        @return: False - no such control
        """
        return _idaapi.formchgcbfa_show_field(self.p_fa, ctrl.id, show)


    def MoveField(self, ctrl, x, y, w, h):
        """
        Move/resize an input field

        @return: False - no such fiel
        """
        return _idaapi.formchgcbfa_move_field(self.p_fa, ctrl.id, x, y, w, h)


    def GetFocusedField(self):
        """
        Get currently focused input field.
        @return: None if no field is selected otherwise the control ID
        """
        id = _idaapi.formchgcbfa_get_focused_field(self.p_fa)
        return self.FindControlById(id)


    def SetFocusedField(self, ctrl):
        """
        Set currently focused input field
        @return: False - no such control
        """
        return _idaapi.formchgcbfa_set_focused_field(self.p_fa, ctrl.id)


    def RefreshField(self, ctrl):
        """
        Refresh a field
        @return: False - no such control
        """
        return _idaapi.formchgcbfa_refresh_field(self.p_fa, ctrl.id)


    def Close(self, close_normally):
        """
        Close the form
        @param close_normally:
                   1: form is closed normally as if the user pressed Enter
                   0: form is closed abnormally as if the user pressed Esc
        @return: None
        """
        return _idaapi.formchgcbfa_close(self.p_fa, close_normally)


    def GetControlValue(self, ctrl):
        """
        Returns the control's value depending on its type
        @param ctrl: Form control instance
        @return:
            - color button, radio controls: integer
            - file/dir input, string input and string label: string
            - embedded chooser control (0-based indices of selected items): integer list
            - for multilinetext control: textctrl_info_t
            - dropdown list controls: string (when editable) or index (when readonly)
            - None: on failure
        """
        tid, sz = self.ControlToFieldTypeIdAndSize(ctrl)
        r = _idaapi.formchgcbfa_get_field_value(
                    self.p_fa,
                    ctrl.id,
                    tid,
                    sz)
        # Multilinetext? Unpack the tuple into a new textctrl_info_t instance
        if r is not None and tid == 7:
            return textctrl_info_t(text=r[0], flags=r[1], tabsize=r[2])
        else:
            return r


    def SetControlValue(self, ctrl, value):
        """
        Set the control's value depending on its type
        @param ctrl: Form control instance
        @param value:
            - embedded chooser: a 0-base indices list to select embedded chooser items
            - multilinetext: a textctrl_info_t
            - dropdown list: an integer designating the selection index if readonly
                             a string designating the edit control value if not readonly
        @return: Boolean true on success
        """
        tid, _ = self.ControlToFieldTypeIdAndSize(ctrl)
        return _idaapi.formchgcbfa_set_field_value(
                    self.p_fa,
                    ctrl.id,
                    tid,
                    value)


    @staticmethod
    def ControlToFieldTypeIdAndSize(ctrl):
        """
        Converts a control object to a tuple containing the field id
        and the associated buffer size
        """
        # Input control depend on the associated buffer size (supplied by the user)

        # Make sure you check instances types taking into account inheritance
        if isinstance(ctrl, Form.DropdownListControl):
            return (8, 1 if ctrl.readonly else 0)
        elif isinstance(ctrl, Form.MultiLineTextControl):
            return (7, 0)
        elif isinstance(ctrl, Form.EmbeddedChooserControl):
            return (5, 0)
        # Group items or controls
        elif isinstance(ctrl, (Form.GroupItemControl, Form.GroupControl)):
            return (2, 0)
        elif isinstance(ctrl, Form.StringLabel):
            return (3, min(_idaapi.MAXSTR, ctrl.size))
        elif isinstance(ctrl, Form.ColorInput):
            return (4, 0)
        elif isinstance(ctrl, Form.NumericInput):
            # Pass the numeric control type
            return (6, ord(ctrl.tp[0]))
        elif isinstance(ctrl, Form.InputControl):
            return (1, ctrl.size)
        else:
            raise NotImplementedError, "Not yet implemented"

# --------------------------------------------------------------------------
# Instantiate AskUsingForm function pointer
try:
    import ctypes
    # Setup the numeric argument size
    Form.NumericArgument.DefI64 = _idaapi.BADADDR == 0xFFFFFFFFFFFFFFFFL
    AskUsingForm__ = ctypes.CFUNCTYPE(ctypes.c_long)(_idaapi.py_get_AskUsingForm())
    OpenForm__ = ctypes.CFUNCTYPE(ctypes.c_long)(_idaapi.py_get_OpenForm())
except:
    def AskUsingForm__(*args):
        warning("AskUsingForm() needs ctypes library in order to work")
        return 0
    def OpenForm__(*args):
        warning("OpenForm() needs ctypes library in order to work")


def AskUsingForm(*args):
    """
    Calls AskUsingForm()
    @param: Compiled Arguments obtain through the Form.Compile() function
    @return: 1 = ok, 0 = cancel
    """
    old = set_script_timeout(0)
    r = AskUsingForm__(*args)
    set_script_timeout(old)
    return r

def OpenForm(*args):
    """
    Calls OpenForm()
    @param: Compiled Arguments obtain through the Form.Compile() function
    """
    old = set_script_timeout(0)
    r = OpenForm__(*args)
    set_script_timeout(old)


#</pycode(py_kernwin)>

#<pycode(py_plgform)>
class PluginForm(object):
    """
    PluginForm class.

    This form can be used to host additional controls. Please check the PyQt example.
    """

    FORM_MDI      = 0x01
    """
    start by default as MDI (obsolete)
    """
    FORM_TAB      = 0x02
    """
    attached by default to a tab
    """
    FORM_RESTORE  = 0x04
    """
    restore state from desktop config
    """
    FORM_ONTOP    = 0x08
    """
    form should be "ontop
    """
    FORM_MENU     = 0x10
    """
    form must be listed in the windows menu (automatically set for all plugins)
    """
    FORM_CENTERED = 0x20
    """
    form will be centered on the screen
    """
    FORM_PERSIST  = 0x40
    """
    form will persist until explicitly closed with Close()
    """


    def __init__(self):
        """
        """
        self.__clink__ = _idaapi.plgform_new()



    def Show(self, caption, options = 0):
        """
		Creates the form if not was not created or brings to front if it was already created

        @param caption: The form caption
        @param options: One of PluginForm.FORM_ constants
        """
        options |= PluginForm.FORM_TAB|PluginForm.FORM_MENU|PluginForm.FORM_RESTORE
        return _idaapi.plgform_show(self.__clink__, self, caption, options)


    @staticmethod
    def FormToPyQtWidget(form, ctx = sys.modules['__main__']):
        """
        Use this method to convert a TForm* to a QWidget to be used by PyQt

        @param ctx: Context. Reference to a module that already imported SIP and QtGui modules
        """
        return ctx.sip.wrapinstance(ctx.sip.voidptr(form).__int__(), ctx.QtGui.QWidget)


    @staticmethod
    def FormToPySideWidget(form, ctx = sys.modules['__main__']):
        """
        Use this method to convert a TForm* to a QWidget to be used by PySide

        @param ctx: Context. Reference to a module that already imported QtGui module
        """
        if form is None:
            return None
        if type(form).__name__ == "SwigPyObject":
            # Since 'form' is a SwigPyObject, we first need to convert it to a PyCObject.
            # However, there's no easy way of doing it, so we'll use a rather brutal approach:
            # converting the SwigPyObject to a 'long' (will go through 'SwigPyObject_long',
            # that will return the pointer's value as a long), and then convert that value
            # back to a pointer into a PyCObject.
            ptr_l = long(form)
            from ctypes import pythonapi, c_void_p, py_object
            pythonapi.PyCObject_FromVoidPtr.restype  = py_object
            pythonapi.PyCObject_AsVoidPtr.argtypes = [c_void_p, c_void_p]
            form = pythonapi.PyCObject_FromVoidPtr(ptr_l, 0)
        return ctx.QtGui.QWidget.FromCObject(form)


    def OnCreate(self, form):
        """
        This event is called when the plugin form is created.
        The programmer should populate the form when this event is triggered.

        @return: None
        """
        pass


    def OnClose(self, form):
        """
        Called when the plugin form is closed

        @return: None
        """
        pass


    def Close(self, options):
        """
        Closes the form.

        @param options: Close options (FORM_SAVE, FORM_NO_CONTEXT, ...)

        @return: None
        """
        return _idaapi.plgform_close(self.__clink__, options)

    FORM_SAVE           = 0x1
    """
    Save state in desktop config
    """

    FORM_NO_CONTEXT     = 0x2
    """
    Don't change the current context (useful for toolbars)
    """

    FORM_DONT_SAVE_SIZE = 0x4
    """
    Don't save size of the window
    """

    FORM_CLOSE_LATER    = 0x8
    """
    This flag should be used when Close() is called from an event handler
    """
#</pycode(py_plgform)>

class Choose:
  """
  Choose - class for choose() with callbacks
  """
  def __init__(self, list, title, flags=0, deflt=1, icon=37):
    self.list = list
    self.title = title

    self.flags = flags
    self.x0 = -1
    self.x1 = -1
    self.y0 = -1
    self.y1 = -1

    self.width = -1
    self.deflt = deflt
    self.icon = icon

    # HACK: Add a circular reference for non-modal choosers. This prevents the GC
    # from collecting the class object the callbacks need. Unfortunately this means
    # that the class will never be collected, unless refhack is set to None explicitly.
    if (flags & Choose2.CH_MODAL) == 0:
      self.refhack = self

  def sizer(self):
    """
    Callback: sizer - returns the length of the list
    """
    return len(self.list)

  def getl(self, n):
    """
    Callback: getl - get one item from the list
    """
    if n == 0:
       return self.title
    if n <= self.sizer():
      return str(self.list[n-1])
    else:
      return "<Empty>"


  def ins(self):
    pass


  def update(self, n):
    pass


  def edit(self, n):
    pass


  def enter(self, n):
    print "enter(%d) called" % n


  def destroy(self):
    pass


  def get_icon(self, n):
    pass


  def choose(self):
    """
    choose - Display the choose dialogue
    """
    old = set_script_timeout(0)
    n = _idaapi.choose_choose(
        self,
        self.flags,
        self.x0,
        self.y0,
        self.x1,
        self.y1,
        self.width,
        self.deflt,
        self.icon)
    set_script_timeout(old)
    return n

#<pycode(py_cli)>
class cli_t(pyidc_opaque_object_t):
    """
    cli_t wrapper class.

    This class allows you to implement your own command line interface handlers.
    """

    def __init__(self):
        self.__cli_idx = -1
        self.__clink__ = None


    def register(self, flags = 0, sname = None, lname = None, hint = None):
        """
        Registers the CLI.

        @param flags: Feature bits. No bits are defined yet, must be 0
        @param sname: Short name (displayed on the button)
        @param lname: Long name (displayed in the menu)
        @param hint:  Hint for the input line

        @return Boolean: True-Success, False-Failed
        """

        # Already registered?
        if self.__cli_idx >= 0:
            return True

        if sname is not None: self.sname = sname
        if lname is not None: self.lname = lname
        if hint is not None:  self.hint  = hint

        # Register
        self.__cli_idx = _idaapi.install_command_interpreter(self)
        return False if self.__cli_idx < 0 else True


    def unregister(self):
        """
        Unregisters the CLI (if it was registered)
        """
        if self.__cli_idx < 0:
            return False

        _idaapi.remove_command_interpreter(self.__cli_idx)
        self.__cli_idx = -1
        return True


    def __del__(self):
        self.unregister()

    #
    # Implement these methods in the subclass:
    #
#<pydoc>
#    def OnExecuteLine(self, line):
#        """
#        The user pressed Enter. The CLI is free to execute the line immediately or ask for more lines.
#
#        This callback is mandatory.
#
#        @param line: typed line(s)
#        @return Boolean: True-executed line, False-ask for more lines
#        """
#        return True
#
#    def OnKeydown(self, line, x, sellen, vkey, shift):
#        """
#        A keyboard key has been pressed
#        This is a generic callback and the CLI is free to do whatever it wants.
#
#        This callback is optional.
#
#        @param line: current input line
#        @param x: current x coordinate of the cursor
#        @param sellen: current selection length (usually 0)
#        @param vkey: virtual key code. if the key has been handled, it should be returned as zero
#        @param shift: shift state
#
#        @return:
#            None - Nothing was changed
#            tuple(line, x, sellen, vkey): if either of the input line or the x coordinate or the selection length has been modified.
#            It is possible to return a tuple with None elements to preserve old values. Example: tuple(new_line, None, None, None) or tuple(new_line)
#        """
#        return None
#
#    def OnCompleteLine(self, prefix, n, line, prefix_start):
#        """
#        The user pressed Tab. Find a completion number N for prefix PREFIX
#
#        This callback is optional.
#
#        @param prefix: Line prefix at prefix_start (string)
#        @param n: completion number (int)
#        @param line: the current line (string)
#        @param prefix_start: the index where PREFIX starts in LINE (int)
#
#        @return: None if no completion could be generated otherwise a String with the completion suggestion
#        """
#        return None
#</pydoc>

#</pycode(py_cli)>
#<pycode(py_custviewer)>
class simplecustviewer_t(object):
    """
    The base class for implementing simple custom viewers
    """
    def __init__(self):
        self.__this = None

    def __del__(self):
        """
        Destructor. It also frees the associated C++ object
        """
        try:
            _idaapi.pyscv_delete(self.__this)
        except:
            pass

    @staticmethod
    def __make_sl_arg(line, fgcolor=None, bgcolor=None):
        return line if (fgcolor is None and bgcolor is None) else (line, fgcolor, bgcolor)

    def Create(self, title):
        """
        Creates the custom view. This should be the first method called after instantiation

        @param title: The title of the view
        @return: Boolean whether it succeeds or fails. It may fail if a window with the same title is already open.
                 In this case better close existing windows
        """
        self.title = title
        self.__this = _idaapi.pyscv_init(self, title)
        return True if self.__this else False

    def Close(self):
        """
        Destroys the view.
        One has to call Create() afterwards.
        Show() can be called and it will call Create() internally.
        @return: Boolean
        """
        return _idaapi.pyscv_close(self.__this)

    def Show(self):
        """
        Shows an already created view. It the view was close, then it will call Create() for you
        @return: Boolean
        """
        return _idaapi.pyscv_show(self.__this)

    def Refresh(self):
        return _idaapi.pyscv_refresh(self.__this)

    def RefreshCurrent(self):
        """
        Refreshes the current line only
        """
        return _idaapi.pyscv_refresh_current(self.__this)

    def Count(self):
        """
        Returns the number of lines in the view
        """
        return _idaapi.pyscv_count(self.__this)

    def GetSelection(self):
        """
        Returns the selected area or None
        @return:
            - tuple(x1, y1, x2, y2)
            - None if no selection
        """
        return _idaapi.pyscv_get_selection(self.__this)

    def ClearLines(self):
        """
        Clears all the lines
        """
        _idaapi.pyscv_clear_lines(self.__this)

    def AddLine(self, line, fgcolor=None, bgcolor=None):
        """
        Adds a colored line to the view
        @return: Boolean
        """
        return _idaapi.pyscv_add_line(self.__this, self.__make_sl_arg(line, fgcolor, bgcolor))

    def InsertLine(self, lineno, line, fgcolor=None, bgcolor=None):
        """
        Inserts a line in the given position
        @return: Boolean
        """
        return _idaapi.pyscv_insert_line(self.__this, lineno, self.__make_sl_arg(line, fgcolor, bgcolor))

    def EditLine(self, lineno, line, fgcolor=None, bgcolor=None):
        """
        Edits an existing line.
        @return: Boolean
        """
        return _idaapi.pyscv_edit_line(self.__this, lineno, self.__make_sl_arg(line, fgcolor, bgcolor))

    def PatchLine(self, lineno, offs, value):
        """
        Patches an existing line character at the given offset. This is a low level function. You must know what you're doing
        """
        return _idaapi.pyscv_patch_line(self.__this, lineno, offs, value)

    def DelLine(self, lineno):
        """
        Deletes an existing line
        @return: Boolean
        """
        return _idaapi.pyscv_del_line(self.__this, lineno)

    def GetLine(self, lineno):
        """
        Returns a line
        @param lineno: The line number
        @return:
            Returns a tuple (colored_line, fgcolor, bgcolor) or None
        """
        return _idaapi.pyscv_get_line(self.__this, lineno)

    def GetCurrentWord(self, mouse = 0):
        """
        Returns the current word
        @param mouse: Use mouse position or cursor position
        @return: None if failed or a String containing the current word at mouse or cursor
        """
        return _idaapi.pyscv_get_current_word(self.__this, mouse)

    def GetCurrentLine(self, mouse = 0, notags = 0):
        """
        Returns the current line.
        @param mouse: Current line at mouse pos
        @param notags: If True then tag_remove() will be called before returning the line
        @return: Returns the current line (colored or uncolored) or None on failure
        """
        return _idaapi.pyscv_get_current_line(self.__this, mouse, notags)

    def GetPos(self, mouse = 0):
        """
        Returns the current cursor or mouse position.
        @param mouse: return mouse position
        @return: Returns a tuple (lineno, x, y)
        """
        return _idaapi.pyscv_get_pos(self.__this, mouse)

    def GetLineNo(self, mouse = 0):
        """
        Calls GetPos() and returns the current line number or -1 on failure
        """
        r = self.GetPos(mouse)
        return -1 if not r else r[0]

    def Jump(self, lineno, x=0, y=0):
        return _idaapi.pyscv_jumpto(self.__this, lineno, x, y)

    def AddPopupMenu(self, title, hotkey=""):
        """
        Adds a popup menu item
        @param title: The name of the menu item
        @param hotkey: Hotkey of the item or just empty
        @return: Returns the
        """
        return _idaapi.pyscv_add_popup_menu(self.__this, title, hotkey)

    def ClearPopupMenu(self):
        """
        Clears all previously installed popup menu items.
        Use this function if you're generating menu items on the fly (in the OnPopup() callback),
        and before adding new items
        """
        _idaapi.pyscv_clear_popup_menu(self.__this)

    def IsFocused(self):
        """
        Returns True if the current view is the focused view
        """
        return _idaapi.pyscv_is_focused(self.__this)

    def GetTForm(self):
        """
        Return the TForm hosting this view.

        @return: The TForm that hosts this view, or None.
        """
        return _idaapi.pyscv_get_tform(self.__this)

    def GetTCustomControl(self):
        """
        Return the TCustomControl underlying this view.

        @return: The TCustomControl underlying this view, or None.
        """
        return _idaapi.pyscv_get_tcustom_control(self.__this)



    # Here are all the supported events
#<pydoc>
#    def OnClick(self, shift):
#        """
#        User clicked in the view
#        @param shift: Shift flag
#        @return: Boolean. True if you handled the event
#        """
#        print "OnClick, shift=%d" % shift
#        return True
#
#    def OnDblClick(self, shift):
#        """
#        User dbl-clicked in the view
#        @param shift: Shift flag
#        @return: Boolean. True if you handled the event
#        """
#        print "OnDblClick, shift=%d" % shift
#        return True
#
#    def OnCursorPosChanged(self):
#        """
#        Cursor position changed.
#        @return: Nothing
#        """
#        print "OnCurposChanged"
#
#    def OnClose(self):
#        """
#        The view is closing. Use this event to cleanup.
#        @return: Nothing
#        """
#        print "OnClose"
#
#    def OnKeydown(self, vkey, shift):
#        """
#        User pressed a key
#        @param vkey: Virtual key code
#        @param shift: Shift flag
#        @return: Boolean. True if you handled the event
#        """
#        print "OnKeydown, vk=%d shift=%d" % (vkey, shift)
#        return False
#
#    def OnPopup(self):
#        """
#        Context menu popup is about to be shown. Create items dynamically if you wish
#        @return: Boolean. True if you handled the event
#        """
#        print "OnPopup"
#
#    def OnHint(self, lineno):
#        """
#        Hint requested for the given line number.
#        @param lineno: The line number (zero based)
#        @return:
#            - tuple(number of important lines, hint string)
#            - None: if no hint available
#        """
#        return (1, "OnHint, line=%d" % lineno)
#
#    def OnPopupMenu(self, menu_id):
#        """
#        A context (or popup) menu item was executed.
#        @param menu_id: ID previously registered with add_popup_menu()
#        @return: Boolean
#        """
#        print "OnPopupMenu, menu_id=" % menu_id
#        return True
#</pydoc>
#</pycode(py_custviewer)>

COLOR_ON = _idaapi.COLOR_ON
COLOR_OFF = _idaapi.COLOR_OFF
COLOR_ESC = _idaapi.COLOR_ESC
COLOR_INV = _idaapi.COLOR_INV
SCOLOR_ON = _idaapi.SCOLOR_ON
SCOLOR_OFF = _idaapi.SCOLOR_OFF
SCOLOR_ESC = _idaapi.SCOLOR_ESC
SCOLOR_INV = _idaapi.SCOLOR_INV
SCOLOR_DEFAULT = _idaapi.SCOLOR_DEFAULT
SCOLOR_REGCMT = _idaapi.SCOLOR_REGCMT
SCOLOR_RPTCMT = _idaapi.SCOLOR_RPTCMT
SCOLOR_AUTOCMT = _idaapi.SCOLOR_AUTOCMT
SCOLOR_INSN = _idaapi.SCOLOR_INSN
SCOLOR_DATNAME = _idaapi.SCOLOR_DATNAME
SCOLOR_DNAME = _idaapi.SCOLOR_DNAME
SCOLOR_DEMNAME = _idaapi.SCOLOR_DEMNAME
SCOLOR_SYMBOL = _idaapi.SCOLOR_SYMBOL
SCOLOR_CHAR = _idaapi.SCOLOR_CHAR
SCOLOR_STRING = _idaapi.SCOLOR_STRING
SCOLOR_NUMBER = _idaapi.SCOLOR_NUMBER
SCOLOR_VOIDOP = _idaapi.SCOLOR_VOIDOP
SCOLOR_CREF = _idaapi.SCOLOR_CREF
SCOLOR_DREF = _idaapi.SCOLOR_DREF
SCOLOR_CREFTAIL = _idaapi.SCOLOR_CREFTAIL
SCOLOR_DREFTAIL = _idaapi.SCOLOR_DREFTAIL
SCOLOR_ERROR = _idaapi.SCOLOR_ERROR
SCOLOR_PREFIX = _idaapi.SCOLOR_PREFIX
SCOLOR_BINPREF = _idaapi.SCOLOR_BINPREF
SCOLOR_EXTRA = _idaapi.SCOLOR_EXTRA
SCOLOR_ALTOP = _idaapi.SCOLOR_ALTOP
SCOLOR_HIDNAME = _idaapi.SCOLOR_HIDNAME
SCOLOR_LIBNAME = _idaapi.SCOLOR_LIBNAME
SCOLOR_LOCNAME = _idaapi.SCOLOR_LOCNAME
SCOLOR_CODNAME = _idaapi.SCOLOR_CODNAME
SCOLOR_ASMDIR = _idaapi.SCOLOR_ASMDIR
SCOLOR_MACRO = _idaapi.SCOLOR_MACRO
SCOLOR_DSTR = _idaapi.SCOLOR_DSTR
SCOLOR_DCHAR = _idaapi.SCOLOR_DCHAR
SCOLOR_DNUM = _idaapi.SCOLOR_DNUM
SCOLOR_KEYWORD = _idaapi.SCOLOR_KEYWORD
SCOLOR_REG = _idaapi.SCOLOR_REG
SCOLOR_IMPNAME = _idaapi.SCOLOR_IMPNAME
SCOLOR_SEGNAME = _idaapi.SCOLOR_SEGNAME
SCOLOR_UNKNAME = _idaapi.SCOLOR_UNKNAME
SCOLOR_CNAME = _idaapi.SCOLOR_CNAME
SCOLOR_UNAME = _idaapi.SCOLOR_UNAME
SCOLOR_COLLAPSED = _idaapi.SCOLOR_COLLAPSED
SCOLOR_ADDR = _idaapi.SCOLOR_ADDR

def tag_strlen(*args):
  """
  tag_strlen(line) -> ssize_t
  """
  return _idaapi.tag_strlen(*args)
COLOR_SELECTED = _idaapi.COLOR_SELECTED
COLOR_LIBFUNC = _idaapi.COLOR_LIBFUNC
COLOR_REGFUNC = _idaapi.COLOR_REGFUNC
COLOR_CODE = _idaapi.COLOR_CODE
COLOR_DATA = _idaapi.COLOR_DATA
COLOR_UNKNOWN = _idaapi.COLOR_UNKNOWN
COLOR_EXTERN = _idaapi.COLOR_EXTERN
COLOR_CURITEM = _idaapi.COLOR_CURITEM
COLOR_CURLINE = _idaapi.COLOR_CURLINE
COLOR_HIDLINE = _idaapi.COLOR_HIDLINE
COLOR_BG_MAX = _idaapi.COLOR_BG_MAX

def calc_prefix_color(*args):
  """
  calc_prefix_color(ea) -> color_t
  """
  return _idaapi.calc_prefix_color(*args)

def calc_bg_color(*args):
  """
  calc_bg_color(ea) -> bgcolor_t
  """
  return _idaapi.calc_bg_color(*args)
class bgcolors_t(object):
    """
    Proxy of C++ bgcolors_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    prolog_color = _swig_property(_idaapi.bgcolors_t_prolog_color_get, _idaapi.bgcolors_t_prolog_color_set)
    epilog_color = _swig_property(_idaapi.bgcolors_t_epilog_color_get, _idaapi.bgcolors_t_epilog_color_set)
    switch_color = _swig_property(_idaapi.bgcolors_t_switch_color_get, _idaapi.bgcolors_t_switch_color_set)
    def __init__(self, *args):
        """
        __init__(self) -> bgcolors_t
        """
        this = _idaapi.new_bgcolors_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_bgcolors_t
    __del__ = lambda self : None;
bgcolors_t_swigregister = _idaapi.bgcolors_t_swigregister
bgcolors_t_swigregister(bgcolors_t)
COLOR_DEFAULT = cvar.COLOR_DEFAULT
COLOR_REGCMT = cvar.COLOR_REGCMT
COLOR_RPTCMT = cvar.COLOR_RPTCMT
COLOR_AUTOCMT = cvar.COLOR_AUTOCMT
COLOR_INSN = cvar.COLOR_INSN
COLOR_DATNAME = cvar.COLOR_DATNAME
COLOR_DNAME = cvar.COLOR_DNAME
COLOR_DEMNAME = cvar.COLOR_DEMNAME
COLOR_SYMBOL = cvar.COLOR_SYMBOL
COLOR_CHAR = cvar.COLOR_CHAR
COLOR_STRING = cvar.COLOR_STRING
COLOR_NUMBER = cvar.COLOR_NUMBER
COLOR_VOIDOP = cvar.COLOR_VOIDOP
COLOR_CREF = cvar.COLOR_CREF
COLOR_DREF = cvar.COLOR_DREF
COLOR_CREFTAIL = cvar.COLOR_CREFTAIL
COLOR_DREFTAIL = cvar.COLOR_DREFTAIL
COLOR_ERROR = cvar.COLOR_ERROR
COLOR_PREFIX = cvar.COLOR_PREFIX
COLOR_BINPREF = cvar.COLOR_BINPREF
COLOR_EXTRA = cvar.COLOR_EXTRA
COLOR_ALTOP = cvar.COLOR_ALTOP
COLOR_HIDNAME = cvar.COLOR_HIDNAME
COLOR_LIBNAME = cvar.COLOR_LIBNAME
COLOR_LOCNAME = cvar.COLOR_LOCNAME
COLOR_CODNAME = cvar.COLOR_CODNAME
COLOR_ASMDIR = cvar.COLOR_ASMDIR
COLOR_MACRO = cvar.COLOR_MACRO
COLOR_DSTR = cvar.COLOR_DSTR
COLOR_DCHAR = cvar.COLOR_DCHAR
COLOR_DNUM = cvar.COLOR_DNUM
COLOR_KEYWORD = cvar.COLOR_KEYWORD
COLOR_REG = cvar.COLOR_REG
COLOR_IMPNAME = cvar.COLOR_IMPNAME
COLOR_SEGNAME = cvar.COLOR_SEGNAME
COLOR_UNKNAME = cvar.COLOR_UNKNAME
COLOR_CNAME = cvar.COLOR_CNAME
COLOR_UNAME = cvar.COLOR_UNAME
COLOR_COLLAPSED = cvar.COLOR_COLLAPSED
COLOR_FG_MAX = cvar.COLOR_FG_MAX
COLOR_ADDR = cvar.COLOR_ADDR
COLOR_OPND1 = cvar.COLOR_OPND1
COLOR_OPND2 = cvar.COLOR_OPND2
COLOR_OPND3 = cvar.COLOR_OPND3
COLOR_OPND4 = cvar.COLOR_OPND4
COLOR_OPND5 = cvar.COLOR_OPND5
COLOR_OPND6 = cvar.COLOR_OPND6
COLOR_UTF8 = cvar.COLOR_UTF8
COLOR_RESERVED1 = cvar.COLOR_RESERVED1


def add_sourcefile(*args):
  """
  add_sourcefile(ea1, ea2, filename) -> bool
  """
  return _idaapi.add_sourcefile(*args)

def get_sourcefile(*args):
  """
  get_sourcefile(ea, bounds=None) -> char const *
  """
  return _idaapi.get_sourcefile(*args)

def del_sourcefile(*args):
  """
  del_sourcefile(ea) -> bool
  """
  return _idaapi.del_sourcefile(*args)

def MakeLine(*args):
  """
  MakeLine(contents, indent=-1) -> bool
  """
  return _idaapi.MakeLine(*args)

def printf_line(*args):
  """
  printf_line(indent, format) -> bool
  """
  return _idaapi.printf_line(*args)

def MakeNull(*args):
  """
  MakeNull() -> bool
  """
  return _idaapi.MakeNull(*args)

def MakeBorder(*args):
  """
  MakeBorder() -> bool
  """
  return _idaapi.MakeBorder(*args)

def MakeSolidBorder(*args):
  """
  MakeSolidBorder() -> bool
  """
  return _idaapi.MakeSolidBorder(*args)

def gen_cmt_line(*args):
  """
  gen_cmt_line(format) -> bool
  """
  return _idaapi.gen_cmt_line(*args)

def gen_collapsed_line(*args):
  """
  gen_collapsed_line(format) -> bool
  """
  return _idaapi.gen_collapsed_line(*args)

def generate_big_comment(*args):
  """
  generate_big_comment(cmt, color) -> bool
  """
  return _idaapi.generate_big_comment(*args)

def generate_many_lines(*args):
  """
  generate_many_lines(string, color) -> bool
  """
  return _idaapi.generate_many_lines(*args)

def describe(*args):
  """
  describe(ea, isprev, format)
  """
  return _idaapi.describe(*args)

def add_long_cmt(*args):
  """
  add_long_cmt(ea, isprev, format)
  """
  return _idaapi.add_long_cmt(*args)

def add_pgm_cmt(*args):
  """
  add_pgm_cmt(format)
  """
  return _idaapi.add_pgm_cmt(*args)

def generate_disasm_line(*args):
  """
  generate_disasm_line(ea, flags=0) -> bool
  """
  return _idaapi.generate_disasm_line(*args)
GENDSM_FORCE_CODE = _idaapi.GENDSM_FORCE_CODE
GENDSM_MULTI_LINE = _idaapi.GENDSM_MULTI_LINE

def get_first_free_extra_cmtidx(*args):
  """
  get_first_free_extra_cmtidx(ea, start) -> int
  """
  return _idaapi.get_first_free_extra_cmtidx(*args)

def update_extra_cmt(*args):
  """
  update_extra_cmt(ea, what, str)
  """
  return _idaapi.update_extra_cmt(*args)

def del_extra_cmt(*args):
  """
  del_extra_cmt(ea, what)
  """
  return _idaapi.del_extra_cmt(*args)

def get_extra_cmt(*args):
  """
  get_extra_cmt(ea, what) -> ssize_t
  """
  return _idaapi.get_extra_cmt(*args)

def delete_extra_cmts(*args):
  """
  delete_extra_cmts(ea, cmtidx)
  """
  return _idaapi.delete_extra_cmts(*args)

def ExtraFree(*args):
  """
  ExtraFree(ea, start) -> int
  """
  return _idaapi.ExtraFree(*args)

def set_user_defined_prefix(*args):
  """
  set_user_defined_prefix(width, pycb) -> PyObject *


  User-defined line-prefixes are displayed just after the autogenerated
  line prefixes. In order to use them, the plugin should call the
  following function to specify its width and contents.
  @param width: the width of the user-defined prefix
  @param callback: a get_user_defined_prefix callback to get the contents of the prefix.
      Its arguments:
        ea     - linear address
        lnnum  - line number
        indent - indent of the line contents (-1 means the default instruction)
                 indent and is used for instruction itself. see explanations for printf_line()
        line   - the line to be generated. the line usually contains color tags this argument
                 can be examined to decide whether to generated the prefix
        bufsize- the maximum allowed size of the output buffer
      It returns a buffer of size < bufsize
  
  In order to remove the callback before unloading the plugin, specify the width = 0 or the callback = None
  """
  return _idaapi.set_user_defined_prefix(*args)

def tag_remove(*args):
  """
  tag_remove(instr) -> PyObject *


  Remove color escape sequences from a string
  @param colstr: the colored string with embedded tags
  @return:
      None on failure
      or a new string w/o the tags
  """
  return _idaapi.tag_remove(*args)

def tag_addr(*args):
  """
  tag_addr(ea) -> PyObject *
  """
  return _idaapi.tag_addr(*args)

def tag_skipcode(*args):
  """
  tag_skipcode(line) -> int
  """
  return _idaapi.tag_skipcode(*args)

def tag_skipcodes(*args):
  """
  tag_skipcodes(line) -> int
  """
  return _idaapi.tag_skipcodes(*args)

def tag_advance(*args):
  """
  tag_advance(line, cnt) -> int
  """
  return _idaapi.tag_advance(*args)

def generate_disassembly(*args):
  """
  generate_disassembly(ea, max_lines, as_stack, notags) -> PyObject *


  Generate disassembly lines (many lines) and put them into a buffer
  
  @param ea: address to generate disassembly for
  @param max_lines: how many lines max to generate
  @param as_stack: Display undefined items as 2/4/8 bytes
  @return:
      - None on failure
      - tuple(most_important_line_number, tuple(lines)) : Returns a tuple containing
        the most important line number and a tuple of generated lines
  """
  return _idaapi.generate_disassembly(*args)
#<pycode(py_lines)>

# ---------------- Color escape sequence defitions -------------------------
COLOR_ADDR_SIZE = 16 if _idaapi.BADADDR == 0xFFFFFFFFFFFFFFFFL else 8
SCOLOR_FG_MAX   = '\x28'             #  Max color number
SCOLOR_OPND1    = chr(cvar.COLOR_ADDR+1)  #  Instruction operand 1
SCOLOR_OPND2    = chr(cvar.COLOR_ADDR+2)  #  Instruction operand 2
SCOLOR_OPND3    = chr(cvar.COLOR_ADDR+3)  #  Instruction operand 3
SCOLOR_OPND4    = chr(cvar.COLOR_ADDR+4)  #  Instruction operand 4
SCOLOR_OPND5    = chr(cvar.COLOR_ADDR+5)  #  Instruction operand 5
SCOLOR_OPND6    = chr(cvar.COLOR_ADDR+6)  #  Instruction operand 6
SCOLOR_UTF8     = chr(cvar.COLOR_ADDR+10) #  Following text is UTF-8 encoded

# ---------------- Line prefix colors --------------------------------------
PALETTE_SIZE   =  (cvar.COLOR_FG_MAX+_idaapi.COLOR_BG_MAX)

def requires_color_esc(c):
    """
    Checks if the given character requires escaping
    @param c: character (string of one char)
    @return: Boolean
    """
    t = ord(c[0])
    return c >= COLOR_ON and c <= COLOR_INV

def COLSTR(str, tag):
    """
    Utility function to create a colored line
    @param str: The string
    @param tag: Color tag constant. One of SCOLOR_XXXX
    """
    return SCOLOR_ON + tag + str + SCOLOR_OFF + tag

#</pycode(py_lines)>


MAX_FILE_FORMAT_NAME = _idaapi.MAX_FILE_FORMAT_NAME
class loader_t(object):
    """
    Proxy of C++ loader_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    version = _swig_property(_idaapi.loader_t_version_get, _idaapi.loader_t_version_set)
    flags = _swig_property(_idaapi.loader_t_flags_get, _idaapi.loader_t_flags_set)
    _UNUSED1_was_init_loader_options = _swig_property(_idaapi.loader_t__UNUSED1_was_init_loader_options_get, _idaapi.loader_t__UNUSED1_was_init_loader_options_set)
    def __init__(self, *args):
        """
        __init__(self) -> loader_t
        """
        this = _idaapi.new_loader_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_loader_t
    __del__ = lambda self : None;
loader_t_swigregister = _idaapi.loader_t_swigregister
loader_t_swigregister(loader_t)
E_PREV = cvar.E_PREV
E_NEXT = cvar.E_NEXT
LDRF_RELOAD = _idaapi.LDRF_RELOAD
ACCEPT_FIRST = _idaapi.ACCEPT_FIRST
NEF_SEGS = _idaapi.NEF_SEGS
NEF_RSCS = _idaapi.NEF_RSCS
NEF_NAME = _idaapi.NEF_NAME
NEF_MAN = _idaapi.NEF_MAN
NEF_FILL = _idaapi.NEF_FILL
NEF_IMPS = _idaapi.NEF_IMPS
NEF_TIGHT = _idaapi.NEF_TIGHT
NEF_FIRST = _idaapi.NEF_FIRST
NEF_CODE = _idaapi.NEF_CODE
NEF_RELOAD = _idaapi.NEF_RELOAD
NEF_FLAT = _idaapi.NEF_FLAT
NEF_MINI = _idaapi.NEF_MINI
NEF_LOPT = _idaapi.NEF_LOPT
NEF_LALL = _idaapi.NEF_LALL

LOADER_EXT = _idaapi.LOADER_EXT
LOADER_DLL = _idaapi.LOADER_DLL

def load_binary_file(*args):
  """
  load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes) -> bool
  """
  return _idaapi.load_binary_file(*args)
OFILE_MAP = _idaapi.OFILE_MAP
OFILE_EXE = _idaapi.OFILE_EXE
OFILE_IDC = _idaapi.OFILE_IDC
OFILE_LST = _idaapi.OFILE_LST
OFILE_ASM = _idaapi.OFILE_ASM
OFILE_DIF = _idaapi.OFILE_DIF

def gen_file(*args):
  """
  gen_file(otype, fp, ea1, ea2, flags) -> int
  """
  return _idaapi.gen_file(*args)
GENFLG_MAPSEG = _idaapi.GENFLG_MAPSEG
GENFLG_MAPNAME = _idaapi.GENFLG_MAPNAME
GENFLG_MAPDMNG = _idaapi.GENFLG_MAPDMNG
GENFLG_MAPLOC = _idaapi.GENFLG_MAPLOC
GENFLG_IDCTYPE = _idaapi.GENFLG_IDCTYPE
GENFLG_ASMTYPE = _idaapi.GENFLG_ASMTYPE
GENFLG_GENHTML = _idaapi.GENFLG_GENHTML
GENFLG_ASMINC = _idaapi.GENFLG_ASMINC

def file2base(*args):
  """
  file2base(li, pos, ea1, ea2, patchable) -> int
  """
  return _idaapi.file2base(*args)
FILEREG_PATCHABLE = _idaapi.FILEREG_PATCHABLE
FILEREG_NOTPATCHABLE = _idaapi.FILEREG_NOTPATCHABLE

def base2file(*args):
  """
  base2file(fp, pos, ea1, ea2) -> int
  """
  return _idaapi.base2file(*args)

def extract_module_from_archive(*args):
  """
  extract_module_from_archive(filename, bufsize, is_remote, temp_file_ptr) -> bool
  """
  return _idaapi.extract_module_from_archive(*args)

def get_basic_file_type(*args):
  """
  get_basic_file_type(li) -> filetype_t
  """
  return _idaapi.get_basic_file_type(*args)

def get_file_type_name(*args):
  """
  get_file_type_name() -> size_t
  """
  return _idaapi.get_file_type_name(*args)

def load_ids_module(*args):
  """
  load_ids_module(fname) -> int
  """
  return _idaapi.load_ids_module(*args)

def get_plugin_options(*args):
  """
  get_plugin_options(plugin) -> char const *
  """
  return _idaapi.get_plugin_options(*args)
PLUGIN_EXT = _idaapi.PLUGIN_EXT
PLUGIN_DLL = _idaapi.PLUGIN_DLL
class idp_name_t(object):
    """
    Proxy of C++ idp_name_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    lname = _swig_property(_idaapi.idp_name_t_lname_get, _idaapi.idp_name_t_lname_set)
    sname = _swig_property(_idaapi.idp_name_t_sname_get, _idaapi.idp_name_t_sname_set)
    hidden = _swig_property(_idaapi.idp_name_t_hidden_get, _idaapi.idp_name_t_hidden_set)
    def __init__(self, *args):
        """
        __init__(self) -> idp_name_t
        """
        this = _idaapi.new_idp_name_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idp_name_t
    __del__ = lambda self : None;
idp_name_t_swigregister = _idaapi.idp_name_t_swigregister
idp_name_t_swigregister(idp_name_t)

class idp_desc_t(object):
    """
    Proxy of C++ idp_desc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    path = _swig_property(_idaapi.idp_desc_t_path_get, _idaapi.idp_desc_t_path_set)
    mtime = _swig_property(_idaapi.idp_desc_t_mtime_get, _idaapi.idp_desc_t_mtime_set)
    family = _swig_property(_idaapi.idp_desc_t_family_get, _idaapi.idp_desc_t_family_set)
    names = _swig_property(_idaapi.idp_desc_t_names_get, _idaapi.idp_desc_t_names_set)
    is_script = _swig_property(_idaapi.idp_desc_t_is_script_get, _idaapi.idp_desc_t_is_script_set)
    checked = _swig_property(_idaapi.idp_desc_t_checked_get, _idaapi.idp_desc_t_checked_set)
    def __init__(self, *args):
        """
        __init__(self) -> idp_desc_t
        """
        this = _idaapi.new_idp_desc_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_idp_desc_t
    __del__ = lambda self : None;
idp_desc_t_swigregister = _idaapi.idp_desc_t_swigregister
idp_desc_t_swigregister(idp_desc_t)

IDP_EXT = _idaapi.IDP_EXT
IDP_DLL = _idaapi.IDP_DLL

def load_and_run_plugin(*args):
  """
  load_and_run_plugin(name, arg) -> bool
  """
  return _idaapi.load_and_run_plugin(*args)

def get_fileregion_offset(*args):
  """
  get_fileregion_offset(ea) -> int32
  """
  return _idaapi.get_fileregion_offset(*args)

def get_fileregion_ea(*args):
  """
  get_fileregion_ea(offset) -> ea_t
  """
  return _idaapi.get_fileregion_ea(*args)

def gen_exe_file(*args):
  """
  gen_exe_file(fp) -> int
  """
  return _idaapi.gen_exe_file(*args)

def reload_file(*args):
  """
  reload_file(file, is_remote) -> int
  """
  return _idaapi.reload_file(*args)
MAX_DATABASE_DESCRIPTION = _idaapi.MAX_DATABASE_DESCRIPTION
SSUF_DESC = _idaapi.SSUF_DESC
SSUF_PATH = _idaapi.SSUF_PATH
SSUF_FLAGS = _idaapi.SSUF_FLAGS

def flush_buffers(*args):
  """
  flush_buffers() -> int
  """
  return _idaapi.flush_buffers(*args)

def is_trusted_idb(*args):
  """
  is_trusted_idb() -> bool
  """
  return _idaapi.is_trusted_idb(*args)

def save_database_ex(*args):
  """
  save_database_ex(outfile, flags, root=None, attr=None) -> bool
  """
  return _idaapi.save_database_ex(*args)
DBFL_KILL = _idaapi.DBFL_KILL
DBFL_COMP = _idaapi.DBFL_COMP
DBFL_BAK = _idaapi.DBFL_BAK
DBFL_TEMP = _idaapi.DBFL_TEMP

def save_database(*args):
  """
  save_database(outfile, delete_unpacked) -> bool
  """
  return _idaapi.save_database(*args)

def load_loader_module(*args):
  """
  load_loader_module(li, lname, fname, is_remote) -> int
  """
  return _idaapi.load_loader_module(*args)

def mem2base(*args):
  """
  mem2base(py_mem, ea, fpos=-1) -> int


  Load database from the memory.
  @param mem: the buffer
  @param ea: start linear addresses
  @param fpos: position in the input file the data is taken from.
               if == -1, then no file position correspond to the data.
  @return:
      - Returns zero if the passed buffer was not a string
      - Otherwise 1 is returned
  """
  return _idaapi.mem2base(*args)

def load_plugin(*args):
  """
  load_plugin(name) -> PyObject *


  Loads a plugin
  @return:
      - None if plugin could not be loaded
      - An opaque object representing the loaded plugin
  """
  return _idaapi.load_plugin(*args)

def run_plugin(*args):
  """
  run_plugin(plg, arg) -> bool


  Runs a plugin
  @param plg: A plugin object (returned by load_plugin())
  @return: Boolean
  """
  return _idaapi.run_plugin(*args)
class graph_location_info_t(object):
    """
    Proxy of C++ graph_location_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    zoom = _swig_property(_idaapi.graph_location_info_t_zoom_get, _idaapi.graph_location_info_t_zoom_set)
    orgx = _swig_property(_idaapi.graph_location_info_t_orgx_get, _idaapi.graph_location_info_t_orgx_set)
    orgy = _swig_property(_idaapi.graph_location_info_t_orgy_get, _idaapi.graph_location_info_t_orgy_set)
    def __init__(self, *args):
        """
        __init__(self) -> graph_location_info_t
        """
        this = _idaapi.new_graph_location_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """
        __eq__(self, r) -> bool
        """
        return _idaapi.graph_location_info_t___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, r) -> bool
        """
        return _idaapi.graph_location_info_t___ne__(self, *args)

    __swig_destroy__ = _idaapi.delete_graph_location_info_t
    __del__ = lambda self : None;
graph_location_info_t_swigregister = _idaapi.graph_location_info_t_swigregister
graph_location_info_t_swigregister(graph_location_info_t)

CURLOC_SISTACK_ITEMS = _idaapi.CURLOC_SISTACK_ITEMS
CURLOC_LIST = _idaapi.CURLOC_LIST
class curloc(object):
    """
    Proxy of C++ curloc class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.curloc_ea_get, _idaapi.curloc_ea_set)
    x = _swig_property(_idaapi.curloc_x_get, _idaapi.curloc_x_set)
    y = _swig_property(_idaapi.curloc_y_get, _idaapi.curloc_y_set)
    lnnum = _swig_property(_idaapi.curloc_lnnum_get, _idaapi.curloc_lnnum_set)
    flags = _swig_property(_idaapi.curloc_flags_get, _idaapi.curloc_flags_set)
    target = _swig_property(_idaapi.curloc_target_get, _idaapi.curloc_target_set)
    def __init__(self, *args):
        """
        __init__(self) -> curloc
        __init__(self, stackName) -> curloc
        """
        this = _idaapi.new_curloc(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args):
        """
        linkTo(self, stackName)
        """
        return _idaapi.curloc_linkTo(self, *args)

    def setx(self, *args):
        """
        setx(self, xx)
        """
        return _idaapi.curloc_setx(self, *args)

    def jump_push(self, *args):
        """
        jump_push(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0)
        """
        return _idaapi.curloc_jump_push(self, *args)

    def pop(self, *args):
        """
        pop(self, try_tohide) -> bool
        """
        return _idaapi.curloc_pop(self, *args)

    def get(self, *args):
        """
        get(self, depth) -> bool
        """
        return _idaapi.curloc_get(self, *args)

    def get_entry(self, *args):
        """
        get_entry(self, out, depth) -> bool
        """
        return _idaapi.curloc_get_entry(self, *args)

    def size(self, *args):
        """
        size(self) -> size_t
        """
        return _idaapi.curloc_size(self, *args)

    def copy_current_location(self, *args):
        """
        copy_current_location(self, loc)
        """
        return _idaapi.curloc_copy_current_location(self, *args)

    def unhide_if_necessary(self, *args):
        """
        unhide_if_necessary(self, tgt)
        """
        return _idaapi.curloc_unhide_if_necessary(self, *args)

    def hide_if_necessary(self, *args):
        """
        hide_if_necessary(self)
        """
        return _idaapi.curloc_hide_if_necessary(self, *args)

    def mark(self, *args):
        """
        mark(self, marker, title, desc) -> int
        """
        return _idaapi.curloc_mark(self, *args)

    def markedpos(self, *args):
        """
        markedpos(self, marker) -> ea_t
        """
        return _idaapi.curloc_markedpos(self, *args)

    def jump(self, *args):
        """
        jump(self, marker) -> bool
        """
        return _idaapi.curloc_jump(self, *args)

    def markdesc(self, *args):
        """
        markdesc(self, marker) -> ssize_t
        """
        return _idaapi.curloc_markdesc(self, *args)

    __swig_destroy__ = _idaapi.delete_curloc
    __del__ = lambda self : None;
curloc_swigregister = _idaapi.curloc_swigregister
curloc_swigregister(curloc)
DEFAULT_CURSOR_Y = _idaapi.DEFAULT_CURSOR_Y
DEFAULT_LNNUM = _idaapi.DEFAULT_LNNUM
UNHID_SEGM = _idaapi.UNHID_SEGM
UNHID_FUNC = _idaapi.UNHID_FUNC
UNHID_AREA = _idaapi.UNHID_AREA

MAX_MARK_SLOT = _idaapi.MAX_MARK_SLOT
class location_t(curloc):
    """
    Proxy of C++ location_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    gli = _swig_property(_idaapi.location_t_gli_get, _idaapi.location_t_gli_set)
    def __init__(self, *args):
        """
        __init__(self) -> location_t
        __init__(self, name) -> location_t
        """
        this = _idaapi.new_location_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args):
        """
        linkTo(self, name)
        """
        return _idaapi.location_t_linkTo(self, *args)

    def push_and_jump(self, *args):
        """
        push_and_jump(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None)
        """
        return _idaapi.location_t_push_and_jump(self, *args)

    def pop(self, *args):
        """
        pop(self, try_tohide) -> bool
        """
        return _idaapi.location_t_pop(self, *args)

    def get(self, *args):
        """
        get(self, depth) -> bool
        """
        return _idaapi.location_t_get(self, *args)

    def get_entry(self, *args):
        """
        get_entry(self, out, depth) -> bool
        """
        return _idaapi.location_t_get_entry(self, *args)

    def copy_current_location(self, *args):
        """
        copy_current_location(self, loc)
        """
        return _idaapi.location_t_copy_current_location(self, *args)

    def jump_nopush(self, *args):
        """
        jump_nopush(self, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None)
        """
        return _idaapi.location_t_jump_nopush(self, *args)

    def mark(self, *args):
        """
        mark(self, marker, title, desc) -> int
        """
        return _idaapi.location_t_mark(self, *args)

    def jump(self, *args):
        """
        jump(self, marker) -> bool
        """
        return _idaapi.location_t_jump(self, *args)

    __swig_destroy__ = _idaapi.delete_location_t
    __del__ = lambda self : None;
location_t_swigregister = _idaapi.location_t_swigregister
location_t_swigregister(location_t)

MAXNAMELEN = _idaapi.MAXNAMELEN
FUNC_IMPORT_PREFIX = _idaapi.FUNC_IMPORT_PREFIX
SN_CHECK = _idaapi.SN_CHECK
SN_NOCHECK = _idaapi.SN_NOCHECK
SN_PUBLIC = _idaapi.SN_PUBLIC
SN_NON_PUBLIC = _idaapi.SN_NON_PUBLIC
SN_WEAK = _idaapi.SN_WEAK
SN_NON_WEAK = _idaapi.SN_NON_WEAK
SN_AUTO = _idaapi.SN_AUTO
SN_NON_AUTO = _idaapi.SN_NON_AUTO
SN_NOLIST = _idaapi.SN_NOLIST
SN_NOWARN = _idaapi.SN_NOWARN
SN_LOCAL = _idaapi.SN_LOCAL

def set_name(*args):
  """
    set_name(ea, name, flag) -> bool
    set_name(ea, name) -> bool
    """
  return _idaapi.set_name(*args)

def del_global_name(*args):
  """
  del_global_name(ea) -> bool
  """
  return _idaapi.del_global_name(*args)

def del_local_name(*args):
  """
  del_local_name(ea) -> bool
  """
  return _idaapi.del_local_name(*args)

def set_dummy_name(*args):
  """
  set_dummy_name(frm, ea) -> bool
  """
  return _idaapi.set_dummy_name(*args)

def make_name_auto(*args):
  """
  make_name_auto(ea) -> bool
  """
  return _idaapi.make_name_auto(*args)

def make_name_user(*args):
  """
  make_name_user(ea) -> bool
  """
  return _idaapi.make_name_user(*args)

def do_name_anyway(*args):
  """
  do_name_anyway(ea, name, maxlen=0) -> bool
  """
  return _idaapi.do_name_anyway(*args)

def validate_name3(*args):
  """
  validate_name3(name) -> bool
  """
  return _idaapi.validate_name3(*args)

def is_ident_char(*args):
  """
  is_ident_char(c) -> bool
  """
  return _idaapi.is_ident_char(*args)

def is_visible_char(*args):
  """
  is_visible_char(c) -> bool
  """
  return _idaapi.is_visible_char(*args)

def isident(*args):
  """
  isident(name) -> bool
  """
  return _idaapi.isident(*args)

def is_uname(*args):
  """
  is_uname(name) -> bool
  """
  return _idaapi.is_uname(*args)

def is_valid_typename(*args):
  """
  is_valid_typename(name) -> bool
  """
  return _idaapi.is_valid_typename(*args)

def extract_name2(*args):
  """
  extract_name2(line, x) -> ssize_t
  """
  return _idaapi.extract_name2(*args)

def hide_name(*args):
  """
  hide_name(ea)
  """
  return _idaapi.hide_name(*args)

def show_name(*args):
  """
  show_name(ea)
  """
  return _idaapi.show_name(*args)

def get_name_ea(*args):
  """
  get_name_ea(frm, name) -> ea_t
  """
  return _idaapi.get_name_ea(*args)

def get_name_base_ea(*args):
  """
  get_name_base_ea(frm, to) -> ea_t
  """
  return _idaapi.get_name_base_ea(*args)

def get_name_value(*args):
  """
  get_name_value(frm, name) -> int
  """
  return _idaapi.get_name_value(*args)
NT_NONE = _idaapi.NT_NONE
NT_BYTE = _idaapi.NT_BYTE
NT_LOCAL = _idaapi.NT_LOCAL
NT_STKVAR = _idaapi.NT_STKVAR
NT_ENUM = _idaapi.NT_ENUM
NT_ABS = _idaapi.NT_ABS
NT_SEG = _idaapi.NT_SEG
NT_STROFF = _idaapi.NT_STROFF
NT_BMASK = _idaapi.NT_BMASK
NT_REGVAR = _idaapi.NT_REGVAR
GN_VISIBLE = _idaapi.GN_VISIBLE
GN_COLORED = _idaapi.GN_COLORED
GN_DEMANGLED = _idaapi.GN_DEMANGLED
GN_STRICT = _idaapi.GN_STRICT
GN_SHORT = _idaapi.GN_SHORT
GN_LONG = _idaapi.GN_LONG
GN_LOCAL = _idaapi.GN_LOCAL
GN_INSNLOC = _idaapi.GN_INSNLOC

def get_colored_short_name(*args):
  """
  get_colored_short_name(ea, gtn_flags=0) -> ssize_t
  """
  return _idaapi.get_colored_short_name(*args)

def get_colored_long_name(*args):
  """
  get_colored_long_name(ea, gtn_flags=0) -> ssize_t
  """
  return _idaapi.get_colored_long_name(*args)

def get_visible_name(*args):
  """
  get_visible_name(ea, gtn_flags=0) -> qstring
  """
  return _idaapi.get_visible_name(*args)

def get_short_name(*args):
  """
  get_short_name(ea, gtn_flags=0) -> qstring
  """
  return _idaapi.get_short_name(*args)

def get_long_name(*args):
  """
  get_long_name(ea, gtn_flags=0) -> qstring
  """
  return _idaapi.get_long_name(*args)

def get_name_color(*args):
  """
  get_name_color(frm, ea) -> color_t
  """
  return _idaapi.get_name_color(*args)
GETN_APPZERO = _idaapi.GETN_APPZERO
GETN_NOFIXUP = _idaapi.GETN_NOFIXUP
GETN_NODUMMY = _idaapi.GETN_NODUMMY

def get_name_expr(*args):
  """
  get_name_expr(frm, n, ea, off, flags=0x0001) -> ssize_t
  """
  return _idaapi.get_name_expr(*args)

def get_nice_colored_name(*args):
  """
  get_nice_colored_name(ea, flags=0) -> ssize_t
  """
  return _idaapi.get_nice_colored_name(*args)
GNCN_NOSEG = _idaapi.GNCN_NOSEG
GNCN_NOCOLOR = _idaapi.GNCN_NOCOLOR
GNCN_NOLABEL = _idaapi.GNCN_NOLABEL
GNCN_NOFUNC = _idaapi.GNCN_NOFUNC
GNCN_SEG_FUNC = _idaapi.GNCN_SEG_FUNC
GNCN_SEGNUM = _idaapi.GNCN_SEGNUM
GNCN_REQFUNC = _idaapi.GNCN_REQFUNC
GNCN_REQNAME = _idaapi.GNCN_REQNAME
GNCN_NODBGNM = _idaapi.GNCN_NODBGNM

def append_struct_fields2(*args):
  """
  append_struct_fields2(n, path, plen, flags, disp, delta, appzero) -> flags_t
  """
  return _idaapi.append_struct_fields2(*args)

def is_public_name(*args):
  """
  is_public_name(ea) -> bool
  """
  return _idaapi.is_public_name(*args)

def make_name_public(*args):
  """
  make_name_public(ea)
  """
  return _idaapi.make_name_public(*args)

def make_name_non_public(*args):
  """
  make_name_non_public(ea)
  """
  return _idaapi.make_name_non_public(*args)

def gen_name_decl(*args):
  """
  gen_name_decl(ea, name) -> int
  """
  return _idaapi.gen_name_decl(*args)

def is_weak_name(*args):
  """
  is_weak_name(ea) -> bool
  """
  return _idaapi.is_weak_name(*args)

def make_name_weak(*args):
  """
  make_name_weak(ea)
  """
  return _idaapi.make_name_weak(*args)

def make_name_non_weak(*args):
  """
  make_name_non_weak(ea)
  """
  return _idaapi.make_name_non_weak(*args)

def get_nlist_size(*args):
  """
  get_nlist_size() -> size_t
  """
  return _idaapi.get_nlist_size(*args)

def get_nlist_idx(*args):
  """
  get_nlist_idx(ea) -> size_t
  """
  return _idaapi.get_nlist_idx(*args)

def is_in_nlist(*args):
  """
  is_in_nlist(ea) -> bool
  """
  return _idaapi.is_in_nlist(*args)

def get_nlist_ea(*args):
  """
  get_nlist_ea(idx) -> ea_t
  """
  return _idaapi.get_nlist_ea(*args)

def get_nlist_name(*args):
  """
  get_nlist_name(idx) -> char const *
  """
  return _idaapi.get_nlist_name(*args)

def rebuild_nlist(*args):
  """
  rebuild_nlist()
  """
  return _idaapi.rebuild_nlist(*args)

def reorder_dummy_names(*args):
  """
  reorder_dummy_names()
  """
  return _idaapi.reorder_dummy_names(*args)
DEBNAME_EXACT = _idaapi.DEBNAME_EXACT
DEBNAME_LOWER = _idaapi.DEBNAME_LOWER
DEBNAME_UPPER = _idaapi.DEBNAME_UPPER
DEBNAME_NICE = _idaapi.DEBNAME_NICE
class ea_name_t(object):
    """
    Proxy of C++ ea_name_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.ea_name_t_ea_get, _idaapi.ea_name_t_ea_set)
    name = _swig_property(_idaapi.ea_name_t_name_get, _idaapi.ea_name_t_name_set)
    def __init__(self, *args):
        """
        __init__(self) -> ea_name_t
        __init__(self, _ea, _name) -> ea_name_t
        """
        this = _idaapi.new_ea_name_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_ea_name_t
    __del__ = lambda self : None;
ea_name_t_swigregister = _idaapi.ea_name_t_swigregister
ea_name_t_swigregister(ea_name_t)


def set_debug_name(*args):
  """
  set_debug_name(ea, name) -> bool
  """
  return _idaapi.set_debug_name(*args)

def get_debug_name2(*args):
  """
  get_debug_name2(ea_ptr, how) -> ssize_t
  """
  return _idaapi.get_debug_name2(*args)

def del_debug_names(*args):
  """
  del_debug_names(ea1, ea2)
  """
  return _idaapi.del_debug_names(*args)

def get_debug_name_ea(*args):
  """
  get_debug_name_ea(name) -> ea_t
  """
  return _idaapi.get_debug_name_ea(*args)
DQT_NPURGED_8 = _idaapi.DQT_NPURGED_8
DQT_NPURGED_4 = _idaapi.DQT_NPURGED_4
DQT_NPURGED_2 = _idaapi.DQT_NPURGED_2
DQT_COMPILER = _idaapi.DQT_COMPILER
DQT_NAME_TYPE = _idaapi.DQT_NAME_TYPE
DQT_FULL = _idaapi.DQT_FULL

def demangle_name2(*args):
  """
  demangle_name2(name, disable_mask, demreq=DQT_FULL) -> int32
  """
  return _idaapi.demangle_name2(*args)

def is_name_defined_locally(*args):
  """
  is_name_defined_locally(pfn, name, ignore, ea1=BADADDR, ea2=BADADDR) -> bool
  """
  return _idaapi.is_name_defined_locally(*args)

def validate_name(*args):
  """
  validate_name(name) -> char *
  """
  return _idaapi.validate_name(*args)

def validate_name2(*args):
  """
  validate_name2(name, bufsize) -> char *
  """
  return _idaapi.validate_name2(*args)

def get_true_name(*args):
  """
    get_true_name(ea) -> qstring
    get_true_name(frm, ea) -> char *
    """
  return _idaapi.get_true_name(*args)

def get_name(*args):
  """
  get_name(frm, ea) -> char *
  """
  return _idaapi.get_name(*args)

def get_colored_name(*args):
  """
    get_colored_name(ea) -> qstring
    get_colored_name(frm, ea) -> char *
    """
  return _idaapi.get_colored_name(*args)

def demangle_name(*args):
  """
  demangle_name(name, disable_mask) -> int32
  """
  return _idaapi.demangle_name(*args)

def make_visible_name(*args):
  """
  make_visible_name(srcname, dstsize) -> char *
  """
  return _idaapi.make_visible_name(*args)

def extract_name(*args):
  """
  extract_name(line, x) -> char *
  """
  return _idaapi.extract_name(*args)

def get_demangled_name(*args):
  """
    get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> ssize_t
    get_demangled_name(frm, ea, inhibitor, demform, strict) -> char *
    """
  return _idaapi.get_demangled_name(*args)

def get_colored_demangled_name(*args):
  """
    get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> ssize_t
    get_colored_demangled_name(frm, ea, inhibitor, demform, strict) -> char *
    """
  return _idaapi.get_colored_demangled_name(*args)

def get_debug_names(*args):
  """
  get_debug_names(ea1, ea2) -> PyObject *
  """
  return _idaapi.get_debug_names(*args)

def get_ea_name(*args):
  """
  get_ea_name(ea, gtn_flags=0) -> qstring
  """
  return _idaapi.get_ea_name(*args)
#<pycode(py_name)>

class NearestName:
    """
    Utility class to help find the nearest name in a given ea/name dictionary
    """
    def __init__(self, ea_names):
        self.update(ea_names)


    def update(self, ea_names):
        """
        Updates the ea/names map
        """
        self._names = ea_names
        self._addrs = ea_names.keys()
        self._addrs.sort()


    def find(self, ea):
        """
        Returns a tupple (ea, name, pos) that is the nearest to the passed ea
        If no name is matched then None is returned
        """
        pos = bisect.bisect_left(self._addrs, ea)
        # no match
        if pos >= len(self._addrs):
            return None
        # exact match?
        if self._addrs[pos] != ea:
            pos -= 1 # go to previous element
        if pos < 0:
            return None
        return self[pos]


    def _get_item(self, index):
        ea = self._addrs[index]
        return (ea, self._names[ea], index)


    def __iter__(self):
        return (self._get_item(index) for index in xrange(0, len(self._addrs)))


    def __getitem__(self, index):
        """
        Returns the tupple (ea, name, index)
        """
        if index > len(self._addrs):
            raise StopIteration
        return self._get_item(index)

extract_name = extract_name2

#</pycode(py_name)>


def set_offset(*args):
  """
  set_offset(ea, n, base) -> bool
  """
  return _idaapi.set_offset(*args)

def op_offset_ex(*args):
  """
  op_offset_ex(ea, n, ri) -> int
  """
  return _idaapi.op_offset_ex(*args)

def op_offset(*args):
  """
  op_offset(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int
  """
  return _idaapi.op_offset(*args)

def get_offbase(*args):
  """
  get_offbase(ea, n) -> ea_t
  """
  return _idaapi.get_offbase(*args)

def get_offset_expression(*args):
  """
  get_offset_expression(ea, n, frm, offset, getn_flags=0) -> int
  """
  return _idaapi.get_offset_expression(*args)

def get_offset_expr(*args):
  """
  get_offset_expr(ea, n, ri, frm, offset, getn_flags=0) -> int
  """
  return _idaapi.get_offset_expr(*args)

def can_be_off32(*args):
  """
  can_be_off32(ea) -> ea_t
  """
  return _idaapi.can_be_off32(*args)

def calc_probable_base_by_value(*args):
  """
  calc_probable_base_by_value(ea, off) -> ea_t
  """
  return _idaapi.calc_probable_base_by_value(*args)

def get_default_reftype(*args):
  """
  get_default_reftype(ea) -> reftype_t
  """
  return _idaapi.get_default_reftype(*args)

def calc_reference_target(*args):
  """
  calc_reference_target(frm, ri, opval) -> ea_t
  """
  return _idaapi.calc_reference_target(*args)

def calc_reference_basevalue(*args):
  """
  calc_reference_basevalue(frm, ri, opval, target) -> ea_t
  """
  return _idaapi.calc_reference_basevalue(*args)

def calc_target(*args):
  """
  calc_target(frm, ea, n, opval) -> ea_t
  """
  return _idaapi.calc_target(*args)

def QueueGetMessage(*args):
  """
  QueueGetMessage(t, ea) -> ssize_t
  """
  return _idaapi.QueueGetMessage(*args)

def QueueSet(*args):
  """
  QueueSet(type, ea, $ignore=None)
  """
  return _idaapi.QueueSet(*args)

def QueueGetType(*args):
  """
  QueueGetType(type, lowea) -> ea_t
  """
  return _idaapi.QueueGetType(*args)

def QueueDel(*args):
  """
  QueueDel(type, ea)
  """
  return _idaapi.QueueDel(*args)

def get_long_queue_name(*args):
  """
  get_long_queue_name(type) -> char const *
  """
  return _idaapi.get_long_queue_name(*args)

def get_short_queue_name(*args):
  """
  get_short_queue_name(type) -> char const *
  """
  return _idaapi.get_short_queue_name(*args)

def QueueIsPresent(*args):
  """
  QueueIsPresent(t, ea) -> bool
  """
  return _idaapi.QueueIsPresent(*args)

def was_ida_decision(*args):
  """
  was_ida_decision(ea) -> bool
  """
  return _idaapi.was_ida_decision(*args)
ROLLBACK_CODE = _idaapi.ROLLBACK_CODE
ROLLBACK_DATA = _idaapi.ROLLBACK_DATA
ROLLBACK_ALIGN = _idaapi.ROLLBACK_ALIGN
ROLLBACK_CALL = _idaapi.ROLLBACK_CALL

def QueueMark(*args):
  """
  QueueMark(type, ea)
  """
  return _idaapi.QueueMark(*args)
SEARCH_UP = _idaapi.SEARCH_UP
SEARCH_DOWN = _idaapi.SEARCH_DOWN
SEARCH_NEXT = _idaapi.SEARCH_NEXT
SEARCH_CASE = _idaapi.SEARCH_CASE
SEARCH_REGEX = _idaapi.SEARCH_REGEX
SEARCH_NOBRK = _idaapi.SEARCH_NOBRK
SEARCH_NOSHOW = _idaapi.SEARCH_NOSHOW
SEARCH_UNICODE = _idaapi.SEARCH_UNICODE
SEARCH_IDENT = _idaapi.SEARCH_IDENT
SEARCH_BRK = _idaapi.SEARCH_BRK

def search_down(*args):
  """
  search_down(sflag) -> bool
  """
  return _idaapi.search_down(*args)

def find_error(*args):
  """
  find_error(ea, sflag) -> ea_t
  """
  return _idaapi.find_error(*args)

def find_notype(*args):
  """
  find_notype(ea, sflag) -> ea_t
  """
  return _idaapi.find_notype(*args)

def find_unknown(*args):
  """
  find_unknown(ea, sflag) -> ea_t
  """
  return _idaapi.find_unknown(*args)

def find_defined(*args):
  """
  find_defined(ea, sflag) -> ea_t
  """
  return _idaapi.find_defined(*args)

def find_void(*args):
  """
  find_void(ea, sflag) -> ea_t
  """
  return _idaapi.find_void(*args)

def find_data(*args):
  """
  find_data(ea, sflag) -> ea_t
  """
  return _idaapi.find_data(*args)

def find_code(*args):
  """
  find_code(ea, sflag) -> ea_t
  """
  return _idaapi.find_code(*args)

def find_not_func(*args):
  """
  find_not_func(ea, sflag) -> ea_t
  """
  return _idaapi.find_not_func(*args)

def find_imm(*args):
  """
  find_imm(newEA, sflag, srchValue) -> ea_t
  """
  return _idaapi.find_imm(*args)

def find_binary(*args):
  """
  find_binary(startea, endea, ubinstr, radix, sflag) -> ea_t
  """
  return _idaapi.find_binary(*args)

def find_text(*args):
  """
  find_text(startEA, y, x, ustr, sflag) -> ea_t
  """
  return _idaapi.find_text(*args)
SREG_NUM = _idaapi.SREG_NUM
class segment_t(area_t):
    """
    Proxy of C++ segment_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> segment_t
        """
        this = _idaapi.new_segment_t(*args)
        try: self.this.append(this)
        except: self.this = this
    name = _swig_property(_idaapi.segment_t_name_get, _idaapi.segment_t_name_set)
    sclass = _swig_property(_idaapi.segment_t_sclass_get, _idaapi.segment_t_sclass_set)
    orgbase = _swig_property(_idaapi.segment_t_orgbase_get, _idaapi.segment_t_orgbase_set)
    align = _swig_property(_idaapi.segment_t_align_get, _idaapi.segment_t_align_set)
    comb = _swig_property(_idaapi.segment_t_comb_get, _idaapi.segment_t_comb_set)
    perm = _swig_property(_idaapi.segment_t_perm_get, _idaapi.segment_t_perm_set)
    bitness = _swig_property(_idaapi.segment_t_bitness_get, _idaapi.segment_t_bitness_set)
    def use32(self, *args):
        """
        use32(self) -> bool
        """
        return _idaapi.segment_t_use32(self, *args)

    def use64(self, *args):
        """
        use64(self) -> bool
        """
        return _idaapi.segment_t_use64(self, *args)

    def abits(self, *args):
        """
        abits(self) -> int
        """
        return _idaapi.segment_t_abits(self, *args)

    def abytes(self, *args):
        """
        abytes(self) -> int
        """
        return _idaapi.segment_t_abytes(self, *args)

    flags = _swig_property(_idaapi.segment_t_flags_get, _idaapi.segment_t_flags_set)
    def comorg(self, *args):
        """
        comorg(self) -> bool
        """
        return _idaapi.segment_t_comorg(self, *args)

    def set_comorg(self, *args):
        """
        set_comorg(self)
        """
        return _idaapi.segment_t_set_comorg(self, *args)

    def clr_comorg(self, *args):
        """
        clr_comorg(self)
        """
        return _idaapi.segment_t_clr_comorg(self, *args)

    def ob_ok(self, *args):
        """
        ob_ok(self) -> bool
        """
        return _idaapi.segment_t_ob_ok(self, *args)

    def set_ob_ok(self, *args):
        """
        set_ob_ok(self)
        """
        return _idaapi.segment_t_set_ob_ok(self, *args)

    def clr_ob_ok(self, *args):
        """
        clr_ob_ok(self)
        """
        return _idaapi.segment_t_clr_ob_ok(self, *args)

    def is_visible_segm(self, *args):
        """
        is_visible_segm(self) -> bool
        """
        return _idaapi.segment_t_is_visible_segm(self, *args)

    def set_visible_segm(self, *args):
        """
        set_visible_segm(self, visible)
        """
        return _idaapi.segment_t_set_visible_segm(self, *args)

    def set_debugger_segm(self, *args):
        """
        set_debugger_segm(self, debseg)
        """
        return _idaapi.segment_t_set_debugger_segm(self, *args)

    def is_loader_segm(self, *args):
        """
        is_loader_segm(self) -> bool
        """
        return _idaapi.segment_t_is_loader_segm(self, *args)

    def set_loader_segm(self, *args):
        """
        set_loader_segm(self, ldrseg)
        """
        return _idaapi.segment_t_set_loader_segm(self, *args)

    def is_hidden_segtype(self, *args):
        """
        is_hidden_segtype(self) -> bool
        """
        return _idaapi.segment_t_is_hidden_segtype(self, *args)

    def set_hidden_segtype(self, *args):
        """
        set_hidden_segtype(self, hide)
        """
        return _idaapi.segment_t_set_hidden_segtype(self, *args)

    sel = _swig_property(_idaapi.segment_t_sel_get, _idaapi.segment_t_sel_set)
    defsr = _swig_property(_idaapi.segment_t_defsr_get, _idaapi.segment_t_defsr_set)
    type = _swig_property(_idaapi.segment_t_type_get, _idaapi.segment_t_type_set)
    color = _swig_property(_idaapi.segment_t_color_get, _idaapi.segment_t_color_set)
    def update(self, *args):
        """
        update(self) -> bool
        """
        return _idaapi.segment_t_update(self, *args)

    startEA = _swig_property(_idaapi.segment_t_startEA_get, _idaapi.segment_t_startEA_set)
    endEA = _swig_property(_idaapi.segment_t_endEA_get, _idaapi.segment_t_endEA_set)
    __swig_destroy__ = _idaapi.delete_segment_t
    __del__ = lambda self : None;
segment_t_swigregister = _idaapi.segment_t_swigregister
segment_t_swigregister(segment_t)
ignore_none = cvar.ignore_none
ignore_regvar = cvar.ignore_regvar
ignore_llabel = cvar.ignore_llabel
ignore_stkvar = cvar.ignore_stkvar
ignore_glabel = cvar.ignore_glabel
Q_noBase = cvar.Q_noBase
Q_noName = cvar.Q_noName
Q_noFop = cvar.Q_noFop
Q_noComm = cvar.Q_noComm
Q_noRef = cvar.Q_noRef
Q_jumps = cvar.Q_jumps
Q_disasm = cvar.Q_disasm
Q_head = cvar.Q_head
Q_noValid = cvar.Q_noValid
Q_lines = cvar.Q_lines
Q_badstack = cvar.Q_badstack
Q_att = cvar.Q_att
Q_final = cvar.Q_final
Q_rolled = cvar.Q_rolled
Q_collsn = cvar.Q_collsn
Q_decimp = cvar.Q_decimp
Q_Qnum = cvar.Q_Qnum
saAbs = _idaapi.saAbs
saRelByte = _idaapi.saRelByte
saRelWord = _idaapi.saRelWord
saRelPara = _idaapi.saRelPara
saRelPage = _idaapi.saRelPage
saRelDble = _idaapi.saRelDble
saRel4K = _idaapi.saRel4K
saGroup = _idaapi.saGroup
saRel32Bytes = _idaapi.saRel32Bytes
saRel64Bytes = _idaapi.saRel64Bytes
saRelQword = _idaapi.saRelQword
saRel128Bytes = _idaapi.saRel128Bytes
saRel512Bytes = _idaapi.saRel512Bytes
saRel1024Bytes = _idaapi.saRel1024Bytes
saRel2048Bytes = _idaapi.saRel2048Bytes
saRel_MAX_ALIGN_CODE = _idaapi.saRel_MAX_ALIGN_CODE
scPriv = _idaapi.scPriv
scGroup = _idaapi.scGroup
scPub = _idaapi.scPub
scPub2 = _idaapi.scPub2
scStack = _idaapi.scStack
scCommon = _idaapi.scCommon
scPub3 = _idaapi.scPub3
sc_MAX_COMB_CODE = _idaapi.sc_MAX_COMB_CODE
SEGPERM_EXEC = _idaapi.SEGPERM_EXEC
SEGPERM_WRITE = _idaapi.SEGPERM_WRITE
SEGPERM_READ = _idaapi.SEGPERM_READ
SEGPERM_MAXVAL = _idaapi.SEGPERM_MAXVAL
SEG_MAX_BITNESS_CODE = _idaapi.SEG_MAX_BITNESS_CODE
SFL_COMORG = _idaapi.SFL_COMORG
SFL_OBOK = _idaapi.SFL_OBOK
SFL_HIDDEN = _idaapi.SFL_HIDDEN
SFL_DEBUG = _idaapi.SFL_DEBUG
SFL_LOADER = _idaapi.SFL_LOADER
SFL_HIDETYPE = _idaapi.SFL_HIDETYPE
SEG_NORM = _idaapi.SEG_NORM
SEG_XTRN = _idaapi.SEG_XTRN
SEG_CODE = _idaapi.SEG_CODE
SEG_DATA = _idaapi.SEG_DATA
SEG_IMP = _idaapi.SEG_IMP
SEG_GRP = _idaapi.SEG_GRP
SEG_NULL = _idaapi.SEG_NULL
SEG_UNDF = _idaapi.SEG_UNDF
SEG_BSS = _idaapi.SEG_BSS
SEG_ABSSYM = _idaapi.SEG_ABSSYM
SEG_COMM = _idaapi.SEG_COMM
SEG_IMEM = _idaapi.SEG_IMEM
SEG_MAX_SEGTYPE_CODE = _idaapi.SEG_MAX_SEGTYPE_CODE


def is_visible_segm(*args):
  """
  is_visible_segm(s) -> bool
  """
  return _idaapi.is_visible_segm(*args)

def is_finally_visible_segm(*args):
  """
  is_finally_visible_segm(s) -> bool
  """
  return _idaapi.is_finally_visible_segm(*args)

def set_visible_segm(*args):
  """
  set_visible_segm(s, visible)
  """
  return _idaapi.set_visible_segm(*args)

def is_spec_segm(*args):
  """
  is_spec_segm(seg_type) -> bool
  """
  return _idaapi.is_spec_segm(*args)

def is_spec_ea(*args):
  """
  is_spec_ea(ea) -> bool
  """
  return _idaapi.is_spec_ea(*args)
class lock_segment(object):
    """
    Proxy of C++ lock_segment class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, _segm) -> lock_segment
        """
        this = _idaapi.new_lock_segment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lock_segment
    __del__ = lambda self : None;
lock_segment_swigregister = _idaapi.lock_segment_swigregister
lock_segment_swigregister(lock_segment)


def is_segm_locked(*args):
  """
  is_segm_locked(segm) -> bool
  """
  return _idaapi.is_segm_locked(*args)

def getn_selector(*args):
  """
  getn_selector(n, sel, base) -> bool
  """
  return _idaapi.getn_selector(*args)

def get_selector_qty(*args):
  """
  get_selector_qty() -> int
  """
  return _idaapi.get_selector_qty(*args)

def setup_selector(*args):
  """
  setup_selector(segbase) -> sel_t
  """
  return _idaapi.setup_selector(*args)

def allocate_selector(*args):
  """
  allocate_selector(segbase) -> sel_t
  """
  return _idaapi.allocate_selector(*args)

def find_free_selector(*args):
  """
  find_free_selector() -> sel_t
  """
  return _idaapi.find_free_selector(*args)

def set_selector(*args):
  """
  set_selector(selector, paragraph) -> int
  """
  return _idaapi.set_selector(*args)

def del_selector(*args):
  """
  del_selector(selector)
  """
  return _idaapi.del_selector(*args)

def ask_selector(*args):
  """
  ask_selector(selector) -> ea_t
  """
  return _idaapi.ask_selector(*args)

def sel2ea(*args):
  """
  sel2ea(selector) -> ea_t
  """
  return _idaapi.sel2ea(*args)

def find_selector(*args):
  """
  find_selector(base) -> sel_t
  """
  return _idaapi.find_selector(*args)

def get_segm_by_sel(*args):
  """
  get_segm_by_sel(selector) -> segment_t
  """
  return _idaapi.get_segm_by_sel(*args)

def add_segm_ex(*args):
  """
  add_segm_ex(s, name, sclass, flags) -> bool
  """
  return _idaapi.add_segm_ex(*args)
ADDSEG_NOSREG = _idaapi.ADDSEG_NOSREG
ADDSEG_OR_DIE = _idaapi.ADDSEG_OR_DIE
ADDSEG_NOTRUNC = _idaapi.ADDSEG_NOTRUNC
ADDSEG_QUIET = _idaapi.ADDSEG_QUIET
ADDSEG_FILLGAP = _idaapi.ADDSEG_FILLGAP
ADDSEG_SPARSE = _idaapi.ADDSEG_SPARSE

def add_segm(*args):
  """
  add_segm(para, start, end, name, sclass) -> bool
  """
  return _idaapi.add_segm(*args)

def del_segm(*args):
  """
  del_segm(ea, flags) -> bool
  """
  return _idaapi.del_segm(*args)
SEGMOD_KILL = _idaapi.SEGMOD_KILL
SEGMOD_KEEP = _idaapi.SEGMOD_KEEP
SEGMOD_SILENT = _idaapi.SEGMOD_SILENT
SEGMOD_KEEP0 = _idaapi.SEGMOD_KEEP0
SEGMOD_KEEPSEL = _idaapi.SEGMOD_KEEPSEL
SEGMOD_NOMOVE = _idaapi.SEGMOD_NOMOVE
SEGMOD_SPARSE = _idaapi.SEGMOD_SPARSE

def get_segm_qty(*args):
  """
  get_segm_qty() -> int
  """
  return _idaapi.get_segm_qty(*args)

def getseg(*args):
  """
  getseg(ea) -> segment_t
  """
  return _idaapi.getseg(*args)

def getnseg(*args):
  """
  getnseg(n) -> segment_t
  """
  return _idaapi.getnseg(*args)

def get_next_seg(*args):
  """
  get_next_seg(ea) -> segment_t
  """
  return _idaapi.get_next_seg(*args)

def get_prev_seg(*args):
  """
  get_prev_seg(ea) -> segment_t
  """
  return _idaapi.get_prev_seg(*args)

def get_first_seg(*args):
  """
  get_first_seg() -> segment_t
  """
  return _idaapi.get_first_seg(*args)

def get_last_seg(*args):
  """
  get_last_seg() -> segment_t
  """
  return _idaapi.get_last_seg(*args)

def get_segm_by_name(*args):
  """
  get_segm_by_name(name) -> segment_t
  """
  return _idaapi.get_segm_by_name(*args)

def set_segm_end(*args):
  """
  set_segm_end(ea, newend, flags) -> bool
  """
  return _idaapi.set_segm_end(*args)

def set_segm_start(*args):
  """
  set_segm_start(ea, newstart, flags) -> bool
  """
  return _idaapi.set_segm_start(*args)

def move_segm_start(*args):
  """
  move_segm_start(ea, newstart, mode) -> bool
  """
  return _idaapi.move_segm_start(*args)

def move_segm(*args):
  """
  move_segm(s, to, flags=0) -> int
  """
  return _idaapi.move_segm(*args)
MSF_SILENT = _idaapi.MSF_SILENT
MSF_NOFIX = _idaapi.MSF_NOFIX
MSF_LDKEEP = _idaapi.MSF_LDKEEP
MSF_FIXONCE = _idaapi.MSF_FIXONCE
MOVE_SEGM_OK = _idaapi.MOVE_SEGM_OK
MOVE_SEGM_PARAM = _idaapi.MOVE_SEGM_PARAM
MOVE_SEGM_ROOM = _idaapi.MOVE_SEGM_ROOM
MOVE_SEGM_IDP = _idaapi.MOVE_SEGM_IDP
MOVE_SEGM_CHUNK = _idaapi.MOVE_SEGM_CHUNK
MOVE_SEGM_LOADER = _idaapi.MOVE_SEGM_LOADER
MOVE_SEGM_ODD = _idaapi.MOVE_SEGM_ODD
MOVE_SEGM_ORPHAN = _idaapi.MOVE_SEGM_ORPHAN

def rebase_program(*args):
  """
  rebase_program(delta, flags) -> int
  """
  return _idaapi.rebase_program(*args)

def change_segment_status(*args):
  """
  change_segment_status(s, is_deb_segm) -> int
  """
  return _idaapi.change_segment_status(*args)
CSS_OK = _idaapi.CSS_OK
CSS_NODBG = _idaapi.CSS_NODBG
CSS_NOAREA = _idaapi.CSS_NOAREA
CSS_NOMEM = _idaapi.CSS_NOMEM
CSS_BREAK = _idaapi.CSS_BREAK

def take_memory_snapshot(*args):
  """
  take_memory_snapshot(only_loader_segs) -> bool
  """
  return _idaapi.take_memory_snapshot(*args)

def is_miniidb(*args):
  """
  is_miniidb() -> bool
  """
  return _idaapi.is_miniidb(*args)

def set_segm_base(*args):
  """
  set_segm_base(s, newbase) -> bool
  """
  return _idaapi.set_segm_base(*args)

def set_group_selector(*args):
  """
  set_group_selector(grp, sel) -> int
  """
  return _idaapi.set_group_selector(*args)
MAX_GROUPS = _idaapi.MAX_GROUPS

def get_group_selector(*args):
  """
  get_group_selector(grpsel) -> sel_t
  """
  return _idaapi.get_group_selector(*args)

def add_segment_translation(*args):
  """
  add_segment_translation(segstart, mappedseg) -> bool
  """
  return _idaapi.add_segment_translation(*args)
MAX_SEGM_TRANSLATIONS = _idaapi.MAX_SEGM_TRANSLATIONS

def set_segment_translations(*args):
  """
  set_segment_translations(segstart, transmap) -> bool
  """
  return _idaapi.set_segment_translations(*args)

def del_segment_translations(*args):
  """
  del_segment_translations(ea) -> bool
  """
  return _idaapi.del_segment_translations(*args)

def get_segment_translations(*args):
  """
  get_segment_translations(segstart, buf, bufsize) -> ea_t *
  """
  return _idaapi.get_segment_translations(*args)

def get_segment_cmt(*args):
  """
  get_segment_cmt(s, repeatable) -> char *
  """
  return _idaapi.get_segment_cmt(*args)

def set_segment_cmt(*args):
  """
  set_segment_cmt(s, cmt, repeatable)
  """
  return _idaapi.set_segment_cmt(*args)

def del_segment_cmt(*args):
  """
  del_segment_cmt(s, repeatable)
  """
  return _idaapi.del_segment_cmt(*args)

def std_gen_segm_footer(*args):
  """
  std_gen_segm_footer(ea)
  """
  return _idaapi.std_gen_segm_footer(*args)

def set_segm_name(*args):
  """
  set_segm_name(s, format) -> int
  """
  return _idaapi.set_segm_name(*args)

def get_true_segm_name(*args):
  """
  get_true_segm_name(s) -> ssize_t
  """
  return _idaapi.get_true_segm_name(*args)

def get_segm_name(*args):
  """
    get_segm_name(s) -> ssize_t
    get_segm_name(ea) -> ssize_t
    """
  return _idaapi.get_segm_name(*args)

def get_segm_class(*args):
  """
  get_segm_class(s) -> ssize_t
  """
  return _idaapi.get_segm_class(*args)

def set_segm_class(*args):
  """
  set_segm_class(s, sclass) -> int
  """
  return _idaapi.set_segm_class(*args)

def segtype(*args):
  """
  segtype(ea) -> uchar
  """
  return _idaapi.segtype(*args)

def get_segment_alignment(*args):
  """
  get_segment_alignment(align) -> char const *
  """
  return _idaapi.get_segment_alignment(*args)

def get_segment_combination(*args):
  """
  get_segment_combination(comb) -> char const *
  """
  return _idaapi.get_segment_combination(*args)

def get_segm_para(*args):
  """
  get_segm_para(s) -> ea_t
  """
  return _idaapi.get_segm_para(*args)

def get_segm_base(*args):
  """
  get_segm_base(s) -> ea_t
  """
  return _idaapi.get_segm_base(*args)

def set_segm_addressing(*args):
  """
  set_segm_addressing(s, bitness) -> bool
  """
  return _idaapi.set_segm_addressing(*args)

def update_segm(*args):
  """
  update_segm(s) -> bool
  """
  return _idaapi.update_segm(*args)

def segm_adjust_diff(*args):
  """
  segm_adjust_diff(s, delta) -> adiff_t
  """
  return _idaapi.segm_adjust_diff(*args)

def segm_adjust_ea(*args):
  """
  segm_adjust_ea(s, ea) -> ea_t
  """
  return _idaapi.segm_adjust_ea(*args)
SEGDEL_PERM = _idaapi.SEGDEL_PERM
SEGDEL_KEEP = _idaapi.SEGDEL_KEEP
SEGDEL_SILENT = _idaapi.SEGDEL_SILENT
SEGDEL_KEEP0 = _idaapi.SEGDEL_KEEP0

def get_defsr(*args):
  """
  get_defsr(s, reg) -> sel_t
  """
  return _idaapi.get_defsr(*args)

def set_defsr(*args):
  """
  set_defsr(s, reg, value)
  """
  return _idaapi.set_defsr(*args)
R_es = _idaapi.R_es
R_cs = _idaapi.R_cs
R_ss = _idaapi.R_ss
R_ds = _idaapi.R_ds
R_fs = _idaapi.R_fs
R_gs = _idaapi.R_gs
class segreg_area_t(area_t):
    """
    Proxy of C++ segreg_area_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    val = _swig_property(_idaapi.segreg_area_t_val_get, _idaapi.segreg_area_t_val_set)
    tag = _swig_property(_idaapi.segreg_area_t_tag_get, _idaapi.segreg_area_t_tag_set)
    def __init__(self, *args):
        """
        __init__(self) -> segreg_area_t
        """
        this = _idaapi.new_segreg_area_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_segreg_area_t
    __del__ = lambda self : None;
segreg_area_t_swigregister = _idaapi.segreg_area_t_swigregister
segreg_area_t_swigregister(segreg_area_t)
SR_inherit = _idaapi.SR_inherit
SR_user = _idaapi.SR_user
SR_auto = _idaapi.SR_auto
SR_autostart = _idaapi.SR_autostart


def get_segreg(*args):
  """
  get_segreg(ea, rg) -> sel_t
  """
  return _idaapi.get_segreg(*args)

def split_srarea(*args):
  """
  split_srarea(ea, rg, v, tag, silent=False) -> bool
  """
  return _idaapi.split_srarea(*args)

def set_default_segreg_value(*args):
  """
  set_default_segreg_value(sg, rg, value) -> bool
  """
  return _idaapi.set_default_segreg_value(*args)

def set_sreg_at_next_code(*args):
  """
  set_sreg_at_next_code(ea1, ea2, rg, value)
  """
  return _idaapi.set_sreg_at_next_code(*args)

def get_srarea2(*args):
  """
  get_srarea2(out, ea, rg) -> bool
  """
  return _idaapi.get_srarea2(*args)

def get_prev_srarea(*args):
  """
  get_prev_srarea(out, ea, rg) -> bool
  """
  return _idaapi.get_prev_srarea(*args)

def set_default_dataseg(*args):
  """
  set_default_dataseg(ds_sel)
  """
  return _idaapi.set_default_dataseg(*args)

def get_srareas_qty2(*args):
  """
  get_srareas_qty2(rg) -> size_t
  """
  return _idaapi.get_srareas_qty2(*args)

def getn_srarea2(*args):
  """
  getn_srarea2(out, rg, n) -> bool
  """
  return _idaapi.getn_srarea2(*args)

def get_srarea_num(*args):
  """
  get_srarea_num(rg, ea) -> int
  """
  return _idaapi.get_srarea_num(*args)

def del_srarea(*args):
  """
  del_srarea(rg, ea) -> bool
  """
  return _idaapi.del_srarea(*args)

def copy_srareas(*args):
  """
  copy_srareas(dst_rg, src_rg, map_selector=False)
  """
  return _idaapi.copy_srareas(*args)
class segreg_t(area_t):
    """
    Proxy of C++ segreg_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def reg(self, *args):
        """
        reg(self, n) -> sel_t const &
        """
        return _idaapi.segreg_t_reg(self, *args)

    def tag(self, *args):
        """
        tag(self, n) -> uchar const &
        """
        return _idaapi.segreg_t_tag(self, *args)

    def undefregs(self, *args):
        """
        undefregs(self)
        """
        return _idaapi.segreg_t_undefregs(self, *args)

    def setregs(self, *args):
        """
        setregs(self, Regs)
        """
        return _idaapi.segreg_t_setregs(self, *args)

    def settags(self, *args):
        """
        settags(self, v)
        """
        return _idaapi.segreg_t_settags(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> segreg_t
        """
        this = _idaapi.new_segreg_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_segreg_t
    __del__ = lambda self : None;
segreg_t_swigregister = _idaapi.segreg_t_swigregister
segreg_t_swigregister(segreg_t)


def get_srarea(*args):
  """
  get_srarea(ea) -> segreg_t
  """
  return _idaapi.get_srarea(*args)

def get_srareas_qty(*args):
  """
  get_srareas_qty() -> size_t
  """
  return _idaapi.get_srareas_qty(*args)

def getn_srarea(*args):
  """
  getn_srarea(n) -> segreg_t
  """
  return _idaapi.getn_srarea(*args)
class lock_segreg(object):
    """
    Proxy of C++ lock_segreg class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self, arg2) -> lock_segreg
        """
        this = _idaapi.new_lock_segreg(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_lock_segreg
    __del__ = lambda self : None;
lock_segreg_swigregister = _idaapi.lock_segreg_swigregister
lock_segreg_swigregister(lock_segreg)


def is_segreg_locked(*args):
  """
  is_segreg_locked(arg1) -> bool
  """
  return _idaapi.is_segreg_locked(*args)

def getSR(*args):
  """
  getSR(ea, rg) -> sel_t
  """
  return _idaapi.getSR(*args)

def SetDefaultRegisterValue(*args):
  """
  SetDefaultRegisterValue(sg, rg, value) -> bool
  """
  return _idaapi.SetDefaultRegisterValue(*args)

def splitSRarea1(*args):
  """
  splitSRarea1(ea, rg, v, tag, silent=False) -> bool
  """
  return _idaapi.splitSRarea1(*args)
class strwinsetup_t(object):
    """
    Proxy of C++ strwinsetup_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> strwinsetup_t
        """
        this = _idaapi.new_strwinsetup_t(*args)
        try: self.this.append(this)
        except: self.this = this
    strtypes = _swig_property(_idaapi.strwinsetup_t_strtypes_get, _idaapi.strwinsetup_t_strtypes_set)
    minlen = _swig_property(_idaapi.strwinsetup_t_minlen_get, _idaapi.strwinsetup_t_minlen_set)
    display_only_existing_strings = _swig_property(_idaapi.strwinsetup_t_display_only_existing_strings_get, _idaapi.strwinsetup_t_display_only_existing_strings_set)
    only_7bit = _swig_property(_idaapi.strwinsetup_t_only_7bit_get, _idaapi.strwinsetup_t_only_7bit_set)
    ignore_heads = _swig_property(_idaapi.strwinsetup_t_ignore_heads_get, _idaapi.strwinsetup_t_ignore_heads_set)
    ea1 = _swig_property(_idaapi.strwinsetup_t_ea1_get, _idaapi.strwinsetup_t_ea1_set)
    ea2 = _swig_property(_idaapi.strwinsetup_t_ea2_get, _idaapi.strwinsetup_t_ea2_set)
    def is_initialized(self, *args):
        """
        is_initialized(self) -> bool
        """
        return _idaapi.strwinsetup_t_is_initialized(self, *args)

    __swig_destroy__ = _idaapi.delete_strwinsetup_t
    __del__ = lambda self : None;
strwinsetup_t_swigregister = _idaapi.strwinsetup_t_swigregister
strwinsetup_t_swigregister(strwinsetup_t)

class string_info_t(object):
    """
    Proxy of C++ string_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ea = _swig_property(_idaapi.string_info_t_ea_get, _idaapi.string_info_t_ea_set)
    length = _swig_property(_idaapi.string_info_t_length_get, _idaapi.string_info_t_length_set)
    type = _swig_property(_idaapi.string_info_t_type_get, _idaapi.string_info_t_type_set)
    def __init__(self, *args):
        """
        __init__(self) -> string_info_t
        __init__(self, _ea) -> string_info_t
        """
        this = _idaapi.new_string_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def __lt__(self, *args):
        """
        __lt__(self, string_info) -> bool
        """
        return _idaapi.string_info_t___lt__(self, *args)

    __swig_destroy__ = _idaapi.delete_string_info_t
    __del__ = lambda self : None;
string_info_t_swigregister = _idaapi.string_info_t_swigregister
string_info_t_swigregister(string_info_t)


def set_strlist_options(*args):
  """
  set_strlist_options(options) -> bool
  """
  return _idaapi.set_strlist_options(*args)

def refresh_strlist(*args):
  """
  refresh_strlist(ea1, ea2)
  """
  return _idaapi.refresh_strlist(*args)

def get_strlist_qty(*args):
  """
  get_strlist_qty() -> size_t
  """
  return _idaapi.get_strlist_qty(*args)

def get_strlist_item(*args):
  """
  get_strlist_item(n, si) -> bool
  """
  return _idaapi.get_strlist_item(*args)
STRUC_SEPARATOR = _idaapi.STRUC_SEPARATOR
class member_t(object):
    """
    Proxy of C++ member_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    id = _swig_property(_idaapi.member_t_id_get, _idaapi.member_t_id_set)
    soff = _swig_property(_idaapi.member_t_soff_get, _idaapi.member_t_soff_set)
    eoff = _swig_property(_idaapi.member_t_eoff_get, _idaapi.member_t_eoff_set)
    flag = _swig_property(_idaapi.member_t_flag_get, _idaapi.member_t_flag_set)
    props = _swig_property(_idaapi.member_t_props_get, _idaapi.member_t_props_set)
    def unimem(self, *args):
        """
        unimem(self) -> bool
        """
        return _idaapi.member_t_unimem(self, *args)

    def has_union(self, *args):
        """
        has_union(self) -> bool
        """
        return _idaapi.member_t_has_union(self, *args)

    def by_til(self, *args):
        """
        by_til(self) -> bool
        """
        return _idaapi.member_t_by_til(self, *args)

    def has_ti(self, *args):
        """
        has_ti(self) -> bool
        """
        return _idaapi.member_t_has_ti(self, *args)

    def get_soff(self, *args):
        """
        get_soff(self) -> ea_t
        """
        return _idaapi.member_t_get_soff(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> member_t
        """
        this = _idaapi.new_member_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_member_t
    __del__ = lambda self : None;
member_t_swigregister = _idaapi.member_t_swigregister
member_t_swigregister(member_t)
MF_OK = _idaapi.MF_OK
MF_UNIMEM = _idaapi.MF_UNIMEM
MF_HASUNI = _idaapi.MF_HASUNI
MF_BYTIL = _idaapi.MF_BYTIL
MF_HASTI = _idaapi.MF_HASTI

class struc_t(object):
    """
    Proxy of C++ struc_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    id = _swig_property(_idaapi.struc_t_id_get, _idaapi.struc_t_id_set)
    memqty = _swig_property(_idaapi.struc_t_memqty_get, _idaapi.struc_t_memqty_set)
    members = _swig_property(_idaapi.struc_t_members_get, _idaapi.struc_t_members_set)
    age = _swig_property(_idaapi.struc_t_age_get, _idaapi.struc_t_age_set)
    props = _swig_property(_idaapi.struc_t_props_get, _idaapi.struc_t_props_set)
    def is_varstr(self, *args):
        """
        is_varstr(self) -> bool
        """
        return _idaapi.struc_t_is_varstr(self, *args)

    def is_union(self, *args):
        """
        is_union(self) -> bool
        """
        return _idaapi.struc_t_is_union(self, *args)

    def has_union(self, *args):
        """
        has_union(self) -> bool
        """
        return _idaapi.struc_t_has_union(self, *args)

    def is_choosable(self, *args):
        """
        is_choosable(self) -> bool
        """
        return _idaapi.struc_t_is_choosable(self, *args)

    def from_til(self, *args):
        """
        from_til(self) -> bool
        """
        return _idaapi.struc_t_from_til(self, *args)

    def is_hidden(self, *args):
        """
        is_hidden(self) -> bool
        """
        return _idaapi.struc_t_is_hidden(self, *args)

    def get_alignment(self, *args):
        """
        get_alignment(self) -> int
        """
        return _idaapi.struc_t_get_alignment(self, *args)

    def is_ghost(self, *args):
        """
        is_ghost(self) -> bool
        """
        return _idaapi.struc_t_is_ghost(self, *args)

    def set_alignment(self, *args):
        """
        set_alignment(self, shift)
        """
        return _idaapi.struc_t_set_alignment(self, *args)

    def set_ghost(self, *args):
        """
        set_ghost(self, _is_ghost)
        """
        return _idaapi.struc_t_set_ghost(self, *args)

    ordinal = _swig_property(_idaapi.struc_t_ordinal_get, _idaapi.struc_t_ordinal_set)
    def get_member(self, *args):
        """
        get_member(self, index) -> member_t
        """
        return _idaapi.struc_t_get_member(self, *args)

    __swig_destroy__ = _idaapi.delete_struc_t
    __del__ = lambda self : None;
struc_t_swigregister = _idaapi.struc_t_swigregister
struc_t_swigregister(struc_t)
SF_VAR = _idaapi.SF_VAR
SF_UNION = _idaapi.SF_UNION
SF_HASUNI = _idaapi.SF_HASUNI
SF_NOLIST = _idaapi.SF_NOLIST
SF_TYPLIB = _idaapi.SF_TYPLIB
SF_HIDDEN = _idaapi.SF_HIDDEN
SF_FRAME = _idaapi.SF_FRAME
SF_ALIGN = _idaapi.SF_ALIGN
SF_GHOST = _idaapi.SF_GHOST


def get_struc_qty(*args):
  """
  get_struc_qty() -> size_t
  """
  return _idaapi.get_struc_qty(*args)

def get_first_struc_idx(*args):
  """
  get_first_struc_idx() -> uval_t
  """
  return _idaapi.get_first_struc_idx(*args)

def get_last_struc_idx(*args):
  """
  get_last_struc_idx() -> uval_t
  """
  return _idaapi.get_last_struc_idx(*args)

def get_prev_struc_idx(*args):
  """
  get_prev_struc_idx(idx) -> uval_t
  """
  return _idaapi.get_prev_struc_idx(*args)

def get_next_struc_idx(*args):
  """
  get_next_struc_idx(idx) -> uval_t
  """
  return _idaapi.get_next_struc_idx(*args)

def get_struc_idx(*args):
  """
  get_struc_idx(id) -> uval_t
  """
  return _idaapi.get_struc_idx(*args)

def get_struc_by_idx(*args):
  """
  get_struc_by_idx(idx) -> tid_t
  """
  return _idaapi.get_struc_by_idx(*args)

def get_struc(*args):
  """
  get_struc(id) -> struc_t
  """
  return _idaapi.get_struc(*args)

def get_struc_id(*args):
  """
  get_struc_id(name) -> tid_t
  """
  return _idaapi.get_struc_id(*args)

def get_struc_name(*args):
  """
  get_struc_name(id) -> ssize_t
  """
  return _idaapi.get_struc_name(*args)

def get_struc_cmt(*args):
  """
  get_struc_cmt(id, repeatable) -> ssize_t
  """
  return _idaapi.get_struc_cmt(*args)

def get_struc_size(*args):
  """
    get_struc_size(sptr) -> asize_t
    get_struc_size(id) -> asize_t
    """
  return _idaapi.get_struc_size(*args)

def get_struc_prev_offset(*args):
  """
  get_struc_prev_offset(sptr, offset) -> ea_t
  """
  return _idaapi.get_struc_prev_offset(*args)

def get_struc_next_offset(*args):
  """
  get_struc_next_offset(sptr, offset) -> ea_t
  """
  return _idaapi.get_struc_next_offset(*args)

def get_struc_last_offset(*args):
  """
  get_struc_last_offset(sptr) -> ea_t
  """
  return _idaapi.get_struc_last_offset(*args)

def get_struc_first_offset(*args):
  """
  get_struc_first_offset(sptr) -> ea_t
  """
  return _idaapi.get_struc_first_offset(*args)

def get_max_offset(*args):
  """
  get_max_offset(sptr) -> ea_t
  """
  return _idaapi.get_max_offset(*args)

def is_varstr(*args):
  """
  is_varstr(id) -> bool
  """
  return _idaapi.is_varstr(*args)

def is_union(*args):
  """
  is_union(id) -> bool
  """
  return _idaapi.is_union(*args)

def get_member_struc(*args):
  """
  get_member_struc(fullname) -> struc_t
  """
  return _idaapi.get_member_struc(*args)

def get_sptr(*args):
  """
  get_sptr(mptr) -> struc_t
  """
  return _idaapi.get_sptr(*args)

def get_member(*args):
  """
  get_member(sptr, offset) -> member_t
  """
  return _idaapi.get_member(*args)

def get_member_by_name(*args):
  """
  get_member_by_name(sptr, membername) -> member_t
  """
  return _idaapi.get_member_by_name(*args)

def get_member_by_fullname(*args):
  """
  get_member_by_fullname(fullname, sptr_place) -> member_t
  """
  return _idaapi.get_member_by_fullname(*args)

def get_member_fullname(*args):
  """
  get_member_fullname(mid) -> ssize_t
  """
  return _idaapi.get_member_fullname(*args)

def get_member_name2(*args):
  """
  get_member_name2(mid) -> ssize_t
  """
  return _idaapi.get_member_name2(*args)

def get_member_cmt(*args):
  """
  get_member_cmt(mid, repeatable) -> ssize_t
  """
  return _idaapi.get_member_cmt(*args)

def get_member_size(*args):
  """
  get_member_size(mptr) -> asize_t
  """
  return _idaapi.get_member_size(*args)

def is_varmember(*args):
  """
  is_varmember(mptr) -> bool
  """
  return _idaapi.is_varmember(*args)

def get_best_fit_member(*args):
  """
  get_best_fit_member(sptr, offset) -> member_t
  """
  return _idaapi.get_best_fit_member(*args)

def get_next_member_idx(*args):
  """
  get_next_member_idx(sptr, off) -> ssize_t
  """
  return _idaapi.get_next_member_idx(*args)

def get_prev_member_idx(*args):
  """
  get_prev_member_idx(sptr, off) -> ssize_t
  """
  return _idaapi.get_prev_member_idx(*args)

def add_struc(*args):
  """
  add_struc(idx, name, is_union=False) -> tid_t
  """
  return _idaapi.add_struc(*args)

def del_struc(*args):
  """
  del_struc(sptr) -> bool
  """
  return _idaapi.del_struc(*args)

def set_struc_idx(*args):
  """
  set_struc_idx(sptr, idx) -> bool
  """
  return _idaapi.set_struc_idx(*args)

def set_struc_align(*args):
  """
  set_struc_align(sptr, shift) -> bool
  """
  return _idaapi.set_struc_align(*args)

def set_struc_name(*args):
  """
  set_struc_name(id, name) -> bool
  """
  return _idaapi.set_struc_name(*args)

def set_struc_cmt(*args):
  """
  set_struc_cmt(id, cmt, repeatable) -> bool
  """
  return _idaapi.set_struc_cmt(*args)
STRUC_ERROR_MEMBER_OK = _idaapi.STRUC_ERROR_MEMBER_OK
STRUC_ERROR_MEMBER_NAME = _idaapi.STRUC_ERROR_MEMBER_NAME
STRUC_ERROR_MEMBER_OFFSET = _idaapi.STRUC_ERROR_MEMBER_OFFSET
STRUC_ERROR_MEMBER_SIZE = _idaapi.STRUC_ERROR_MEMBER_SIZE
STRUC_ERROR_MEMBER_TINFO = _idaapi.STRUC_ERROR_MEMBER_TINFO
STRUC_ERROR_MEMBER_STRUCT = _idaapi.STRUC_ERROR_MEMBER_STRUCT
STRUC_ERROR_MEMBER_UNIVAR = _idaapi.STRUC_ERROR_MEMBER_UNIVAR
STRUC_ERROR_MEMBER_VARLAST = _idaapi.STRUC_ERROR_MEMBER_VARLAST
STRUC_ERROR_MEMBER_NESTED = _idaapi.STRUC_ERROR_MEMBER_NESTED

def add_struc_member(*args):
  """
  add_struc_member(sptr, fieldname, offset, flag, mt, nbytes) -> struc_error_t
  """
  return _idaapi.add_struc_member(*args)

def del_struc_member(*args):
  """
  del_struc_member(sptr, offset) -> bool
  """
  return _idaapi.del_struc_member(*args)

def del_struc_members(*args):
  """
  del_struc_members(sptr, off1, off2) -> int
  """
  return _idaapi.del_struc_members(*args)

def set_member_name(*args):
  """
  set_member_name(sptr, offset, name) -> bool
  """
  return _idaapi.set_member_name(*args)

def set_member_type(*args):
  """
  set_member_type(sptr, offset, flag, mt, nbytes) -> bool
  """
  return _idaapi.set_member_type(*args)

def set_member_cmt(*args):
  """
  set_member_cmt(mptr, cmt, repeatable) -> bool
  """
  return _idaapi.set_member_cmt(*args)

def expand_struc(*args):
  """
  expand_struc(sptr, offset, delta, recalc=True) -> bool
  """
  return _idaapi.expand_struc(*args)

def save_struc2(*args):
  """
  save_struc2(sptr, may_update_ltypes=True)
  """
  return _idaapi.save_struc2(*args)

def set_struc_hidden(*args):
  """
  set_struc_hidden(sptr, is_hidden)
  """
  return _idaapi.set_struc_hidden(*args)

def set_struc_listed(*args):
  """
  set_struc_listed(sptr, is_listed)
  """
  return _idaapi.set_struc_listed(*args)
SMT_BADARG = _idaapi.SMT_BADARG
SMT_NOCOMPAT = _idaapi.SMT_NOCOMPAT
SMT_WORSE = _idaapi.SMT_WORSE
SMT_SIZE = _idaapi.SMT_SIZE
SMT_ARRAY = _idaapi.SMT_ARRAY
SMT_OVERLAP = _idaapi.SMT_OVERLAP
SMT_FAILED = _idaapi.SMT_FAILED
SMT_OK = _idaapi.SMT_OK
SMT_KEEP = _idaapi.SMT_KEEP

def get_member_tinfo2(*args):
  """
  get_member_tinfo2(mptr, tif) -> bool
  """
  return _idaapi.get_member_tinfo2(*args)

def del_member_tinfo(*args):
  """
  del_member_tinfo(sptr, mptr) -> bool
  """
  return _idaapi.del_member_tinfo(*args)

def set_member_tinfo2(*args):
  """
  set_member_tinfo2(sptr, mptr, memoff, tif, flags) -> smt_code_t
  """
  return _idaapi.set_member_tinfo2(*args)
SET_MEMTI_MAY_DESTROY = _idaapi.SET_MEMTI_MAY_DESTROY
SET_MEMTI_COMPATIBLE = _idaapi.SET_MEMTI_COMPATIBLE
SET_MEMTI_FUNCARG = _idaapi.SET_MEMTI_FUNCARG
SET_MEMTI_BYTIL = _idaapi.SET_MEMTI_BYTIL

def get_or_guess_member_tinfo2(*args):
  """
  get_or_guess_member_tinfo2(mptr, tif) -> bool
  """
  return _idaapi.get_or_guess_member_tinfo2(*args)

def retrieve_member_info(*args):
  """
  retrieve_member_info(mptr, buf) -> opinfo_t
  """
  return _idaapi.retrieve_member_info(*args)

def is_anonymous_member_name(*args):
  """
  is_anonymous_member_name(name) -> bool
  """
  return _idaapi.is_anonymous_member_name(*args)

def is_dummy_member_name(*args):
  """
  is_dummy_member_name(name) -> bool
  """
  return _idaapi.is_dummy_member_name(*args)

def get_member_by_id(*args):
  """
    get_member_by_id(mid, sptr_place) -> member_t
    get_member_by_id(mid, sptr_place=None) -> member_t
    """
  return _idaapi.get_member_by_id(*args)

def is_member_id(*args):
  """
  is_member_id(mid) -> bool
  """
  return _idaapi.is_member_id(*args)

def is_special_member(*args):
  """
  is_special_member(id) -> bool
  """
  return _idaapi.is_special_member(*args)
class struct_field_visitor_t(object):
    """
    Proxy of C++ struct_field_visitor_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def visit_field(self, *args):
        """
        visit_field(self, sptr, mptr) -> int
        """
        return _idaapi.struct_field_visitor_t_visit_field(self, *args)

    __swig_destroy__ = _idaapi.delete_struct_field_visitor_t
    __del__ = lambda self : None;
struct_field_visitor_t_swigregister = _idaapi.struct_field_visitor_t_swigregister
struct_field_visitor_t_swigregister(struct_field_visitor_t)


def visit_stroff_fields(*args):
  """
  visit_stroff_fields(sfv, path, plen, disp, appzero) -> flags_t
  """
  return _idaapi.visit_stroff_fields(*args)

def stroff_as_size(*args):
  """
  stroff_as_size(plen, sptr, value) -> bool
  """
  return _idaapi.stroff_as_size(*args)

def save_struc(*args):
  """
  save_struc(sptr)
  """
  return _idaapi.save_struc(*args)

def get_or_guess_member_type(*args):
  """
  get_or_guess_member_type(mptr, type, tsize) -> bool
  """
  return _idaapi.get_or_guess_member_type(*args)

def get_member_ti(*args):
  """
  get_member_ti(mptr, buf, bufsize) -> bool
  """
  return _idaapi.get_member_ti(*args)

def set_member_ti(*args):
  """
  set_member_ti(sptr, mptr, type, flags) -> bool
  """
  return _idaapi.set_member_ti(*args)

def get_or_guess_member_tinfo(*args):
  """
  get_or_guess_member_tinfo(mptr, type, fields) -> bool
  """
  return _idaapi.get_or_guess_member_tinfo(*args)

def get_member_tinfo(*args):
  """
  get_member_tinfo(mptr, buf, fields) -> bool
  """
  return _idaapi.get_member_tinfo(*args)

def set_member_tinfo(*args):
  """
  set_member_tinfo(til, sptr, mptr, memoff, type, fields, flags) -> bool
  """
  return _idaapi.set_member_tinfo(*args)

def get_member_name(*args):
  """
  get_member_name(mid) -> ssize_t
  """
  return _idaapi.get_member_name(*args)

def get_operand_immvals(*args):
  """
  get_operand_immvals(ea, n, v) -> size_t
  """
  return _idaapi.get_operand_immvals(*args)

def dataSeg_opreg(*args):
  """
  dataSeg_opreg(opnum, rgnum) -> ea_t
  """
  return _idaapi.dataSeg_opreg(*args)

def dataSeg_op(*args):
  """
  dataSeg_op(opnum) -> ea_t
  """
  return _idaapi.dataSeg_op(*args)

def dataSeg(*args):
  """
  dataSeg() -> ea_t
  """
  return _idaapi.dataSeg(*args)

def codeSeg(*args):
  """
  codeSeg(addr, opnum) -> ea_t
  """
  return _idaapi.codeSeg(*args)
tbo_123 = _idaapi.tbo_123
tbo_132 = _idaapi.tbo_132
tbo_213 = _idaapi.tbo_213
tbo_231 = _idaapi.tbo_231
tbo_312 = _idaapi.tbo_312
tbo_321 = _idaapi.tbo_321

def ua_next_byte(*args):
  """
  ua_next_byte() -> uint8
  """
  return _idaapi.ua_next_byte(*args)

def ua_next_word(*args):
  """
  ua_next_word() -> uint16
  """
  return _idaapi.ua_next_word(*args)

def ua_next_long(*args):
  """
  ua_next_long() -> uint32
  """
  return _idaapi.ua_next_long(*args)

def ua_next_qword(*args):
  """
  ua_next_qword() -> uint64
  """
  return _idaapi.ua_next_qword(*args)

def OutMnem(*args):
  """
  OutMnem(width=8, postfix=None) -> int
  """
  return _idaapi.OutMnem(*args)

def OutBadInstruction(*args):
  """
  OutBadInstruction()
  """
  return _idaapi.OutBadInstruction(*args)

def out_one_operand(*args):
  """
  out_one_operand(n) -> bool
  """
  return _idaapi.out_one_operand(*args)
OOF_SIGNMASK = _idaapi.OOF_SIGNMASK
OOFS_IFSIGN = _idaapi.OOFS_IFSIGN
OOFS_NOSIGN = _idaapi.OOFS_NOSIGN
OOFS_NEEDSIGN = _idaapi.OOFS_NEEDSIGN
OOF_SIGNED = _idaapi.OOF_SIGNED
OOF_NUMBER = _idaapi.OOF_NUMBER
OOF_WIDTHMASK = _idaapi.OOF_WIDTHMASK
OOFW_IMM = _idaapi.OOFW_IMM
OOFW_8 = _idaapi.OOFW_8
OOFW_16 = _idaapi.OOFW_16
OOFW_24 = _idaapi.OOFW_24
OOFW_32 = _idaapi.OOFW_32
OOFW_64 = _idaapi.OOFW_64
OOF_ADDR = _idaapi.OOF_ADDR
OOF_OUTER = _idaapi.OOF_OUTER
OOF_ZSTROFF = _idaapi.OOF_ZSTROFF
OOF_NOBNOT = _idaapi.OOF_NOBNOT
OOF_SPACES = _idaapi.OOF_SPACES

def out_symbol(*args):
  """
  out_symbol(c)
  """
  return _idaapi.out_symbol(*args)

def out_line(*args):
  """
  out_line(str, color)
  """
  return _idaapi.out_line(*args)

def out_keyword(*args):
  """
  out_keyword(str)
  """
  return _idaapi.out_keyword(*args)

def out_register(*args):
  """
  out_register(str)
  """
  return _idaapi.out_register(*args)

def out_tagon(*args):
  """
  out_tagon(tag)
  """
  return _idaapi.out_tagon(*args)

def out_tagoff(*args):
  """
  out_tagoff(tag)
  """
  return _idaapi.out_tagoff(*args)

def out_addr_tag(*args):
  """
  out_addr_tag(ea)
  """
  return _idaapi.out_addr_tag(*args)

def out_colored_register_line(*args):
  """
  out_colored_register_line(str)
  """
  return _idaapi.out_colored_register_line(*args)

def OutLine(*args):
  """
  OutLine(s)
  """
  return _idaapi.OutLine(*args)

def OutChar(*args):
  """
  OutChar(c)
  """
  return _idaapi.OutChar(*args)

def OutLong(*args):
  """
  OutLong(Word, radix)
  """
  return _idaapi.OutLong(*args)

def out_long(*args):
  """
  out_long(v, radix)
  """
  return _idaapi.out_long(*args)

def ua_dodata2(*args):
  """
  ua_dodata2(opoff, ea, dtype) -> bool
  """
  return _idaapi.ua_dodata2(*args)

def ua_add_cref(*args):
  """
  ua_add_cref(opoff, to, type)
  """
  return _idaapi.ua_add_cref(*args)

def ua_add_dref(*args):
  """
  ua_add_dref(opoff, to, type)
  """
  return _idaapi.ua_add_dref(*args)

def get_dtyp_flag(*args):
  """
  get_dtyp_flag(dtype) -> flags_t
  """
  return _idaapi.get_dtyp_flag(*args)

def get_dtyp_size(*args):
  """
  get_dtyp_size(dtype) -> size_t
  """
  return _idaapi.get_dtyp_size(*args)

def get_dtyp_by_size(*args):
  """
  get_dtyp_by_size(size) -> char
  """
  return _idaapi.get_dtyp_by_size(*args)

def create_insn(*args):
  """
  create_insn(ea) -> int
  """
  return _idaapi.create_insn(*args)

def decode_insn(*args):
  """
  decode_insn(ea) -> int
  """
  return _idaapi.decode_insn(*args)

def ua_outop2(*args):
  """
  ua_outop2(ea, n, flags=0) -> bool
  """
  return _idaapi.ua_outop2(*args)

def ua_mnem(*args):
  """
  ua_mnem(ea) -> char const *
  """
  return _idaapi.ua_mnem(*args)

def decode_prev_insn(*args):
  """
  decode_prev_insn(ea) -> ea_t
  """
  return _idaapi.decode_prev_insn(*args)

def guess_table_address(*args):
  """
  guess_table_address() -> ea_t
  """
  return _idaapi.guess_table_address(*args)

def guess_table_size(*args):
  """
  guess_table_size(jump_table) -> asize_t
  """
  return _idaapi.guess_table_size(*args)

def ua_dodata(*args):
  """
  ua_dodata(ea, dtype)
  """
  return _idaapi.ua_dodata(*args)

def ua_outop(*args):
  """
  ua_outop(ea, n) -> bool
  """
  return _idaapi.ua_outop(*args)

def ua_ana0(*args):
  """
  ua_ana0(ea) -> int
  """
  return _idaapi.ua_ana0(*args)

def ua_code(*args):
  """
  ua_code(ea) -> int
  """
  return _idaapi.ua_code(*args)

def init_output_buffer(*args):
  """
  init_output_buffer(size=1024) -> PyObject *


  This function initialize an output buffer with the given size.
  It should be called before using any out_xxxx() functions.
  @return: It returns a string. This string should then be passed to MakeLine().
           This function could return None if it failed to create a buffer with the given size.
  """
  return _idaapi.init_output_buffer(*args)

def term_output_buffer(*args):
  """
  term_output_buffer()


  Use this function to terminate an output buffer.
  """
  return _idaapi.term_output_buffer(*args)

def decode_preceding_insn(*args):
  """
  decode_preceding_insn(ea) -> PyObject *


  Decodes the preceding instruction. Please check ua.hpp / decode_preceding_insn()
  @param ea: current ea
  @return: tuple(preceeding_ea or BADADDR, farref = Boolean)
  """
  return _idaapi.decode_preceding_insn(*args)

def OutValue(*args):
  """
  OutValue(x, outflags=0) -> flags_t


  Output immediate value
  @param op: operand (of type op_t)
  @return: flags of the output value
           -1: value is output with COLOR_ERROR
           0:  value is output as a number or character or segment
  """
  return _idaapi.OutValue(*args)

def get_stkvar(*args):
  """
  get_stkvar(py_op, py_v) -> PyObject *


  Get pointer to stack variable
  @param op: reference to instruction operand
  @param v: immediate value in the operand (usually op.addr)
  @return:
      - None on failure
      - tuple(member_t, actval)
        where actval: actual value used to fetch stack variable
  """
  return _idaapi.get_stkvar(*args)

def add_stkvar3(*args):
  """
  add_stkvar3(py_op, py_v, flags) -> bool


  Automatically add stack variable if doesn't exist
  Processor modules should use ua_stkvar2()
  @param op: reference to instruction operand
  @param v: immediate value in the operand (usually op.addr)
  @param flags: combination of STKVAR_... constants
  @return: Boolean
  """
  return _idaapi.add_stkvar3(*args)

def apply_type_to_stkarg(*args):
  """
  apply_type_to_stkarg(py_op, py_uv, py_type, name) -> bool


  Apply type information to a stack variable
  
  @param op: reference to instruction operand
  @param v: immediate value in the operand (usually op.addr)
  @param type: type string. Retrieve from idc.ParseType("type string", flags)[1]
  @param name: stack variable name
  
  @return: Boolean
  """
  return _idaapi.apply_type_to_stkarg(*args)

def OutImmChar(*args):
  """
  OutImmChar(x)


  Output operand value as a commented character constant
  @param op: operand (of type op_t)
  @return: None
  """
  return _idaapi.OutImmChar(*args)

def ua_stkvar2(*args):
  """
  ua_stkvar2(x, v, flags) -> bool


  Create or modify a stack variable in the function frame.
  Please check ua.hpp / ua_stkvar2()
  @param op: operand (of type op_t)
  @return: None
  """
  return _idaapi.ua_stkvar2(*args)

def ua_add_off_drefs(*args):
  """
  ua_add_off_drefs(py_op, type) -> ea_t


  Add xrefs for offset operand of the current instruction
  Please check ua.hpp / ua_add_off_drefs()
  @param op: operand (of type op_t)
  @return: None
  """
  return _idaapi.ua_add_off_drefs(*args)

def ua_add_off_drefs2(*args):
  """
  ua_add_off_drefs2(py_op, type, outf) -> ea_t


  Add xrefs for offset operand of the current instruction
  Please check ua.hpp / ua_add_off_drefs2()
  @return: ea_t
  """
  return _idaapi.ua_add_off_drefs2(*args)

def out_name_expr(*args):
  """
  out_name_expr(py_op, ea, py_off) -> bool


  Output a name expression
  @param op: operand (of type op_t)
  @param ea: address of expression
  @param off: the value of name expression. this parameter is used only to
              check that the name expression will have the wanted value.
              You may pass BADADDR for this parameter.
  @return: true if the name expression has been produced
  """
  return _idaapi.out_name_expr(*args)

def construct_macro(*args):
  """
  construct_macro(enable, build_macro) -> bool


  See ua.hpp's construct_macro().
  """
  return _idaapi.construct_macro(*args)

def insn_t_get_op_link(*args):
  """
  insn_t_get_op_link(py_insn_lnk, i) -> PyObject *
  """
  return _idaapi.insn_t_get_op_link(*args)

def insn_t_create(*args):
  """
  insn_t_create() -> PyObject *
  """
  return _idaapi.insn_t_create(*args)

def op_t_create(*args):
  """
  op_t_create() -> PyObject *
  """
  return _idaapi.op_t_create(*args)

def op_t_assign(*args):
  """
  op_t_assign(self, other) -> bool
  """
  return _idaapi.op_t_assign(*args)

def insn_t_assign(*args):
  """
  insn_t_assign(self, other) -> bool
  """
  return _idaapi.insn_t_assign(*args)

def op_t_destroy(*args):
  """
  op_t_destroy(py_obj) -> bool
  """
  return _idaapi.op_t_destroy(*args)

def insn_t_destroy(*args):
  """
  insn_t_destroy(py_obj) -> bool
  """
  return _idaapi.insn_t_destroy(*args)

def py_get_global_cmd_link(*args):
  """
  py_get_global_cmd_link() -> PyObject *
  """
  return _idaapi.py_get_global_cmd_link(*args)

def insn_t_is_canon_insn(*args):
  """
  insn_t_is_canon_insn(itype) -> PyObject *
  """
  return _idaapi.insn_t_is_canon_insn(*args)

def insn_t_get_canon_feature(*args):
  """
  insn_t_get_canon_feature(itype) -> PyObject *
  """
  return _idaapi.insn_t_get_canon_feature(*args)

def insn_t_get_canon_mnem(*args):
  """
  insn_t_get_canon_mnem(itype) -> PyObject *
  """
  return _idaapi.insn_t_get_canon_mnem(*args)

def insn_t_get_cs(*args):
  """
  insn_t_get_cs(self) -> PyObject *
  """
  return _idaapi.insn_t_get_cs(*args)

def insn_t_set_cs(*args):
  """
  insn_t_set_cs(self, value)
  """
  return _idaapi.insn_t_set_cs(*args)

def insn_t_get_ip(*args):
  """
  insn_t_get_ip(self) -> PyObject *
  """
  return _idaapi.insn_t_get_ip(*args)

def insn_t_set_ip(*args):
  """
  insn_t_set_ip(self, value)
  """
  return _idaapi.insn_t_set_ip(*args)

def insn_t_get_ea(*args):
  """
  insn_t_get_ea(self) -> PyObject *
  """
  return _idaapi.insn_t_get_ea(*args)

def insn_t_set_ea(*args):
  """
  insn_t_set_ea(self, value)
  """
  return _idaapi.insn_t_set_ea(*args)

def insn_t_get_itype(*args):
  """
  insn_t_get_itype(self) -> PyObject *
  """
  return _idaapi.insn_t_get_itype(*args)

def insn_t_set_itype(*args):
  """
  insn_t_set_itype(self, value)
  """
  return _idaapi.insn_t_set_itype(*args)

def insn_t_get_size(*args):
  """
  insn_t_get_size(self) -> PyObject *
  """
  return _idaapi.insn_t_get_size(*args)

def insn_t_set_size(*args):
  """
  insn_t_set_size(self, value)
  """
  return _idaapi.insn_t_set_size(*args)

def insn_t_get_auxpref(*args):
  """
  insn_t_get_auxpref(self) -> PyObject *
  """
  return _idaapi.insn_t_get_auxpref(*args)

def insn_t_set_auxpref(*args):
  """
  insn_t_set_auxpref(self, value)
  """
  return _idaapi.insn_t_set_auxpref(*args)

def insn_t_get_segpref(*args):
  """
  insn_t_get_segpref(self) -> PyObject *
  """
  return _idaapi.insn_t_get_segpref(*args)

def insn_t_set_segpref(*args):
  """
  insn_t_set_segpref(self, value)
  """
  return _idaapi.insn_t_set_segpref(*args)

def insn_t_get_insnpref(*args):
  """
  insn_t_get_insnpref(self) -> PyObject *
  """
  return _idaapi.insn_t_get_insnpref(*args)

def insn_t_set_insnpref(*args):
  """
  insn_t_set_insnpref(self, value)
  """
  return _idaapi.insn_t_set_insnpref(*args)

def insn_t_get_flags(*args):
  """
  insn_t_get_flags(self) -> PyObject *
  """
  return _idaapi.insn_t_get_flags(*args)

def insn_t_set_flags(*args):
  """
  insn_t_set_flags(self, value)
  """
  return _idaapi.insn_t_set_flags(*args)

def op_t_get_n(*args):
  """
  op_t_get_n(self) -> PyObject *
  """
  return _idaapi.op_t_get_n(*args)

def op_t_set_n(*args):
  """
  op_t_set_n(self, value)
  """
  return _idaapi.op_t_set_n(*args)

def op_t_get_type(*args):
  """
  op_t_get_type(self) -> PyObject *
  """
  return _idaapi.op_t_get_type(*args)

def op_t_set_type(*args):
  """
  op_t_set_type(self, value)
  """
  return _idaapi.op_t_set_type(*args)

def op_t_get_offb(*args):
  """
  op_t_get_offb(self) -> PyObject *
  """
  return _idaapi.op_t_get_offb(*args)

def op_t_set_offb(*args):
  """
  op_t_set_offb(self, value)
  """
  return _idaapi.op_t_set_offb(*args)

def op_t_get_offo(*args):
  """
  op_t_get_offo(self) -> PyObject *
  """
  return _idaapi.op_t_get_offo(*args)

def op_t_set_offo(*args):
  """
  op_t_set_offo(self, value)
  """
  return _idaapi.op_t_set_offo(*args)

def op_t_get_flags(*args):
  """
  op_t_get_flags(self) -> PyObject *
  """
  return _idaapi.op_t_get_flags(*args)

def op_t_set_flags(*args):
  """
  op_t_set_flags(self, value)
  """
  return _idaapi.op_t_set_flags(*args)

def op_t_get_dtyp(*args):
  """
  op_t_get_dtyp(self) -> PyObject *
  """
  return _idaapi.op_t_get_dtyp(*args)

def op_t_set_dtyp(*args):
  """
  op_t_set_dtyp(self, value)
  """
  return _idaapi.op_t_set_dtyp(*args)

def op_t_get_reg_phrase(*args):
  """
  op_t_get_reg_phrase(self) -> PyObject *
  """
  return _idaapi.op_t_get_reg_phrase(*args)

def op_t_set_reg_phrase(*args):
  """
  op_t_set_reg_phrase(self, value)
  """
  return _idaapi.op_t_set_reg_phrase(*args)

def op_t_get_value(*args):
  """
  op_t_get_value(self) -> PyObject *
  """
  return _idaapi.op_t_get_value(*args)

def op_t_set_value(*args):
  """
  op_t_set_value(self, value)
  """
  return _idaapi.op_t_set_value(*args)

def op_t_get_addr(*args):
  """
  op_t_get_addr(self) -> PyObject *
  """
  return _idaapi.op_t_get_addr(*args)

def op_t_set_addr(*args):
  """
  op_t_set_addr(self, value)
  """
  return _idaapi.op_t_set_addr(*args)

def op_t_get_specval(*args):
  """
  op_t_get_specval(self) -> PyObject *
  """
  return _idaapi.op_t_get_specval(*args)

def op_t_set_specval(*args):
  """
  op_t_set_specval(self, value)
  """
  return _idaapi.op_t_set_specval(*args)

def op_t_get_specflag1(*args):
  """
  op_t_get_specflag1(self) -> PyObject *
  """
  return _idaapi.op_t_get_specflag1(*args)

def op_t_set_specflag1(*args):
  """
  op_t_set_specflag1(self, value)
  """
  return _idaapi.op_t_set_specflag1(*args)

def op_t_get_specflag2(*args):
  """
  op_t_get_specflag2(self) -> PyObject *
  """
  return _idaapi.op_t_get_specflag2(*args)

def op_t_set_specflag2(*args):
  """
  op_t_set_specflag2(self, value)
  """
  return _idaapi.op_t_set_specflag2(*args)

def op_t_get_specflag3(*args):
  """
  op_t_get_specflag3(self) -> PyObject *
  """
  return _idaapi.op_t_get_specflag3(*args)

def op_t_set_specflag3(*args):
  """
  op_t_set_specflag3(self, value)
  """
  return _idaapi.op_t_set_specflag3(*args)

def op_t_get_specflag4(*args):
  """
  op_t_get_specflag4(self) -> PyObject *
  """
  return _idaapi.op_t_get_specflag4(*args)

def op_t_set_specflag4(*args):
  """
  op_t_set_specflag4(self, value)
  """
  return _idaapi.op_t_set_specflag4(*args)
#<pycode(py_ua)>

# -----------------------------------------------------------------------
class op_t(py_clinked_object_t):
    """
    Class representing operands
    """
    def __init__(self, lnk = None):
        py_clinked_object_t.__init__(self, lnk)

    def _create_clink(self):
        return _idaapi.op_t_create()

    def _del_clink(self, lnk):
        return _idaapi.op_t_destroy(lnk)

    def assign(self, other):
        """
        Copies the contents of 'other' to 'self'
        """
        return _idaapi.op_t_assign(self, other)

    def __eq__(self, other):
        """
        Checks if two register operands are equal by checking the register number and its dtype
        """
        return (self.reg == other.reg) and (self.dtyp == other.dtyp)

    def is_reg(self, r):
        """
        Checks if the register operand is the given processor register
        """
        return self.type == o_reg and self.reg == r

    def has_reg(self, r):
        """
        Checks if the operand accesses the given processor register
        """
        return self.reg == r.reg

    #
    # Autogenerated
    #
    def __get_n__(self):
        return _idaapi.op_t_get_n(self)
    def __set_n__(self, v):
        _idaapi.op_t_set_n(self, v)
    def __get_type__(self):
        return _idaapi.op_t_get_type(self)
    def __set_type__(self, v):
        _idaapi.op_t_set_type(self, v)
    def __get_offb__(self):
        return _idaapi.op_t_get_offb(self)
    def __set_offb__(self, v):
        _idaapi.op_t_set_offb(self, v)
    def __get_offo__(self):
        return _idaapi.op_t_get_offo(self)
    def __set_offo__(self, v):
        _idaapi.op_t_set_offo(self, v)
    def __get_flags__(self):
        return _idaapi.op_t_get_flags(self)
    def __set_flags__(self, v):
        _idaapi.op_t_set_flags(self, v)
    def __get_dtyp__(self):
        return _idaapi.op_t_get_dtyp(self)
    def __set_dtyp__(self, v):
        _idaapi.op_t_set_dtyp(self, v)
    def __get_reg_phrase__(self):
        return _idaapi.op_t_get_reg_phrase(self)
    def __set_reg_phrase__(self, v):
        _idaapi.op_t_set_reg_phrase(self, v)
    def __get_value__(self):
        return _idaapi.op_t_get_value(self)
    def __set_value__(self, v):
        _idaapi.op_t_set_value(self, v)
    def __get_addr__(self):
        return _idaapi.op_t_get_addr(self)
    def __set_addr__(self, v):
        _idaapi.op_t_set_addr(self, v)
    def __get_specval__(self):
        return _idaapi.op_t_get_specval(self)
    def __set_specval__(self, v):
        _idaapi.op_t_set_specval(self, v)
    def __get_specflag1__(self):
        return _idaapi.op_t_get_specflag1(self)
    def __set_specflag1__(self, v):
        _idaapi.op_t_set_specflag1(self, v)
    def __get_specflag2__(self):
        return _idaapi.op_t_get_specflag2(self)
    def __set_specflag2__(self, v):
        _idaapi.op_t_set_specflag2(self, v)
    def __get_specflag3__(self):
        return _idaapi.op_t_get_specflag3(self)
    def __set_specflag3__(self, v):
        _idaapi.op_t_set_specflag3(self, v)
    def __get_specflag4__(self):
        return _idaapi.op_t_get_specflag4(self)
    def __set_specflag4__(self, v):
        _idaapi.op_t_set_specflag4(self, v)

    n = property(__get_n__, __set_n__)
    type = property(__get_type__, __set_type__)
    offb = property(__get_offb__, __set_offb__)
    offo = property(__get_offo__, __set_offo__)
    flags = property(__get_flags__, __set_flags__)
    dtyp = property(__get_dtyp__, __set_dtyp__)
    reg = property(__get_reg_phrase__, __set_reg_phrase__)
    phrase = property(__get_reg_phrase__, __set_reg_phrase__)
    value = property(__get_value__, __set_value__)
    addr = property(__get_addr__, __set_addr__)
    specval = property(__get_specval__, __set_specval__)
    specflag1 = property(__get_specflag1__, __set_specflag1__)
    specflag2 = property(__get_specflag2__, __set_specflag2__)
    specflag3 = property(__get_specflag3__, __set_specflag3__)
    specflag4 = property(__get_specflag4__, __set_specflag4__)

# -----------------------------------------------------------------------
class insn_t(py_clinked_object_t):
    """
    Class representing instructions
    """
    def __init__(self, lnk = None):
        py_clinked_object_t.__init__(self, lnk)

        # Create linked operands
        self.Operands = []
        for i in xrange(0, UA_MAXOP):
            self.Operands.append(op_t(insn_t_get_op_link(self.clink, i)))

        # Convenience operand reference objects
        self.Op1 = self.Operands[0]
        self.Op2 = self.Operands[1]
        self.Op3 = self.Operands[2]
        self.Op4 = self.Operands[3]
        self.Op5 = self.Operands[4]
        self.Op6 = self.Operands[5]

    def assign(self, other):
        """
        Copies the contents of 'other' to 'self'
        """
        return _idaapi.insn_t_assign(self, other)

#<pydoc>
#    def copy(self):
#        """Returns a new copy of this class"""
#        pass
#</pydoc>

    def _create_clink(self):
        return _idaapi.insn_t_create()


    def _del_clink(self, lnk):
        return _idaapi.insn_t_destroy(lnk)


    def __iter__(self):
        return (self.Operands[idx] for idx in xrange(0, UA_MAXOP))


    def __getitem__(self, idx):
        """
        Operands can be accessed directly as indexes
        @return op_t: Returns an operand of type op_t
        """
        if idx >= UA_MAXOP:
            raise KeyError
        else:
            return self.Operands[idx]

    def is_macro(self):
        return self.flags & INSN_MACRO != 0

    def is_canon_insn(self):
        return _idaapi.insn_t_is_canon_insn(self.itype)

    def get_canon_feature(self):
        return _idaapi.insn_t_get_canon_feature(self.itype)

    def get_canon_mnem(self):
        return _idaapi.insn_t_get_canon_mnem(self.itype)

    #
    # Autogenerated
    #
    def __get_cs__(self):
        return _idaapi.insn_t_get_cs(self)
    def __set_cs__(self, v):
        _idaapi.insn_t_set_cs(self, v)
    def __get_ip__(self):
        return _idaapi.insn_t_get_ip(self)
    def __set_ip__(self, v):
        _idaapi.insn_t_set_ip(self, v)
    def __get_ea__(self):
        return _idaapi.insn_t_get_ea(self)
    def __set_ea__(self, v):
        _idaapi.insn_t_set_ea(self, v)
    def __get_itype__(self):
        return _idaapi.insn_t_get_itype(self)
    def __set_itype__(self, v):
        _idaapi.insn_t_set_itype(self, v)
    def __get_size__(self):
        return _idaapi.insn_t_get_size(self)
    def __set_size__(self, v):
        _idaapi.insn_t_set_size(self, v)
    def __get_auxpref__(self):
        return _idaapi.insn_t_get_auxpref(self)
    def __set_auxpref__(self, v):
        _idaapi.insn_t_set_auxpref(self, v)
    def __get_segpref__(self):
        return _idaapi.insn_t_get_segpref(self)
    def __set_segpref__(self, v):
        _idaapi.insn_t_set_segpref(self, v)
    def __get_insnpref__(self):
        return _idaapi.insn_t_get_insnpref(self)
    def __set_insnpref__(self, v):
        _idaapi.insn_t_set_insnpref(self, v)
    def __get_flags__(self):
        return _idaapi.insn_t_get_flags(self)
    def __set_flags__(self, v):
        _idaapi.insn_t_set_flags(self, v)

    cs = property(__get_cs__, __set_cs__)
    ip = property(__get_ip__, __set_ip__)
    ea = property(__get_ea__, __set_ea__)
    itype = property(__get_itype__, __set_itype__)
    size = property(__get_size__, __set_size__)
    auxpref = property(__get_auxpref__, __set_auxpref__)
    segpref = property(__get_segpref__, __set_segpref__)
    insnpref = property(__get_insnpref__, __set_insnpref__)
    flags = property(__get_flags__, __set_flags__)


#----------------------------------------------------------------------------
#               P R O C E S S O R  M O D U L E S  C O N S T A N T S
#----------------------------------------------------------------------------

# ----------------------------------------------------------------------
# processor_t related constants

CUSTOM_CMD_ITYPE    = 0x8000
REG_SPOIL           = 0x80000000

REAL_ERROR_FORMAT   = -1   #  not supported format for current .idp
REAL_ERROR_RANGE    = -2   #  number too big (small) for store (mem NOT modifyed)
REAL_ERROR_BADDATA  = -3   #  illegal real data for load (IEEE data not filled)

#
#  Check whether the operand is relative to stack pointer or frame pointer.
#  This function is used to determine how to output a stack variable
#  This function may be absent. If it is absent, then all operands
#  are sp based by default.
#  Define this function only if some stack references use frame pointer
#  instead of stack pointer.
#  returns flags:
OP_FP_BASED   = 0x00000000   #  operand is FP based
OP_SP_BASED   = 0x00000001   #  operand is SP based
OP_SP_ADD     = 0x00000000   #  operand value is added to the pointer
OP_SP_SUB     = 0x00000002   #  operand value is substracted from the pointer

# processor_t.id
PLFM_386        = 0       # Intel 80x86
PLFM_Z80        = 1       # 8085, Z80
PLFM_I860       = 2       # Intel 860
PLFM_8051       = 3       # 8051
PLFM_TMS        = 4       # Texas Instruments TMS320C5x
PLFM_6502       = 5       # 6502
PLFM_PDP        = 6       # PDP11
PLFM_68K        = 7       # Motoroal 680x0
PLFM_JAVA       = 8       # Java
PLFM_6800       = 9       # Motorola 68xx
PLFM_ST7        = 10      # SGS-Thomson ST7
PLFM_MC6812     = 11      # Motorola 68HC12
PLFM_MIPS       = 12      # MIPS
PLFM_ARM        = 13      # Advanced RISC Machines
PLFM_TMSC6      = 14      # Texas Instruments TMS320C6x
PLFM_PPC        = 15      # PowerPC
PLFM_80196      = 16      # Intel 80196
PLFM_Z8         = 17      # Z8
PLFM_SH         = 18      # Renesas (formerly Hitachi) SuperH
PLFM_NET        = 19      # Microsoft Visual Studio.Net
PLFM_AVR        = 20      # Atmel 8-bit RISC processor(s)
PLFM_H8         = 21      # Hitachi H8/300, H8/2000
PLFM_PIC        = 22      # Microchip's PIC
PLFM_SPARC      = 23      # SPARC
PLFM_ALPHA      = 24      # DEC Alpha
PLFM_HPPA       = 25      # Hewlett-Packard PA-RISC
PLFM_H8500      = 26      # Hitachi H8/500
PLFM_TRICORE    = 27      # Tasking Tricore
PLFM_DSP56K     = 28      # Motorola DSP5600x
PLFM_C166       = 29      # Siemens C166 family
PLFM_ST20       = 30      # SGS-Thomson ST20
PLFM_IA64       = 31      # Intel Itanium IA64
PLFM_I960       = 32      # Intel 960
PLFM_F2MC       = 33      # Fujistu F2MC-16
PLFM_TMS320C54  = 34      # Texas Instruments TMS320C54xx
PLFM_TMS320C55  = 35      # Texas Instruments TMS320C55xx
PLFM_TRIMEDIA   = 36      # Trimedia
PLFM_M32R       = 37      # Mitsubishi 32bit RISC
PLFM_NEC_78K0   = 38      # NEC 78K0
PLFM_NEC_78K0S  = 39      # NEC 78K0S
PLFM_M740       = 40      # Mitsubishi 8bit
PLFM_M7700      = 41      # Mitsubishi 16bit
PLFM_ST9        = 42      # ST9+
PLFM_FR         = 43      # Fujitsu FR Family
PLFM_MC6816     = 44      # Motorola 68HC16
PLFM_M7900      = 45      # Mitsubishi 7900
PLFM_TMS320C3   = 46      # Texas Instruments TMS320C3
PLFM_KR1878     = 47      # Angstrem KR1878
PLFM_AD218X     = 48      # Analog Devices ADSP 218X
PLFM_OAKDSP     = 49      # Atmel OAK DSP
PLFM_TLCS900    = 50      # Toshiba TLCS-900
PLFM_C39        = 51      # Rockwell C39
PLFM_CR16       = 52      # NSC CR16
PLFM_MN102L00   = 53      # Panasonic MN10200
PLFM_TMS320C1X  = 54      # Texas Instruments TMS320C1x
PLFM_NEC_V850X  = 55      # NEC V850 and V850ES/E1/E2
PLFM_SCR_ADPT   = 56      # Processor module adapter for processor modules written in scripting languages
PLFM_EBC        = 57      # EFI Bytecode
PLFM_MSP430     = 58      # Texas Instruments MSP430
PLFM_SPU        = 59      # Cell Broadband Engine Synergistic Processor Unit

#
# processor_t.flag
#
PR_SEGS        = 0x000001    #  has segment registers?
PR_USE32       = 0x000002    #  supports 32-bit addressing?
PR_DEFSEG32    = 0x000004    #  segments are 32-bit by default
PR_RNAMESOK    = 0x000008    #  allow to user register names for location names
PR_ADJSEGS     = 0x000020    #  IDA may adjust segments moving their starting/ending addresses.
PR_DEFNUM      = 0x0000C0    #  default number representation:
PRN_HEX        = 0x000000    #       hex
PRN_OCT        = 0x000040    #       octal
PRN_DEC        = 0x000080    #       decimal
PRN_BIN        = 0x0000C0    #       binary
PR_WORD_INS    = 0x000100    #  instruction codes are grouped 2bytes in binrary line prefix
PR_NOCHANGE    = 0x000200    #  The user can't change segments and code/data attributes (display only)
PR_ASSEMBLE    = 0x000400    #  Module has a built-in assembler and understands IDP_ASSEMBLE
PR_ALIGN       = 0x000800    #  All data items should be aligned properly
PR_TYPEINFO    = 0x001000    #  the processor module supports
                             #     type information callbacks
                             #     ALL OF THEM SHOULD BE IMPLEMENTED!
                             #     (the ones >= decorate_name)
PR_USE64       = 0x002000    #  supports 64-bit addressing?
PR_SGROTHER    = 0x004000    #  the segment registers don't contain
                             #     the segment selectors, something else
PR_STACK_UP    = 0x008000    #  the stack grows up
PR_BINMEM      = 0x010000    #  the processor module provides correct
                             #     segmentation for binary files
                             #     (i.e. it creates additional segments)
                             #     The kernel will not ask the user
                             #     to specify the RAM/ROM sizes
PR_SEGTRANS    = 0x020000    #  the processor module supports
                             #     the segment translation feature
                             #     (it means it calculates the code
                             #     addresses using the codeSeg() function)
PR_CHK_XREF    = 0x040000    #  don't allow near xrefs between segments
                             #     with different bases
PR_NO_SEGMOVE  = 0x080000    #  the processor module doesn't support move_segm()
                             #     (i.e. the user can't move segments)
PR_FULL_HIFXP  = 0x100000    #  REF_VHIGH operand value contains full operand
                             #     not only the high bits. Meaningful if ph.high_fixup_bits
PR_USE_ARG_TYPES = 0x200000  #  use ph.use_arg_types callback
PR_SCALE_STKVARS = 0x400000  #  use ph.get_stkvar_scale callback
PR_DELAYED     = 0x800000    #  has delayed jumps and calls
PR_ALIGN_INSN  = 0x1000000   #  allow ida to create alignment instructions
                             #     arbirtrarily. Since these instructions
                             #     might lead to other wrong instructions
                             #     and spoil the listing, IDA does not create
                             #     them by default anymore
PR_PURGING     = 0x2000000   #  there are calling conventions which may
                             #     purge bytes from the stack
PR_CNDINSNS    = 0x4000000   #  has conditional instructions
PR_USE_TBYTE   = 0x8000000   #  BTMT_SPECFLT means _TBYTE type
PR_DEFSEG64    = 0x10000000  #  segments are 64-bit by default


# ----------------------------------------------------------------------
#
# Misc constants
#
UA_MAXOP   = 6
"""
The maximum number of operands in the insn_t structure
"""

# Create 'cmd' into the global scope
cmd = insn_t(_idaapi.py_get_global_cmd_link())
"""
cmd is a global variable of type insn_t. It is contains information about the last decoded instruction.
This variable is also filled by processor modules when they decode instructions.
"""

# ----------------------------------------------------------------------
# instruc_t related constants

#
# instruc_t.feature
#
CF_STOP = 0x00001 #  Instruction doesn't pass execution to the next instruction
CF_CALL = 0x00002 #  CALL instruction (should make a procedure here)
CF_CHG1 = 0x00004 #  The instruction modifies the first operand
CF_CHG2 = 0x00008 #  The instruction modifies the second operand
CF_CHG3 = 0x00010 #  The instruction modifies the third operand
CF_CHG4 = 0x00020 #  The instruction modifies 4 operand
CF_CHG5 = 0x00040 #  The instruction modifies 5 operand
CF_CHG6 = 0x00080 #  The instruction modifies 6 operand
CF_USE1 = 0x00100 #  The instruction uses value of the first operand
CF_USE2 = 0x00200 #  The instruction uses value of the second operand
CF_USE3 = 0x00400 #  The instruction uses value of the third operand
CF_USE4 = 0x00800 #  The instruction uses value of the 4 operand
CF_USE5 = 0x01000 #  The instruction uses value of the 5 operand
CF_USE6 = 0x02000 #  The instruction uses value of the 6 operand
CF_JUMP = 0x04000 #  The instruction passes execution using indirect jump or call (thus needs additional analysis)
CF_SHFT = 0x08000 #  Bit-shift instruction (shl,shr...)
CF_HLL  = 0x10000 #  Instruction may be present in a high level language function.

# ----------------------------------------------------------------------
# op_t related constants

#
# op_t.type
#                 Description                          Data field
o_void     =  0 # No Operand                           ----------
o_reg      =  1 # General Register (al,ax,es,ds...)    reg
o_mem      =  2 # Direct Memory Reference  (DATA)      addr
o_phrase   =  3 # Memory Ref [Base Reg + Index Reg]    phrase
o_displ    =  4 # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr
o_imm      =  5 # Immediate Value                      value
o_far      =  6 # Immediate Far Address  (CODE)        addr
o_near     =  7 # Immediate Near Address (CODE)        addr
o_idpspec0 =  8 # Processor specific type
o_idpspec1 =  9 # Processor specific type
o_idpspec2 = 10 # Processor specific type
o_idpspec3 = 11 # Processor specific type
o_idpspec4 = 12 # Processor specific type
o_idpspec5 = 13 # Processor specific type
                # There can be more processor specific types

#
# op_t.dtyp
#
dt_byte = 0 #  8 bit
dt_word = 1 #  16 bit
dt_dword = 2 #  32 bit
dt_float = 3 #  4 byte
dt_double = 4 #  8 byte
dt_tbyte = 5 #  variable size (ph.tbyte_size)
dt_packreal = 6 #  packed real format for mc68040
dt_qword = 7 #  64 bit
dt_byte16 = 8 #  128 bit
dt_code = 9 #  ptr to code (not used?)
dt_void = 10 #  none
dt_fword = 11 #  48 bit
dt_bitfild = 12 #  bit field (mc680x0)
dt_string = 13 #  pointer to asciiz string
dt_unicode = 14 #  pointer to unicode string
dt_3byte = 15 #  3-byte data
dt_ldbl = 16 #  long double (which may be different from tbyte)
dt_byte32 = 17 # 256 bit
dt_byte64 = 18 # 512 bit

#
# op_t.flags
#
OF_NO_BASE_DISP = 0x80 #  o_displ: base displacement doesn't exist meaningful only for o_displ type if set, base displacement (x.addr) doesn't exist.
OF_OUTER_DISP = 0x40 #  o_displ: outer displacement exists meaningful only for o_displ type if set, outer displacement (x.value) exists.
PACK_FORM_DEF = 0x20 #  !o_reg + dt_packreal: packed factor defined
OF_NUMBER = 0x10 # can be output as number only if set, the operand can be converted to a number only
OF_SHOW = 0x08 #  should the operand be displayed? if clear, the operand is hidden and should not be displayed

#
# insn_t.flags
#
INSN_MACRO  = 0x01   # macro instruction
INSN_MODMAC = 0x02   # macros: may modify the database to make room for the macro insn

#
# Set IDP options constants
#
IDPOPT_STR        =  1    # string constant
IDPOPT_NUM        =  2    # number
IDPOPT_BIT        =  3    # bit, yes/no
IDPOPT_FLT        =  4    # float
IDPOPT_I64        =  5    # 64bit number

IDPOPT_OK         =  0    # ok
IDPOPT_BADKEY     =  1    # illegal keyword
IDPOPT_BADTYPE    =  2    # illegal type of value
IDPOPT_BADVALUE   =  3    # illegal value (bad range, for example)

# ----------------------------------------------------------------------
class processor_t(pyidc_opaque_object_t):
    """
    Base class for all processor module scripts
    """
    def __init__(self):
        # Take a reference to 'cmd'
        self.cmd = cmd

    def get_idpdesc(self):
        """
        This function must be present and should return the list of
        short processor names similar to the one in ph.psnames.
        This method can be overridden to return to the kernel a different IDP description.
        """
        return '\x01'.join(map(lambda t: '\x01'.join(t), zip(self.plnames, self.psnames)))

    def get_uFlag(self):
        """
        Use this utility function to retrieve the 'uFlag' global variable
        """
        return _idaapi.cvar.uFlag

    def get_auxpref(self):
        """
        This function returns cmd.auxpref value
        """
        return self.cmd.auxpref


# ----------------------------------------------------------------------
class __ph(object):
    id = property(lambda self: ph_get_id())
    cnbits = property(lambda self: ph_get_cnbits())
    dnbits = property(lambda self: ph_get_dnbits())
    flag = property(lambda self: ph_get_flag())
    high_fixup_bits = property(lambda self: ph_get_high_fixup_bits())
    icode_return = property(lambda self: ph_get_icode_return())
    instruc = property(lambda self: ph_get_instruc())
    instruc_end = property(lambda self: ph_get_instruc_end())
    instruc_start = property(lambda self: ph_get_instruc_start())
    regCodeSreg = property(lambda self: ph_get_regCodeSreg())
    regDataSreg = property(lambda self: ph_get_regDataSreg())
    regFirstSreg = property(lambda self: ph_get_regFirstSreg())
    regLastSreg = property(lambda self: ph_get_regLastSreg())
    regnames = property(lambda self: ph_get_regnames())
    segreg_size = property(lambda self: ph_get_segreg_size())
    tbyte_size = property(lambda self: ph_get_tbyte_size())
    version = property(lambda self: ph_get_version())

ph = __ph()

#</pycode(py_ua)>

fl_U = _idaapi.fl_U
fl_CF = _idaapi.fl_CF
fl_CN = _idaapi.fl_CN
fl_JF = _idaapi.fl_JF
fl_JN = _idaapi.fl_JN
fl_USobsolete = _idaapi.fl_USobsolete
fl_F = _idaapi.fl_F
dr_U = _idaapi.dr_U
dr_O = _idaapi.dr_O
dr_W = _idaapi.dr_W
dr_R = _idaapi.dr_R
dr_T = _idaapi.dr_T
dr_I = _idaapi.dr_I
XREF_USER = _idaapi.XREF_USER
XREF_TAIL = _idaapi.XREF_TAIL
XREF_BASE = _idaapi.XREF_BASE
XREF_MASK = _idaapi.XREF_MASK
XREF_PASTEND = _idaapi.XREF_PASTEND

def xrefchar(*args):
  """
  xrefchar(xrtype) -> char
  """
  return _idaapi.xrefchar(*args)

def add_cref(*args):
  """
  add_cref(frm, to, type) -> bool
  """
  return _idaapi.add_cref(*args)

def del_cref(*args):
  """
  del_cref(frm, to, expand) -> int
  """
  return _idaapi.del_cref(*args)

def add_dref(*args):
  """
  add_dref(frm, to, type) -> bool
  """
  return _idaapi.add_dref(*args)

def del_dref(*args):
  """
  del_dref(frm, to)
  """
  return _idaapi.del_dref(*args)
class xrefblk_t(object):
    """
    Proxy of C++ xrefblk_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    frm = _swig_property(_idaapi.xrefblk_t_frm_get, _idaapi.xrefblk_t_frm_set)
    to = _swig_property(_idaapi.xrefblk_t_to_get, _idaapi.xrefblk_t_to_set)
    iscode = _swig_property(_idaapi.xrefblk_t_iscode_get, _idaapi.xrefblk_t_iscode_set)
    type = _swig_property(_idaapi.xrefblk_t_type_get, _idaapi.xrefblk_t_type_set)
    user = _swig_property(_idaapi.xrefblk_t_user_get, _idaapi.xrefblk_t_user_set)
    def first_from(self, *args):
        """
        first_from(self, _from, flags) -> bool
        """
        return _idaapi.xrefblk_t_first_from(self, *args)

    def first_to(self, *args):
        """
        first_to(self, _to, flags) -> bool
        """
        return _idaapi.xrefblk_t_first_to(self, *args)

    def next_from(self, *args):
        """
        next_from(self) -> bool
        next_from(self, _from, _to, flags) -> bool
        """
        return _idaapi.xrefblk_t_next_from(self, *args)

    def next_to(self, *args):
        """
        next_to(self) -> bool
        next_to(self, _from, _to, flags) -> bool
        """
        return _idaapi.xrefblk_t_next_to(self, *args)

    def __init__(self, *args):
        """
        __init__(self) -> xrefblk_t
        """
        this = _idaapi.new_xrefblk_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _idaapi.delete_xrefblk_t
    __del__ = lambda self : None;
xrefblk_t_swigregister = _idaapi.xrefblk_t_swigregister
xrefblk_t_swigregister(xrefblk_t)
XREF_ALL = _idaapi.XREF_ALL
XREF_FAR = _idaapi.XREF_FAR
XREF_DATA = _idaapi.XREF_DATA


def get_first_dref_from(*args):
  """
  get_first_dref_from(frm) -> ea_t
  """
  return _idaapi.get_first_dref_from(*args)

def get_next_dref_from(*args):
  """
  get_next_dref_from(frm, current) -> ea_t
  """
  return _idaapi.get_next_dref_from(*args)

def get_first_dref_to(*args):
  """
  get_first_dref_to(to) -> ea_t
  """
  return _idaapi.get_first_dref_to(*args)

def get_next_dref_to(*args):
  """
  get_next_dref_to(to, current) -> ea_t
  """
  return _idaapi.get_next_dref_to(*args)

def get_first_cref_from(*args):
  """
  get_first_cref_from(frm) -> ea_t
  """
  return _idaapi.get_first_cref_from(*args)

def get_next_cref_from(*args):
  """
  get_next_cref_from(frm, current) -> ea_t
  """
  return _idaapi.get_next_cref_from(*args)

def get_first_cref_to(*args):
  """
  get_first_cref_to(to) -> ea_t
  """
  return _idaapi.get_first_cref_to(*args)

def get_next_cref_to(*args):
  """
  get_next_cref_to(to, current) -> ea_t
  """
  return _idaapi.get_next_cref_to(*args)

def get_first_fcref_from(*args):
  """
  get_first_fcref_from(frm) -> ea_t
  """
  return _idaapi.get_first_fcref_from(*args)

def get_next_fcref_from(*args):
  """
  get_next_fcref_from(frm, current) -> ea_t
  """
  return _idaapi.get_next_fcref_from(*args)

def get_first_fcref_to(*args):
  """
  get_first_fcref_to(to) -> ea_t
  """
  return _idaapi.get_first_fcref_to(*args)

def get_next_fcref_to(*args):
  """
  get_next_fcref_to(to, current) -> ea_t
  """
  return _idaapi.get_next_fcref_to(*args)

def has_external_refs(*args):
  """
  has_external_refs(pfn, ea) -> bool
  """
  return _idaapi.has_external_refs(*args)

def calc_switch_cases(*args):
  """
    calc_switch_cases(insn_ea, py_swi) -> cases_and_targets_t
    calc_switch_cases(insn_ea, si, casevec, targets) -> bool


  Get information about a switch's cases.
  
  The returned information can be used as follows:
  
      for idx in xrange(len(results.cases)):
          cur_case = results.cases[idx]
          for cidx in xrange(len(cur_case)):
              print "case: %d" % cur_case[cidx]
          print "  goto 0x%x" % results.targets[idx]
  
  @param insn_ea: address of the 'indirect jump' instruction
  @param si: switch information
  
  @return: a structure with 2 members: 'cases', and 'targets'.
    """
  return _idaapi.calc_switch_cases(*args)

def pygc_refresh(*args):
  """
  pygc_refresh(self)
  """
  return _idaapi.pygc_refresh(*args)

def pygc_set_node_info(*args):
  """
  pygc_set_node_info(self, py_node_idx, py_node_info, py_flags)
  """
  return _idaapi.pygc_set_node_info(*args)

def pygc_set_nodes_infos(*args):
  """
  pygc_set_nodes_infos(self, values)
  """
  return _idaapi.pygc_set_nodes_infos(*args)

def pygc_get_node_info(*args):
  """
  pygc_get_node_info(self, py_node_idx) -> PyObject *
  """
  return _idaapi.pygc_get_node_info(*args)

def pygc_del_nodes_infos(*args):
  """
  pygc_del_nodes_infos(self, py_nodes)
  """
  return _idaapi.pygc_del_nodes_infos(*args)

def pygc_get_current_renderer_type(*args):
  """
  pygc_get_current_renderer_type(self) -> PyObject *
  """
  return _idaapi.pygc_get_current_renderer_type(*args)

def pygc_set_current_renderer_type(*args):
  """
  pygc_set_current_renderer_type(self, py_rt)
  """
  return _idaapi.pygc_set_current_renderer_type(*args)

def pygc_create_groups(*args):
  """
  pygc_create_groups(self, groups_infos) -> PyObject *
  """
  return _idaapi.pygc_create_groups(*args)

def pygc_delete_groups(*args):
  """
  pygc_delete_groups(self, groups, new_current) -> PyObject *
  """
  return _idaapi.pygc_delete_groups(*args)

def pygc_set_groups_visibility(*args):
  """
  pygc_set_groups_visibility(self, groups, expand, new_current) -> PyObject *
  """
  return _idaapi.pygc_set_groups_visibility(*args)

def pycim_get_tform(*args):
  """
  pycim_get_tform(self) -> TForm *
  """
  return _idaapi.pycim_get_tform(*args)

def pycim_get_tcustom_control(*args):
  """
  pycim_get_tcustom_control(self) -> TCustomControl *
  """
  return _idaapi.pycim_get_tcustom_control(*args)
#<pycode(py_view_base)>
class CustomIDAMemo(object):
    def Refresh(self):
        """
        Refreshes the graph. This causes the OnRefresh() to be called
        """
        _idaapi.pygc_refresh(self)

    def GetCurrentRendererType(self):
        return _idaapi.pygc_get_current_renderer_type(self)

    def SetCurrentRendererType(self, rtype):
        """
        Set the current view's renderer.

        @param rtype: The renderer type. Should be one of the idaapi.TCCRT_* values.
        """
        _idaapi.pygc_set_current_renderer_type(self, rtype)

    def SetNodeInfo(self, node_index, node_info, flags):
        """
        Set the properties for the given node.

        Example usage (set second nodes's bg color to red):
          inst = ...
          p = idaapi.node_info_t()
          p.bg_color = 0x00ff0000
          inst.SetNodeInfo(1, p, idaapi.NIF_BG_COLOR)

        @param node_index: The node index.
        @param node_info: An idaapi.node_info_t instance.
        @param flags: An OR'ed value of NIF_* values.
        """
        _idaapi.pygc_set_node_info(self, node_index, node_info, flags)

    def SetNodesInfos(self, values):
        """
        Set the properties for the given nodes.

        Example usage (set first three nodes's bg color to purple):
          inst = ...
          p = idaapi.node_info_t()
          p.bg_color = 0x00ff00ff
          inst.SetNodesInfos({0 : p, 1 : p, 2 : p})

        @param values: A dictionary of 'int -> node_info_t' objects.
        """
        _idaapi.pygc_set_nodes_infos(self, values)

    def GetNodeInfo(self, node):
        """
        Get the properties for the given node.

        @param node: The index of the node.
        @return: A tuple (bg_color, frame_color, ea, text), or None.
        """
        return _idaapi.pygc_get_node_info(self, node)

    def DelNodesInfos(self, *nodes):
        """
        Delete the properties for the given node(s).

        @param nodes: A list of node IDs
        """
        return _idaapi.pygc_del_nodes_infos(self, nodes)

    def CreateGroups(self, groups_infos):
        """
        Send a request to modify the graph by creating a
        (set of) group(s), and perform an animation.

        Each object in the 'groups_infos' list must be of the format:
        {
          "nodes" : [<int>, <int>, <int>, ...] # The list of nodes to group
          "text" : <string>                    # The synthetic text for that group
        }

        @param groups_infos: A list of objects that describe those groups.
        @return: A [<int>, <int>, ...] list of group nodes, or None (failure).
        """
        return _idaapi.pygc_create_groups(self, groups_infos)

    def DeleteGroups(self, groups, new_current = -1):
        """
        Send a request to delete the specified groups in the graph,
        and perform an animation.

        @param groups: A list of group node numbers.
        @param new_current: A node to focus on after the groups have been deleted
        @return: True on success, False otherwise.
        """
        return _idaapi.pygc_delete_groups(self, groups, new_current)

    def SetGroupsVisibility(self, groups, expand, new_current = -1):
        """
        Send a request to expand/collapse the specified groups in the graph,
        and perform an animation.

        @param groups: A list of group node numbers.
        @param expand: True to expand the group, False otherwise.
        @param new_current: A node to focus on after the groups have been expanded/collapsed.
        @return: True on success, False otherwise.
        """
        return _idaapi.pygc_set_groups_visibility(self, groups, expand, new_current)

    def GetTForm(self):
        """
        Return the TForm hosting this view.

        @return: The TForm that hosts this view, or None.
        """
        return _idaapi.pycim_get_tform(self)

    def GetTCustomControl(self):
        """
        Return the TCustomControl underlying this view.

        @return: The TCustomControl underlying this view, or None.
        """
        return _idaapi.pycim_get_tcustom_control(self)


#</pycode(py_view_base)>


def pyidag_bind(*args):
  """
  pyidag_bind(self) -> bool
  """
  return _idaapi.pyidag_bind(*args)

def pyidag_unbind(*args):
  """
  pyidag_unbind(self) -> bool
  """
  return _idaapi.pyidag_unbind(*args)
#<pycode(py_idaview)>
class IDAViewWrapper(CustomIDAMemo):
    """
    This class wraps access to native IDA views. See kernwin.hpp file
    """
    def __init__(self, title):
        """
        Constructs the IDAViewWrapper object around the view
        whose title is 'title'.

        @param title: The title of the existing IDA view. E.g., 'IDA View-A'
        """
        self._title = title

    def Bind(self):
        return _idaapi.pyidag_bind(self)

    def Unbind(self):
        return _idaapi.pyidag_unbind(self)

#</pycode(py_idaview)>

NIF_BG_COLOR = _idaapi.NIF_BG_COLOR
NIF_FRAME_COLOR = _idaapi.NIF_FRAME_COLOR
NIF_EA = _idaapi.NIF_EA
NIF_TEXT = _idaapi.NIF_TEXT
NIF_ALL = _idaapi.NIF_ALL
class node_info_t(object):
    """
    Proxy of C++ node_info_t class
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(self) -> node_info_t
        """
        this = _idaapi.new_node_info_t(*args)
        try: self.this.append(this)
        except: self.this = this
    bg_color = _swig_property(_idaapi.node_info_t_bg_color_get, _idaapi.node_info_t_bg_color_set)
    frame_color = _swig_property(_idaapi.node_info_t_frame_color_get, _idaapi.node_info_t_frame_color_set)
    ea = _swig_property(_idaapi.node_info_t_ea_get, _idaapi.node_info_t_ea_set)
    text = _swig_property(_idaapi.node_info_t_text_get, _idaapi.node_info_t_text_set)
    def valid_bg_color(self, *args):
        """
        valid_bg_color(self) -> bool
        """
        return _idaapi.node_info_t_valid_bg_color(self, *args)

    def valid_frame_color(self, *args):
        """
        valid_frame_color(self) -> bool
        """
        return _idaapi.node_info_t_valid_frame_color(self, *args)

    def valid_ea(self, *args):
        """
        valid_ea(self) -> bool
        """
        return _idaapi.node_info_t_valid_ea(self, *args)

    def valid_text(self, *args):
        """
        valid_text(self) -> bool
        """
        return _idaapi.node_info_t_valid_text(self, *args)

    def get_flags_for_valid(self, *args):
        """
        get_flags_for_valid(self) -> uint32
        """
        return _idaapi.node_info_t_get_flags_for_valid(self, *args)

    __swig_destroy__ = _idaapi.delete_node_info_t
    __del__ = lambda self : None;
node_info_t_swigregister = _idaapi.node_info_t_swigregister
node_info_t_swigregister(node_info_t)


def get_node_info2(*args):
  """
  get_node_info2(out, gid, node) -> bool
  """
  return _idaapi.get_node_info2(*args)

def set_node_info2(*args):
  """
  set_node_info2(gid, node, ni, flags)
  """
  return _idaapi.set_node_info2(*args)

def del_node_info2(*args):
  """
  del_node_info2(gid, node)
  """
  return _idaapi.del_node_info2(*args)

def clr_node_info2(*args):
  """
  clr_node_info2(gid, node, flags)
  """
  return _idaapi.clr_node_info2(*args)

def set_node_info(*args):
  """
  set_node_info(ea, node, pcolor, pea2, text)
  """
  return _idaapi.set_node_info(*args)

def get_node_info(*args):
  """
  get_node_info(ea, node, pcolor, pea) -> char *
  """
  return _idaapi.get_node_info(*args)

def pyg_close(*args):
  """
  pyg_close(self)
  """
  return _idaapi.pyg_close(*args)

def pyg_add_command(*args):
  """
  pyg_add_command(self, title, hotkey) -> PyObject *
  """
  return _idaapi.pyg_add_command(*args)

def pyg_select_node(*args):
  """
  pyg_select_node(self, nid)
  """
  return _idaapi.pyg_select_node(*args)

def pyg_show(*args):
  """
  pyg_show(self) -> bool
  """
  return _idaapi.pyg_show(*args)
#<pycode(py_graph)>
class GraphViewer(CustomIDAMemo):
    """
    This class wraps the user graphing facility provided by the graph.hpp file
    """
    def __init__(self, title, close_open = False):
        """
        Constructs the GraphView object.
        Please do not remove or rename the private fields

        @param title: The title of the graph window
        @param close_open: Should it attempt to close an existing graph (with same title) before creating this graph?
        """
        self._title = title
        self._nodes = []
        self._edges = []
        self._close_open = close_open

    def AddNode(self, obj):
        """
        Creates a node associated with the given object and returns the node id
        """
        id = len(self._nodes)
        self._nodes.append(obj)
        return id

    def AddEdge(self, src_node, dest_node):
        """
        Creates an edge between two given node ids
        """
        self._edges.append( (src_node, dest_node) )

    def Clear(self):
        """
        Clears all the nodes and edges
        """
        self._nodes = []
        self._edges = []


    def __iter__(self):
        return (self._nodes[index] for index in xrange(0, len(self._nodes)))


    def __getitem__(self, idx):
        """
        Returns a reference to the object associated with this node id
        """
        if idx >= len(self._nodes):
            raise KeyError
        else:
            return self._nodes[idx]

    def Count(self):
        """
        Returns the node count
        """
        return len(self._nodes)

    def Close(self):
        """
        Closes the graph.
        It is possible to call Show() again (which will recreate the graph)
        """
        _idaapi.pyg_close(self)

    def Show(self):
        """
        Shows an existing graph or creates a new one

        @return: Boolean
        """
        if self._close_open:
            frm = _idaapi.find_tform(self._title)
            if frm:
                _idaapi.close_tform(frm, 0)
        return _idaapi.pyg_show(self)

    def Select(self, node_id):
        """
        Selects a node on the graph
        """
        _idaapi.pyg_select_node(self, node_id)

    def AddCommand(self, title, hotkey):
        """
        Deprecated: Use
          - register_action()
          - attach_action_to_popup()
        """
        return _idaapi.pyg_add_command(self, title, hotkey)

    def OnRefresh(self):
        """
        Event called when the graph is refreshed or first created.
        From this event you are supposed to create nodes and edges.
        This callback is mandatory.

        @note: ***It is important to clear previous nodes before adding nodes.***
        @return: Returning True tells the graph viewer to use the items. Otherwise old items will be used.
        """
        self.Clear()

        return True
#<pydoc>
#    def OnGetText(self, node_id):
#        """
#        Triggered when the graph viewer wants the text and color for a given node.
#        This callback is triggered one time for a given node (the value will be cached and used later without calling Python).
#        When you call refresh then again this callback will be called for each node.
#
#        This callback is mandatory.
#
#        @return: Return a string to describe the node text or return a tuple (node_text, node_color) to describe both text and color
#        """
#        return str(self[node_id])
#
#    def OnActivate(self):
#        """
#        Triggered when the graph window gets the focus
#        @return: None
#        """
#        print "Activated...."
#
#    def OnDeactivate(self):
#        """Triggered when the graph window loses the focus
#        @return: None
#        """
#        print "Deactivated...."
#
#    def OnSelect(self, node_id):
#        """
#        Triggered when a node is being selected
#        @return: Return True to allow the node to be selected or False to disallow node selection change
#        """
#        # allow selection change
#        return True
#
#    def OnHint(self, node_id):
#        """
#        Triggered when the graph viewer wants to retrieve hint text associated with a given node
#
#        @return: None if no hint is avail or a string designating the hint
#        """
#        return "hint for " + str(node_id)
#
#    def OnClose(self):
#        """Triggered when the graph viewer window is being closed
#        @return: None
#        """
#        print "Closing......."
#
#    def OnClick(self, node_id):
#        """
#        Triggered when a node is clicked
#        @return: False to ignore the click and True otherwise
#        """
#        print "clicked on", self[node_id]
#        return True
#
#    def OnDblClick(self, node_id):
#        """
#        Triggerd when a node is double-clicked.
#        @return: False to ignore the click and True otherwise
#        """
#        print "dblclicked on", self[node_id]
#        return True
#
#    def OnCommand(self, cmd_id):
#        """
#        Deprecated
#        """
#        pass
#</pydoc>
#</pycode(py_graph)>

class qfile_t(object):
    """
    Proxy of C++ qfile_t class


    A helper class to work with FILE related functions.
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __idc_cvt_id__ = _swig_property(_idaapi.qfile_t___idc_cvt_id___get, _idaapi.qfile_t___idc_cvt_id___set)
    def __init__(self, *args):
        """
        __init__(self, rhs) -> qfile_t
        __init__(self, pycobject=None) -> qfile_t


        Closes the file
        """
        this = _idaapi.new_qfile_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def opened(self, *args):
        """
        opened(self) -> bool


        Checks if the file is opened or not
        """
        return _idaapi.qfile_t_opened(self, *args)

    def close(self, *args):
        """
        close(self)
        """
        return _idaapi.qfile_t_close(self, *args)

    __swig_destroy__ = _idaapi.delete_qfile_t
    __del__ = lambda self : None;
    def open(self, *args):
        """
        open(self, filename, mode) -> bool


        Opens a file
        @param filename: the file name
        @param mode: The mode string, ala fopen() style
        @return: Boolean
        """
        return _idaapi.qfile_t_open(self, *args)

    def from_fp(*args):
        """
        from_fp(fp) -> qfile_t
        """
        return _idaapi.qfile_t_from_fp(*args)

    from_fp = staticmethod(from_fp)
    def from_cobject(*args):
        """
        from_cobject(pycobject) -> qfile_t
        """
        return _idaapi.qfile_t_from_cobject(*args)

    from_cobject = staticmethod(from_cobject)
    def tmpfile(*args):
        """
        tmpfile() -> qfile_t


        A static method to construct an instance using a temporary file
        """
        return _idaapi.qfile_t_tmpfile(*args)

    tmpfile = staticmethod(tmpfile)
    def get_fp(self, *args):
        """
        get_fp(self) -> FILE *
        """
        return _idaapi.qfile_t_get_fp(self, *args)

    def seek(self, *args):
        """
        seek(self, offset, whence=SEEK_SET) -> int


        Set input source position
        @return: the new position (not 0 as fseek!)
        """
        return _idaapi.qfile_t_seek(self, *args)

    def tell(self, *args):
        """
        tell(self) -> int32


        Returns the current position
        """
        return _idaapi.qfile_t_tell(self, *args)

    def readbytes(self, *args):
        """
        readbytes(self, size, big_endian) -> PyObject *


        Similar to read() but it respect the endianness
        """
        return _idaapi.qfile_t_readbytes(self, *args)

    def read(self, *args):
        """
        read(self, size) -> PyObject *


        Reads from the file. Returns the buffer or None
        """
        return _idaapi.qfile_t_read(self, *args)

    def gets(self, *args):
        """
        gets(self, size) -> PyObject *


        Reads a line from the input file. Returns the read line or None
        """
        return _idaapi.qfile_t_gets(self, *args)

    def writebytes(self, *args):
        """
        writebytes(self, py_buf, big_endian) -> int


        Similar to write() but it respect the endianness
        """
        return _idaapi.qfile_t_writebytes(self, *args)

    def write(self, *args):
        """
        write(self, py_buf) -> int


        Writes to the file. Returns 0 or the number of bytes written
        """
        return _idaapi.qfile_t_write(self, *args)

    def puts(self, *args):
        """
        puts(self, str) -> int
        """
        return _idaapi.qfile_t_puts(self, *args)

    def size(self, *args):
        """
        size(self) -> int32
        """
        return _idaapi.qfile_t_size(self, *args)

    def flush(self, *args):
        """
        flush(self) -> int


        Reads a single character from the file. Returns None if EOF or the read character
        """
        return _idaapi.qfile_t_flush(self, *args)

    def filename(self, *args):
        """
        filename(self) -> PyObject *
        """
        return _idaapi.qfile_t_filename(self, *args)

    def get_char(self, *args):
        """
        get_char(self) -> PyObject *
        """
        return _idaapi.qfile_t_get_char(self, *args)

    def put_char(self, *args):
        """
        put_char(self, chr) -> int


        Writes a single character to the file
        """
        return _idaapi.qfile_t_put_char(self, *args)

qfile_t_swigregister = _idaapi.qfile_t_swigregister
qfile_t_swigregister(qfile_t)

def qfile_t_from_fp(*args):
  """
  qfile_t_from_fp(fp) -> qfile_t
  """
  return _idaapi.qfile_t_from_fp(*args)

def qfile_t_from_cobject(*args):
  """
  qfile_t_from_cobject(pycobject) -> qfile_t
  """
  return _idaapi.qfile_t_from_cobject(*args)

def qfile_t_tmpfile(*args):
  """
  qfile_t_tmpfile() -> qfile_t
  """
  return _idaapi.qfile_t_tmpfile(*args)


def reg_read_string(*args):
  """
  reg_read_string(name, subkey=None, _def=None) -> PyObject *
  """
  return _idaapi.reg_read_string(*args)

def reg_data_type(*args):
  """
  reg_data_type(name, subkey=None) -> regval_type_t
  """
  return _idaapi.reg_data_type(*args)

def reg_read_binary(*args):
  """
  reg_read_binary(name, subkey=None) -> PyObject *
  """
  return _idaapi.reg_read_binary(*args)

def reg_write_binary(*args):
  """
  reg_write_binary(name, py_bytes, subkey=None)
  """
  return _idaapi.reg_write_binary(*args)

def reg_subkey_subkeys(*args):
  """
  reg_subkey_subkeys(name) -> PyObject *
  """
  return _idaapi.reg_subkey_subkeys(*args)

def reg_subkey_values(*args):
  """
  reg_subkey_values(name) -> PyObject *
  """
  return _idaapi.reg_subkey_values(*args)
ROOT_KEY_NAME = _idaapi.ROOT_KEY_NAME
reg_unknown = _idaapi.reg_unknown
reg_sz = _idaapi.reg_sz
reg_binary = _idaapi.reg_binary
reg_dword = _idaapi.reg_dword

def reg_delete_subkey(*args):
  """
  reg_delete_subkey(name) -> bool
  """
  return _idaapi.reg_delete_subkey(*args)

def reg_delete(*args):
  """
  reg_delete(name, subkey=None) -> bool
  """
  return _idaapi.reg_delete(*args)

def reg_subkey_exists(*args):
  """
  reg_subkey_exists(name) -> bool
  """
  return _idaapi.reg_subkey_exists(*args)

def reg_exists(*args):
  """
  reg_exists(name, subkey=None) -> bool
  """
  return _idaapi.reg_exists(*args)

def reg_read_strlist(*args):
  """
  reg_read_strlist(subkey, list)
  """
  return _idaapi.reg_read_strlist(*args)

def reg_update_strlist(*args):
  """
  reg_update_strlist(subkey, add, maxrecs, rem=None, ignorecase=False)
  """
  return _idaapi.reg_update_strlist(*args)

def reg_write_string(*args):
  """
  reg_write_string(name, utf8, subkey=None)
  """
  return _idaapi.reg_write_string(*args)

def reg_read_int(*args):
  """
  reg_read_int(name, defval, subkey=None) -> int
  """
  return _idaapi.reg_read_int(*args)

def reg_write_int(*args):
  """
  reg_write_int(name, value, subkey=None)
  """
  return _idaapi.reg_write_int(*args)

def reg_read_bool(*args):
  """
  reg_read_bool(name, defval, subkey=None) -> bool
  """
  return _idaapi.reg_read_bool(*args)

def reg_write_bool(*args):
  """
  reg_write_bool(name, value, subkey=None)
  """
  return _idaapi.reg_write_bool(*args)

def reg_update_filestrlist(*args):
  """
  reg_update_filestrlist(subkey, add, maxrecs, rem=None)
  """
  return _idaapi.reg_update_filestrlist(*args)

def reg_load(*args):
  """
  reg_load()
  """
  return _idaapi.reg_load(*args)

def reg_flush(*args):
  """
  reg_flush()
  """
  return _idaapi.reg_flush(*args)


