Module index

# Module `ida_pro`

This is the first header included in the IDA project.

It defines the most common types, functions and data. Also, it tries to make system dependent definitions.

The following preprocessor macros are used in the project (the list may be incomplete)

Platform must be specified as one of:

NT - MS Windows (all platforms) LINUX - Linux MAC - MAC OS X

EA64 - 64-bit address size (sizeof(ea_t)==8) X86 - 32-bit debug servers (sizeof(void)==4) X64 - x64 processor (sizeof(void)==8) default PPC - PowerPC ARM - ARM

## Global variables

`var CP_UTF16`

  UTF-16 codepage.

`var IDA_SDK_VERSION`

  IDA SDK v9.0.

`var IDBDEC_ESCAPE`

  convert non-printable characters to C escapes ( , \xNN, \uNNNN)

`var IOREDIR_APPEND`

  append, do not overwrite the output file

`var IOREDIR_INPUT`

  input redirection

`var IOREDIR_OUTPUT`

  output redirection

`var IOREDIR_QUOTED`

  the file name was quoted

`var MAXSTR`

  maximum string size

`var SUBSTCHAR`

  default char, used if a char cannot be represented in a codepage

## Functions

`def check_process_exit(handle: void *, exit_code: int *, msecs: int = -1)`

  check_process_exit(handle, exit_code, msecs=-1) -> int Check whether process has terminated or not.

  @param handle: (C++: void ) process handle to wait for @param exit_code: (C++: int ) pointer to the buffer for the exit code @param msecs: how long to wait. special values: * 0: do not wait * 1 or -1: wait infinitely * other values: timeout in milliseconds @retval 0: process has exited, and the exit code is available. if exit_code < 0: the process was killed with a signal -exit_code @retval 1: process has not exited yet @retval -1: error happened, see error code for winerr() in *exit_code

`def extend_sign(v: uint64, nbytes: int, sign_extend: bool)`

  extend_sign(v, nbytes, sign_extend) -> uint64 Sign-, or zero-extend the value 'v' to occupy 64 bits. The value 'v' is considered to be of size 'nbytes'.

  @param v: (C++: uint64) @param nbytes: (C++: int) @param sign_extend: (C++: bool)

`def get_login_name()`

  get_login_name() -> str Get the user name for the current desktop session

  @return: success

`def is_control_tty(fd: int)`

  is_control_tty(fd) -> enum tty_control_t Check if the current process is the owner of the TTY specified by 'fd' (typically an opened descriptor to /dev/tty).

  @param fd: (C++: int)

`def is_cvt64() ‑> bool`

  is_cvt64() -> bool is IDA converting IDB into I64?

`def is_main_thread() ‑> bool`

  is_main_thread() -> bool Are we running in the main thread?

`def log2ceil(d64: uint64)`

  log2ceil(d64) -> int calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0

  @param d64: (C++: uint64)

`def log2floor(d64: uint64)`

  log2floor(d64) -> int

  @param d64: uint64

`def parse_dbgopts(ido: instant_dbgopts_t, r_switch: char const *)`

  parse_dbgopts(ido, r_switch) -> bool Parse the -r command line switch (for instant debugging). r_switch points to the value of the -r switch. Example: win32@localhost+

  @param ido: (C++: struct instant_dbgopts_t ) instant_dbgopts_t * @param r_switch: (C++: const char ) char const * @return: true-ok, false-parse error

`def qatoll(nptr: char const *)`

  qatoll(nptr) -> int64

  @param nptr: char const *

`def qcontrol_tty()`

  qcontrol_tty() Make the current terminal the controlling terminal of the calling process. @note: The current terminal is supposed to be /dev/tty

`def qdetach_tty()`

  qdetach_tty() If the current terminal is the controlling terminal of the calling process, give up this controlling terminal. @note: The current terminal is supposed to be /dev/tty

`def qexit(code: int)`

  qexit(code) Call qatexit functions, shut down UI and kernel, and exit.

  @param code: (C++: int) exit code

`def qstrvec_t_add(_self: PyObject *, s: char const *)`

  qstrvec_t_add(_self, s) -> bool

  @param self: PyObject * @param s: char const *

`def qstrvec_t_addressof(_self: PyObject *, idx: size_t)`

  qstrvec_t_addressof(_self, idx) -> PyObject *

  @param self: PyObject * @param idx: size_t

`def qstrvec_t_assign(_self: PyObject *, other: PyObject *)`

  qstrvec_t_assign(_self, other) -> bool

  @param self: PyObject * @param other: PyObject *

`def qstrvec_t_clear(_self: PyObject *, qclear: bool)`

  qstrvec_t_clear(_self, qclear) -> bool

  @param self: PyObject * @param qclear: bool

`def qstrvec_t_create()`

  qstrvec_t_create() -> PyObject *

`def qstrvec_t_destroy(py_obj: PyObject *)`

  qstrvec_t_destroy(py_obj) -> bool

  @param py_obj: PyObject *

`def qstrvec_t_from_list(_self: PyObject *, py_list: PyObject *)`

  qstrvec_t_from_list(_self, py_list) -> bool

  @param self: PyObject * @param py_list: PyObject *

`def qstrvec_t_get(_self: PyObject *, idx: size_t)`

  qstrvec_t_get(_self, idx) -> PyObject *

  @param self: PyObject * @param idx: size_t

`def qstrvec_t_get_clink(_self: PyObject *)`

  qstrvec_t_get_clink(_self) -> qstrvec_t *

  @param self: PyObject *

`def qstrvec_t_get_clink_ptr(_self: PyObject *)`

  qstrvec_t_get_clink_ptr(_self) -> PyObject *

  @param self: PyObject *

`def qstrvec_t_insert(_self: PyObject *, idx: size_t, s: char const *)`

  qstrvec_t_insert(_self, idx, s) -> bool

  @param self: PyObject * @param idx: size_t @param s: char const *

`def qstrvec_t_remove(_self: PyObject *, idx: size_t)`

  qstrvec_t_remove(_self, idx) -> bool

  @param self: PyObject * @param idx: size_t

`def qstrvec_t_set(_self: PyObject *, idx: size_t, s: char const *)`

  qstrvec_t_set(_self, idx, s) -> bool

  @param self: PyObject * @param idx: size_t @param s: char const *

`def qstrvec_t_size(_self: PyObject *)`

  qstrvec_t_size(_self) -> size_t

  @param self: PyObject *

`def qthread_equal(q1: __qthread_t, q2: __qthread_t) ‑> bool`

  qthread_equal(q1, q2) -> bool Are two threads equal?

  @param q1: (C++: qthread_t) @param q2: (C++: qthread_t)

`def quote_cmdline_arg(arg: qstring *)`

  quote_cmdline_arg(arg) -> bool Quote a command line argument if it contains escape characters. For example, .c will be converted into ".c" because * may be inadvertently expanded by the shell

  @param arg: (C++: qstring *) @return: true: modified 'arg'

`def qvector_reserve(vec: void *, old: void *, cnt: size_t, elsize: size_t)`

  qvector_reserve(vec, old, cnt, elsize) -> void * Change capacity of given qvector.

  @param vec: (C++: void ) a pointer to a qvector @param old: (C++: void ) a pointer to the qvector's array @param cnt: (C++: size_t) number of elements to reserve @param elsize: (C++: size_t) size of each element @return: a pointer to the newly allocated array

`def readbytes(h: int, res: uint32 *, size: int, mf: bool)`

  readbytes(h, res, size, mf) -> int Read at most 4 bytes from file.

  @param h: (C++: int) file handle @param res: (C++: uint32 *) value read from file @param size: (C++: int) size of value in bytes (1,2,4) @param mf: (C++: bool) is MSB first? @return: 0 on success, nonzero otherwise

`def reloc_value(value: void *, size: int, delta: adiff_t, mf: bool)`

  reloc_value(value, size, delta, mf)

  @param value: void * @param size: int @param delta: adiff_t @param mf: bool

`def relocate_relobj(_relobj: relobj_t *, ea: ea_t, mf: bool)`

  relocate_relobj(_relobj, ea, mf) -> bool

  @param _relobj: relobj_t * @param ea: ea_t @param mf: bool

`def str2user(str: char const *)`

  str2user(str) -> str or None Insert C-style escape characters to string

  @param str: char const * @return: new string with escape characters inserted

`def writebytes(h: int, l: uint32, size: int, mf: bool)`

  writebytes(h, l, size, mf) -> int Write at most 4 bytes to file.

  @param h: (C++: int) file handle @param l: (C++: uint32) value to write @param size: (C++: int) size of value in bytes (1,2,4) @param mf: (C++: bool) is MSB first? @return: 0 on success, nonzero otherwise

## Classes

`class adiff_pointer`

  Proxy of C++ adiff_pointer class.

  init(self) -> adiff_pointer

  ### Static methods

  `def frompointer(t: adiff_t *)`

    frompointer(t) -> adiff_pointer

    @param t: adiff_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: adiff_t)`

    assign(self, value)

    @param value: adiff_t

  `def cast(self)`

    cast(self) -> adiff_t *

  `def value(self)`

    value(self) -> adiff_t

`class asize_pointer`

  Proxy of C++ asize_pointer class.

  init(self) -> asize_pointer

  ### Static methods

  `def frompointer(t: asize_t *)`

    frompointer(t) -> asize_pointer

    @param t: asize_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: asize_t)`

    assign(self, value)

    @param value: asize_t

  `def cast(self)`

    cast(self) -> asize_t *

  `def value(self)`

    value(self) -> asize_t

`class bool_pointer`

  Proxy of C++ bool_pointer class.

  init(self) -> bool_pointer

  ### Static methods

  `def frompointer(t: bool *)`

    frompointer(t) -> bool_pointer

    @param t: bool *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: bool)`

    assign(self, value)

    @param value: bool

  `def cast(self)`

    cast(self) -> bool *

  `def value(self) ‑> bool`

    value(self) -> bool

`class boolvec_t (*args)`

  Proxy of C++ qvector< bool > class.

  init(self) -> boolvec_t init(self, x) -> boolvec_t

  @param x: qvector< bool > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: bool const &)`

    add_unique(self, x) -> bool

    @param x: bool const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: bool const &

    push_back(self) -> bool &

  `def at(self, i: size_t)`

    getitem(self, i) -> bool const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< bool >::iterator begin(self) -> qvector< bool >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< bool >::iterator end(self) -> qvector< bool >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< bool >::iterator

    @param it: qvector< bool >::iterator

    erase(self, first, last) -> qvector< bool >::iterator

    @param first: qvector< bool >::iterator @param last: qvector< bool >::iterator

  `def extract(self)`

    extract(self) -> bool *

  `def find(self, *args)`

    find(self, x) -> qvector< bool >::iterator

    @param x: bool const &

    find(self, x) -> qvector< bool >::const_iterator

    @param x: bool const &

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=bool())

    @param x: bool const &

  `def has(self, x: bool const &)`

    has(self, x) -> bool

    @param x: bool const &

  `def inject(self, s: bool *, len: size_t)`

    inject(self, s, len)

    @param s: bool * @param len: size_t

  `def insert(self, it: qvector< bool >::iterator, x: bool const &)`

    insert(self, it, x) -> qvector< bool >::iterator

    @param it: qvector< bool >::iterator @param x: bool const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: bool const &

    push_back(self) -> bool &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: bool const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: boolvec_t)`

    swap(self, r)

    @param r: qvector< bool > &

  `def truncate(self)`

    truncate(self)

`class channel_redir_t`

  Proxy of C++ channel_redir_t class.

  init(self) -> channel_redir_t

  ### Instance variables

  `var fd : int`

    channel number

  `var file : qstring`

    file name to redirect to/from. if empty, the channel must be closed.

  `var flags : int`

    i/o redirection flags

  `var length : int`

    length of the redirection string in the command line

  `var start : int`

    begin of the redirection string in the command line

  `var thisown`

    The membership flag

  ### Methods

  `def is_append(self) ‑> bool`

    is_append(self) -> bool

  `def is_input(self) ‑> bool`

    is_input(self) -> bool

  `def is_output(self) ‑> bool`

    is_output(self) -> bool

  `def is_quoted(self) ‑> bool`

    is_quoted(self) -> bool

`class char_pointer`

  Proxy of C++ char_pointer class.

  init(self) -> char_pointer

  ### Static methods

  `def frompointer(t: char *)`

    frompointer(t) -> char_pointer

    @param t: char *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: char)`

    assign(self, value)

    @param value: char

  `def cast(self)`

    cast(self) -> char *

  `def value(self)`

    value(self) -> char

`class ea32_pointer`

  Proxy of C++ ea32_pointer class.

  init(self) -> ea32_pointer

  ### Static methods

  `def frompointer(t: ea32_t *)`

    frompointer(t) -> ea32_pointer

    @param t: ea32_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: ea32_t)`

    assign(self, value)

    @param value: ea32_t

  `def cast(self)`

    cast(self) -> ea32_t *

  `def value(self)`

    value(self) -> ea32_t

`class ea64_pointer`

  Proxy of C++ ea64_pointer class.

  init(self) -> ea64_pointer

  ### Static methods

  `def frompointer(t: ea64_t *)`

    frompointer(t) -> ea64_pointer

    @param t: ea64_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: ea64_t)`

    assign(self, value)

    @param value: ea64_t

  `def cast(self)`

    cast(self) -> ea64_t *

  `def value(self)`

    value(self) -> ea64_t

`class ea_array (nelements: size_t)`

  Proxy of C++ ea_array class.

  init(self, nelements) -> ea_array

  @param nelements: size_t

  ### Static methods

  `def frompointer(t: ea_t *)`

    frompointer(t) -> ea_array

    @param t: ea_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def cast(self)`

    cast(self) -> ea_t *

`class ea_pointer`

  Proxy of C++ ea_pointer class.

  init(self) -> ea_pointer

  ### Static methods

  `def frompointer(t: ea_t *)`

    frompointer(t) -> ea_pointer

    @param t: ea_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: ea_t)`

    assign(self, value)

    @param value: ea_t

  `def cast(self)`

    cast(self) -> ea_t *

  `def value(self)`

    value(self) -> ea_t

`class flags64_pointer`

  Proxy of C++ flags64_pointer class.

  init(self) -> flags64_pointer

  ### Static methods

  `def frompointer(t: flags64_t *)`

    frompointer(t) -> flags64_pointer

    @param t: flags64_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: flags64_t)`

    assign(self, value)

    @param value: flags64_t

  `def cast(self)`

    cast(self) -> flags64_t *

  `def value(self)`

    value(self) -> flags64_t

`class flags_pointer`

  Proxy of C++ flags_pointer class.

  init(self) -> flags_pointer

  ### Static methods

  `def frompointer(t: flags_t *)`

    frompointer(t) -> flags_pointer

    @param t: flags_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: flags_t)`

    assign(self, value)

    @param value: flags_t

  `def cast(self)`

    cast(self) -> flags_t *

  `def value(self)`

    value(self) -> flags_t

`class instant_dbgopts_t`

  Proxy of C++ instant_dbgopts_t class.

  init(self) -> instant_dbgopts_t

  ### Instance variables

  `var attach : bool`

    should attach to a process?

  `var debmod : qstring`

    name of debugger module

  `var env : qstring`

    config variables for debmod. example: DEFAULT_CPU=13;MAXPACKETSIZE=-1

  `var event_id : int`

    event to trigger upon attaching

  `var host : qstring`

    remote hostname (if remote debugging)

  `var pid : int`

    process to attach to (-1: ask the user)

  `var port : int`

    port number for the remote debugger server

  `var thisown`

    The membership flag

`class int16_pointer`

  Proxy of C++ int16_pointer class.

  init(self) -> int16_pointer

  ### Static methods

  `def frompointer(t: int16 *)`

    frompointer(t) -> int16_pointer

    @param t: int16 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: int16)`

    assign(self, value)

    @param value: int16

  `def cast(self)`

    cast(self) -> int16 *

  `def value(self)`

    value(self) -> int16

`class int32_pointer`

  Proxy of C++ int32_pointer class.

  init(self) -> int32_pointer

  ### Static methods

  `def frompointer(t: int32 *)`

    frompointer(t) -> int32_pointer

    @param t: int32 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: int32)`

    assign(self, value)

    @param value: int32

  `def cast(self)`

    cast(self) -> int32 *

  `def value(self)`

    value(self) -> int32

`class int64_pointer`

  Proxy of C++ int64_pointer class.

  init(self) -> int64_pointer

  ### Static methods

  `def frompointer(t: int64 *)`

    frompointer(t) -> int64_pointer

    @param t: int64 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: int64)`

    assign(self, value)

    @param value: int64

  `def cast(self)`

    cast(self) -> int64 *

  `def value(self)`

    value(self) -> int64

`class int64vec_t (*args)`

  Proxy of C++ qvector< long long > class.

  init(self) -> int64vec_t init(self, x) -> int64vec_t

  @param x: qvector< long long > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: long long const &)`

    add_unique(self, x) -> bool

    @param x: long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< long long >::iterator begin(self) -> qvector< long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< long long >::iterator end(self) -> qvector< long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator

    erase(self, first, last) -> qvector< long long >::iterator

    @param first: qvector< long long >::iterator @param last: qvector< long long >::iterator

  `def extract(self)`

    extract(self) -> long long *

  `def find(self, *args)`

    find(self, x) -> qvector< long long >::iterator

    @param x: long long const &

    find(self, x) -> qvector< long long >::const_iterator

    @param x: long long const &

  `def front(self)`
  `def has(self, x: long long const &)`

    has(self, x) -> bool

    @param x: long long const &

  `def inject(self, s: long long *, len: size_t)`

    inject(self, s, len)

    @param s: long long * @param len: size_t

  `def insert(self, it: qvector< long long >::iterator, x: long long const &)`

    insert(self, it, x) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator @param x: long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: int64vec_t)`

    swap(self, r)

    @param r: qvector< long long > &

  `def truncate(self)`

    truncate(self)

`class longlongvec_t (*args)`

  Proxy of C++ qvector< long long > class.

  init(self) -> int64vec_t init(self, x) -> int64vec_t

  @param x: qvector< long long > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: long long const &)`

    add_unique(self, x) -> bool

    @param x: long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< long long >::iterator begin(self) -> qvector< long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< long long >::iterator end(self) -> qvector< long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator

    erase(self, first, last) -> qvector< long long >::iterator

    @param first: qvector< long long >::iterator @param last: qvector< long long >::iterator

  `def extract(self)`

    extract(self) -> long long *

  `def find(self, *args)`

    find(self, x) -> qvector< long long >::iterator

    @param x: long long const &

    find(self, x) -> qvector< long long >::const_iterator

    @param x: long long const &

  `def front(self)`
  `def has(self, x: long long const &)`

    has(self, x) -> bool

    @param x: long long const &

  `def inject(self, s: long long *, len: size_t)`

    inject(self, s, len)

    @param s: long long * @param len: size_t

  `def insert(self, it: qvector< long long >::iterator, x: long long const &)`

    insert(self, it, x) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator @param x: long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: int64vec_t)`

    swap(self, r)

    @param r: qvector< long long > &

  `def truncate(self)`

    truncate(self)

`class svalvec_t (*args)`

  Proxy of C++ qvector< long long > class.

  init(self) -> int64vec_t init(self, x) -> int64vec_t

  @param x: qvector< long long > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: long long const &)`

    add_unique(self, x) -> bool

    @param x: long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< long long >::iterator begin(self) -> qvector< long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< long long >::iterator end(self) -> qvector< long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator

    erase(self, first, last) -> qvector< long long >::iterator

    @param first: qvector< long long >::iterator @param last: qvector< long long >::iterator

  `def extract(self)`

    extract(self) -> long long *

  `def find(self, *args)`

    find(self, x) -> qvector< long long >::iterator

    @param x: long long const &

    find(self, x) -> qvector< long long >::const_iterator

    @param x: long long const &

  `def front(self)`
  `def has(self, x: long long const &)`

    has(self, x) -> bool

    @param x: long long const &

  `def inject(self, s: long long *, len: size_t)`

    inject(self, s, len)

    @param s: long long * @param len: size_t

  `def insert(self, it: qvector< long long >::iterator, x: long long const &)`

    insert(self, it, x) -> qvector< long long >::iterator

    @param it: qvector< long long >::iterator @param x: long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: long long const &

    push_back(self) -> long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: int64vec_t)`

    swap(self, r)

    @param r: qvector< long long > &

  `def truncate(self)`

    truncate(self)

`class int8_pointer`

  Proxy of C++ int8_pointer class.

  init(self) -> int8_pointer

  ### Static methods

  `def frompointer(t: int8 *)`

    frompointer(t) -> int8_pointer

    @param t: int8 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: int8)`

    assign(self, value)

    @param value: int8

  `def cast(self)`

    cast(self) -> int8 *

  `def value(self)`

    value(self) -> int8

`class int_pointer`

  Proxy of C++ int_pointer class.

  init(self) -> int_pointer

  ### Static methods

  `def frompointer(t: int *)`

    frompointer(t) -> int_pointer

    @param t: int *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: int)`

    assign(self, value)

    @param value: int

  `def cast(self)`

    cast(self) -> int *

  `def value(self) ‑> int`

    value(self) -> int

`class intvec_t (*args)`

  Proxy of C++ qvector< int > class.

  init(self) -> intvec_t init(self, x) -> intvec_t

  @param x: qvector< int > const &

  ### Subclasses

  - chain_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: int const &)`

    add_unique(self, x) -> bool

    @param x: int const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: int const &

    push_back(self) -> int &

  `def at(self, i: size_t)`

    getitem(self, i) -> int const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< int >::iterator begin(self) -> qvector< int >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< int >::iterator end(self) -> qvector< int >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< int >::iterator

    @param it: qvector< int >::iterator

    erase(self, first, last) -> qvector< int >::iterator

    @param first: qvector< int >::iterator @param last: qvector< int >::iterator

  `def extract(self)`

    extract(self) -> int *

  `def find(self, *args)`

    find(self, x) -> qvector< int >::iterator

    @param x: int const &

    find(self, x) -> qvector< int >::const_iterator

    @param x: int const &

  `def front(self)`
  `def has(self, x: int const &)`

    has(self, x) -> bool

    @param x: int const &

  `def inject(self, s: int *, len: size_t)`

    inject(self, s, len)

    @param s: int * @param len: size_t

  `def insert(self, it: qvector< int >::iterator, x: int const &)`

    insert(self, it, x) -> qvector< int >::iterator

    @param it: qvector< int >::iterator @param x: int const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: int const &

    push_back(self) -> int &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: int const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: intvec_t)`

    swap(self, r)

    @param r: qvector< int > &

  `def truncate(self)`

    truncate(self)

`class plugin_options_t`

  Proxy of C++ plugin_options_t class.

  init(self) -> plugin_options_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def erase(self, name: char const *)`

    erase(self, name) -> bool

    @param name: char const *

`class qmutex_locker_t (_lock: __qmutex_t)`

  Proxy of C++ qmutex_locker_t class.

  init(self, _lock) -> qmutex_locker_t

  @param _lock: qmutex_t

  ### Instance variables

  `var thisown`

    The membership flag

`class qrefcnt_obj_t (*args, **kwargs)`

  Proxy of C++ qrefcnt_obj_t class.

  ### Instance variables

  `var refcnt : int`

    counter

  `var thisown`

    The membership flag

  ### Methods

  `def release(self)`

    release(self) Call destructor. We use release() instead of operator delete() to maintain binary compatibility with all compilers (vc and gcc use different vtable layouts for operator delete)

`class sel_array (nelements: size_t)`

  Proxy of C++ sel_array class.

  init(self, nelements) -> sel_array

  @param nelements: size_t

  ### Static methods

  `def frompointer(t: sel_t *)`

    frompointer(t) -> sel_array

    @param t: sel_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def cast(self)`

    cast(self) -> sel_t *

`class sel_pointer`

  Proxy of C++ sel_pointer class.

  init(self) -> sel_pointer

  ### Static methods

  `def frompointer(t: sel_t *)`

    frompointer(t) -> sel_pointer

    @param t: sel_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: sel_t)`

    assign(self, value)

    @param value: sel_t

  `def cast(self)`

    cast(self) -> sel_t *

  `def value(self)`

    value(self) -> sel_t

`class short_pointer`

  Proxy of C++ short_pointer class.

  init(self) -> short_pointer

  ### Static methods

  `def frompointer(t: short *)`

    frompointer(t) -> short_pointer

    @param t: short *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: short)`

    assign(self, value)

    @param value: short

  `def cast(self)`

    cast(self) -> short *

  `def value(self)`

    value(self) -> short

`class sint8_pointer`

  Proxy of C++ sint8_pointer class.

  init(self) -> sint8_pointer

  ### Static methods

  `def frompointer(t: sint8 *)`

    frompointer(t) -> sint8_pointer

    @param t: sint8 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: sint8)`

    assign(self, value)

    @param value: sint8

  `def cast(self)`

    cast(self) -> sint8 *

  `def value(self)`

    value(self) -> sint8

`class sizevec_t (*args)`

  Proxy of C++ qvector< size_t > class.

  init(self) -> sizevec_t init(self, x) -> sizevec_t

  @param x: qvector< size_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: size_t const &)`

    add_unique(self, x) -> bool

    @param x: size_t const &

  `def at(self, _idx: size_t)`

    at(self, _idx) -> size_t const &

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< size_t >::iterator begin(self) -> qvector< size_t >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< size_t >::iterator end(self) -> qvector< size_t >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< size_t >::iterator

    @param it: qvector< size_t >::iterator

    erase(self, first, last) -> qvector< size_t >::iterator

    @param first: qvector< size_t >::iterator @param last: qvector< size_t >::iterator

  `def extract(self)`

    extract(self) -> size_t *

  `def find(self, *args)`

    find(self, x) -> qvector< size_t >::iterator

    @param x: size_t const &

    find(self, x) -> qvector< size_t >::const_iterator

    @param x: size_t const &

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=size_t())

    @param x: size_t const &

  `def has(self, x: size_t const &)`

    has(self, x) -> bool

    @param x: size_t const &

  `def inject(self, s: size_t *, len: size_t)`

    inject(self, s, len)

    @param s: size_t * @param len: size_t

  `def insert(self, it: qvector< size_t >::iterator, x: size_t const &)`

    insert(self, it, x) -> qvector< size_t >::iterator

    @param it: qvector< size_t >::iterator @param x: size_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: size_t const &

    push_back(self) -> size_t &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: size_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: sizevec_t)`

    swap(self, r)

    @param r: qvector< size_t > &

  `def truncate(self)`

    truncate(self)

`class ssize_pointer`

  Proxy of C++ ssize_pointer class.

  init(self) -> ssize_pointer

  ### Static methods

  `def frompointer(t: ssize_t *)`

    frompointer(t) -> ssize_pointer

    @param t: ssize_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: ssize_t)`

    assign(self, value)

    @param value: ssize_t

  `def cast(self)`

    cast(self) -> ssize_t *

  `def value(self)`

    value(self) -> ssize_t

`class strvec_t (*args)`

  Proxy of C++ qvector< simpleline_t > class.

  init(self) -> strvec_t init(self, x) -> strvec_t

  @param x: qvector< simpleline_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def append(self, *args)`

    push_back(self, x)

    @param x: simpleline_t const &

    push_back(self) -> simpleline_t &

  `def at(self, i: size_t)`

    getitem(self, i) -> simpleline_t const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< simpleline_t >::iterator begin(self) -> qvector< simpleline_t >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< simpleline_t >::iterator end(self) -> qvector< simpleline_t >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< simpleline_t >::iterator

    @param it: qvector< simpleline_t >::iterator

    erase(self, first, last) -> qvector< simpleline_t >::iterator

    @param first: qvector< simpleline_t >::iterator @param last: qvector< simpleline_t >::iterator

  `def extract(self)`

    extract(self) -> simpleline_t *

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=simpleline_t())

    @param x: simpleline_t const &

  `def inject(self, s: simpleline_t *, len: size_t)`

    inject(self, s, len)

    @param s: simpleline_t * @param len: size_t

  `def insert(self, it: qvector< simpleline_t >::iterator, x: simpleline_t const &)`

    insert(self, it, x) -> qvector< simpleline_t >::iterator

    @param it: qvector< simpleline_t >::iterator @param x: simpleline_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: simpleline_t const &

    push_back(self) -> simpleline_t &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: simpleline_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: strvec_t)`

    swap(self, r)

    @param r: qvector< simpleline_t > &

  `def truncate(self)`

    truncate(self)

`class sval_pointer`

  Proxy of C++ sval_pointer class.

  init(self) -> sval_pointer

  ### Static methods

  `def frompointer(t: sval_t *)`

    frompointer(t) -> sval_pointer

    @param t: sval_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: sval_t)`

    assign(self, value)

    @param value: sval_t

  `def cast(self)`

    cast(self) -> sval_t *

  `def value(self)`

    value(self) -> sval_t

`class tid_array (nelements: size_t)`

  Proxy of C++ tid_array class.

  init(self, nelements) -> tid_array

  @param nelements: size_t

  ### Static methods

  `def frompointer(t: tid_t *)`

    frompointer(t) -> tid_array

    @param t: tid_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def cast(self)`

    cast(self) -> tid_t *

`class tid_pointer`

  Proxy of C++ tid_pointer class.

  init(self) -> tid_pointer

  ### Static methods

  `def frompointer(t: tid_t *)`

    frompointer(t) -> tid_pointer

    @param t: tid_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: tid_t)`

    assign(self, value)

    @param value: tid_t

  `def cast(self)`

    cast(self) -> tid_t *

  `def value(self)`

    value(self) -> tid_t

`class uchar_array (nelements: size_t)`

  Proxy of C++ uchar_array class.

  init(self, nelements) -> uchar_array

  @param nelements: size_t

  ### Static methods

  `def frompointer(t: uchar *)`

    frompointer(t) -> uchar_array

    @param t: uchar *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def cast(self)`

    cast(self) -> uchar *

`class uchar_pointer`

  Proxy of C++ uchar_pointer class.

  init(self) -> uchar_pointer

  ### Static methods

  `def frompointer(t: uchar *)`

    frompointer(t) -> uchar_pointer

    @param t: uchar *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uchar)`

    assign(self, value)

    @param value: uchar

  `def cast(self)`

    cast(self) -> uchar *

  `def value(self)`

    value(self) -> uchar

`class uint16_pointer`

  Proxy of C++ uint16_pointer class.

  init(self) -> uint16_pointer

  ### Static methods

  `def frompointer(t: uint16 *)`

    frompointer(t) -> uint16_pointer

    @param t: uint16 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uint16)`

    assign(self, value)

    @param value: uint16

  `def cast(self)`

    cast(self) -> uint16 *

  `def value(self)`

    value(self) -> uint16

`class uint32_pointer`

  Proxy of C++ uint32_pointer class.

  init(self) -> uint32_pointer

  ### Static methods

  `def frompointer(t: uint32 *)`

    frompointer(t) -> uint32_pointer

    @param t: uint32 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uint32)`

    assign(self, value)

    @param value: uint32

  `def cast(self)`

    cast(self) -> uint32 *

  `def value(self)`

    value(self) -> uint32

`class uint64_pointer`

  Proxy of C++ uint64_pointer class.

  init(self) -> uint64_pointer

  ### Static methods

  `def frompointer(t: uint64 *)`

    frompointer(t) -> uint64_pointer

    @param t: uint64 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uint64)`

    assign(self, value)

    @param value: uint64

  `def cast(self)`

    cast(self) -> uint64 *

  `def value(self)`

    value(self) -> uint64

`class uint64vec_t (*args)`

  Proxy of C++ qvector< unsigned long long > class.

  init(self) -> uint64vec_t init(self, x) -> uint64vec_t

  @param x: qvector< unsigned long long > const &

  ### Subclasses

  - casm_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: unsigned long long const &)`

    add_unique(self, x) -> bool

    @param x: unsigned long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> unsigned long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< unsigned long long >::iterator begin(self) -> qvector< unsigned long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< unsigned long long >::iterator end(self) -> qvector< unsigned long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator

    erase(self, first, last) -> qvector< unsigned long long >::iterator

    @param first: qvector< unsigned long long >::iterator @param last: qvector< unsigned long long >::iterator

  `def extract(self)`

    extract(self) -> unsigned long long *

  `def find(self, *args)`

    find(self, x) -> qvector< unsigned long long >::iterator

    @param x: unsigned long long const &

    find(self, x) -> qvector< unsigned long long >::const_iterator

    @param x: unsigned long long const &

  `def front(self)`
  `def has(self, x: unsigned long long const &)`

    has(self, x) -> bool

    @param x: unsigned long long const &

  `def inject(self, s: unsigned long long *, len: size_t)`

    inject(self, s, len)

    @param s: unsigned long long * @param len: size_t

  `def insert(self, it: qvector< unsigned long long >::iterator, x: unsigned long long const &)`

    insert(self, it, x) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator @param x: unsigned long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: unsigned long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: uint64vec_t)`

    swap(self, r)

    @param r: qvector< unsigned long long > &

  `def truncate(self)`

    truncate(self)

`class ulonglongvec_t (*args)`

  Proxy of C++ qvector< unsigned long long > class.

  init(self) -> uint64vec_t init(self, x) -> uint64vec_t

  @param x: qvector< unsigned long long > const &

  ### Subclasses

  - casm_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: unsigned long long const &)`

    add_unique(self, x) -> bool

    @param x: unsigned long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> unsigned long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< unsigned long long >::iterator begin(self) -> qvector< unsigned long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< unsigned long long >::iterator end(self) -> qvector< unsigned long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator

    erase(self, first, last) -> qvector< unsigned long long >::iterator

    @param first: qvector< unsigned long long >::iterator @param last: qvector< unsigned long long >::iterator

  `def extract(self)`

    extract(self) -> unsigned long long *

  `def find(self, *args)`

    find(self, x) -> qvector< unsigned long long >::iterator

    @param x: unsigned long long const &

    find(self, x) -> qvector< unsigned long long >::const_iterator

    @param x: unsigned long long const &

  `def front(self)`
  `def has(self, x: unsigned long long const &)`

    has(self, x) -> bool

    @param x: unsigned long long const &

  `def inject(self, s: unsigned long long *, len: size_t)`

    inject(self, s, len)

    @param s: unsigned long long * @param len: size_t

  `def insert(self, it: qvector< unsigned long long >::iterator, x: unsigned long long const &)`

    insert(self, it, x) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator @param x: unsigned long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: unsigned long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: uint64vec_t)`

    swap(self, r)

    @param r: qvector< unsigned long long > &

  `def truncate(self)`

    truncate(self)

`class uvalvec_t (*args)`

  Proxy of C++ qvector< unsigned long long > class.

  init(self) -> uint64vec_t init(self, x) -> uint64vec_t

  @param x: qvector< unsigned long long > const &

  ### Subclasses

  - casm_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: unsigned long long const &)`

    add_unique(self, x) -> bool

    @param x: unsigned long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> unsigned long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< unsigned long long >::iterator begin(self) -> qvector< unsigned long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< unsigned long long >::iterator end(self) -> qvector< unsigned long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator

    erase(self, first, last) -> qvector< unsigned long long >::iterator

    @param first: qvector< unsigned long long >::iterator @param last: qvector< unsigned long long >::iterator

  `def extract(self)`

    extract(self) -> unsigned long long *

  `def find(self, *args)`

    find(self, x) -> qvector< unsigned long long >::iterator

    @param x: unsigned long long const &

    find(self, x) -> qvector< unsigned long long >::const_iterator

    @param x: unsigned long long const &

  `def front(self)`
  `def has(self, x: unsigned long long const &)`

    has(self, x) -> bool

    @param x: unsigned long long const &

  `def inject(self, s: unsigned long long *, len: size_t)`

    inject(self, s, len)

    @param s: unsigned long long * @param len: size_t

  `def insert(self, it: qvector< unsigned long long >::iterator, x: unsigned long long const &)`

    insert(self, it, x) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator @param x: unsigned long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: unsigned long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: uint64vec_t)`

    swap(self, r)

    @param r: qvector< unsigned long long > &

  `def truncate(self)`

    truncate(self)

`class eavec_t (*args)`

  Proxy of C++ qvector< unsigned long long > class.

  init(self) -> uint64vec_t init(self, x) -> uint64vec_t

  @param x: qvector< unsigned long long > const &

  ### Subclasses

  - casm_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: unsigned long long const &)`

    add_unique(self, x) -> bool

    @param x: unsigned long long const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def at(self, i: size_t)`

    getitem(self, i) -> unsigned long long const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< unsigned long long >::iterator begin(self) -> qvector< unsigned long long >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< unsigned long long >::iterator end(self) -> qvector< unsigned long long >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator

    erase(self, first, last) -> qvector< unsigned long long >::iterator

    @param first: qvector< unsigned long long >::iterator @param last: qvector< unsigned long long >::iterator

  `def extract(self)`

    extract(self) -> unsigned long long *

  `def find(self, *args)`

    find(self, x) -> qvector< unsigned long long >::iterator

    @param x: unsigned long long const &

    find(self, x) -> qvector< unsigned long long >::const_iterator

    @param x: unsigned long long const &

  `def front(self)`
  `def has(self, x: unsigned long long const &)`

    has(self, x) -> bool

    @param x: unsigned long long const &

  `def inject(self, s: unsigned long long *, len: size_t)`

    inject(self, s, len)

    @param s: unsigned long long * @param len: size_t

  `def insert(self, it: qvector< unsigned long long >::iterator, x: unsigned long long const &)`

    insert(self, it, x) -> qvector< unsigned long long >::iterator

    @param it: qvector< unsigned long long >::iterator @param x: unsigned long long const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: unsigned long long const &

    push_back(self) -> unsigned long long &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: unsigned long long const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: uint64vec_t)`

    swap(self, r)

    @param r: qvector< unsigned long long > &

  `def truncate(self)`

    truncate(self)

`class uint8_pointer`

  Proxy of C++ uint8_pointer class.

  init(self) -> uint8_pointer

  ### Static methods

  `def frompointer(t: uint8 *)`

    frompointer(t) -> uint8_pointer

    @param t: uint8 *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uint8)`

    assign(self, value)

    @param value: uint8

  `def cast(self)`

    cast(self) -> uint8 *

  `def value(self)`

    value(self) -> uint8

`class uint_pointer`

  Proxy of C++ uint_pointer class.

  init(self) -> uint_pointer

  ### Static methods

  `def frompointer(t: uint *)`

    frompointer(t) -> uint_pointer

    @param t: uint *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uint)`

    assign(self, value)

    @param value: uint

  `def cast(self)`

    cast(self) -> uint *

  `def value(self)`

    value(self) -> uint

`class uintvec_t (*args)`

  Proxy of C++ qvector< unsigned int > class.

  init(self) -> uintvec_t init(self, x) -> uintvec_t

  @param x: qvector< unsigned int > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: unsigned int const &)`

    add_unique(self, x) -> bool

    @param x: unsigned int const &

  `def append(self, *args)`

    push_back(self, x)

    @param x: unsigned int const &

    push_back(self) -> unsigned int &

  `def at(self, i: size_t)`

    getitem(self, i) -> unsigned int const &

    @param i: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> qvector< unsigned int >::iterator begin(self) -> qvector< unsigned int >::const_iterator

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> qvector< unsigned int >::iterator end(self) -> qvector< unsigned int >::const_iterator

  `def erase(self, *args)`

    erase(self, it) -> qvector< unsigned int >::iterator

    @param it: qvector< unsigned int >::iterator

    erase(self, first, last) -> qvector< unsigned int >::iterator

    @param first: qvector< unsigned int >::iterator @param last: qvector< unsigned int >::iterator

  `def extract(self)`

    extract(self) -> unsigned int *

  `def find(self, *args)`

    find(self, x) -> qvector< unsigned int >::iterator

    @param x: unsigned int const &

    find(self, x) -> qvector< unsigned int >::const_iterator

    @param x: unsigned int const &

  `def front(self)`
  `def has(self, x: unsigned int const &)`

    has(self, x) -> bool

    @param x: unsigned int const &

  `def inject(self, s: unsigned int *, len: size_t)`

    inject(self, s, len)

    @param s: unsigned int * @param len: size_t

  `def insert(self, it: qvector< unsigned int >::iterator, x: unsigned int const &)`

    insert(self, it, x) -> qvector< unsigned int >::iterator

    @param it: qvector< unsigned int >::iterator @param x: unsigned int const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: unsigned int const &

    push_back(self) -> unsigned int &

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: unsigned int const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: uintvec_t)`

    swap(self, r)

    @param r: qvector< unsigned int > &

  `def truncate(self)`

    truncate(self)

`class ushort_pointer`

  Proxy of C++ ushort_pointer class.

  init(self) -> ushort_pointer

  ### Static methods

  `def frompointer(t: ushort *)`

    frompointer(t) -> ushort_pointer

    @param t: ushort *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: ushort)`

    assign(self, value)

    @param value: ushort

  `def cast(self)`

    cast(self) -> ushort *

  `def value(self)`

    value(self) -> ushort

`class uval_array (nelements: size_t)`

  Proxy of C++ uval_array class.

  init(self, nelements) -> uval_array

  @param nelements: size_t

  ### Static methods

  `def frompointer(t: uval_t *)`

    frompointer(t) -> uval_array

    @param t: uval_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def cast(self)`

    cast(self) -> uval_t *

`class uval_pointer`

  Proxy of C++ uval_pointer class.

  init(self) -> uval_pointer

  ### Static methods

  `def frompointer(t: uval_t *)`

    frompointer(t) -> uval_pointer

    @param t: uval_t *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def assign(self, value: uval_t)`

    assign(self, value)

    @param value: uval_t

  `def cast(self)`

    cast(self) -> uval_t *

  `def value(self)`

    value(self) -> uval_t