Convert to src-layout ta/nix

1 files changed, 0 insertions, 1715 deletions

diff --git a/miasm/core/cpu.py b/miasm/core/cpu.py
deleted file mode 100644
index 7df9f991..00000000
--- a/miasm/core/cpu.py
+++ /dev/null
@@ -1,1715 +0,0 @@
-#-*- coding:utf-8 -*-
-
-from builtins import range
-import re
-import struct
-import logging
-from collections import defaultdict
-
-
-from future.utils import viewitems, viewvalues
-
-import pyparsing
-
-from miasm.core.utils import decode_hex
-import miasm.expression.expression as m2_expr
-from miasm.core.bin_stream import bin_stream, bin_stream_str
-from miasm.core.utils import Disasm_Exception
-from miasm.expression.simplifications import expr_simp
-
-
-from miasm.core.asm_ast import AstNode, AstInt, AstId, AstOp
-from miasm.core import utils
-from future.utils import with_metaclass
-
-log = logging.getLogger("cpuhelper")
-console_handler = logging.StreamHandler()
-console_handler.setFormatter(logging.Formatter("[%(levelname)-8s]: %(message)s"))
-log.addHandler(console_handler)
-log.setLevel(logging.WARN)
-
-
-class bitobj(object):
-
-    def __init__(self, s=b""):
-        if not s:
-            bits = []
-        else:
-            bits = [int(x) for x in bin(int(encode_hex(s), 16))[2:]]
-            if len(bits) % 8:
-                bits = [0 for x in range(8 - (len(bits) % 8))] + bits
-        self.bits = bits
-        self.offset = 0
-
-    def __len__(self):
-        return len(self.bits) - self.offset
-
-    def getbits(self, n):
-        if not n:
-            return 0
-        if n > len(self.bits) - self.offset:
-            raise ValueError('not enough bits %r %r' % (n, len(self.bits)))
-        b = self.bits[self.offset:self.offset + n]
-        b = int("".join(str(x) for x in b), 2)
-        self.offset += n
-        return b
-
-    def putbits(self, b, n):
-        if not n:
-            return
-        bits = list(bin(b)[2:])
-        bits = [int(x) for x in bits]
-        bits = [0 for x in range(n - len(bits))] + bits
-        self.bits += bits
-
-    def tostring(self):
-        if len(self.bits) % 8:
-            raise ValueError(
-                'num bits must be 8 bit aligned: %d' % len(self.bits)
-            )
-        b = int("".join(str(x) for x in self.bits), 2)
-        b = "%X" % b
-        b = '0' * (len(self.bits) // 4 - len(b)) + b
-        b = decode_hex(b.encode())
-        return b
-
-    def reset(self):
-        self.offset = 0
-
-    def copy_state(self):
-        b = self.__class__()
-        b.bits = self.bits
-        b.offset = self.offset
-        return b
-
-
-def literal_list(l):
-    l = l[:]
-    l.sort()
-    l = l[::-1]
-    o = pyparsing.Literal(l[0])
-    for x in l[1:]:
-        o |= pyparsing.Literal(x)
-    return o
-
-
-class reg_info(object):
-
-    def __init__(self, reg_str, reg_expr):
-        self.str = reg_str
-        self.expr = reg_expr
-        self.parser = literal_list(reg_str).setParseAction(self.cb_parse)
-
-    def cb_parse(self, tokens):
-        assert len(tokens) == 1
-        i = self.str.index(tokens[0])
-        reg = self.expr[i]
-        result = AstId(reg)
-        return result
-
-    def reg2expr(self, s):
-        i = self.str.index(s[0])
-        return self.expr[i]
-
-    def expr2regi(self, e):
-        return self.expr.index(e)
-
-
-class reg_info_dct(object):
-
-    def __init__(self, reg_expr):
-        self.dct_str_inv = dict((v.name, k) for k, v in viewitems(reg_expr))
-        self.dct_expr = reg_expr
-        self.dct_expr_inv = dict((v, k) for k, v in viewitems(reg_expr))
-        reg_str = [v.name for v in viewvalues(reg_expr)]
-        self.parser = literal_list(reg_str).setParseAction(self.cb_parse)
-
-    def cb_parse(self, tokens):
-        assert len(tokens) == 1
-        i = self.dct_str_inv[tokens[0]]
-        reg = self.dct_expr[i]
-        result = AstId(reg)
-        return result
-
-    def reg2expr(self, s):
-        i = self.dct_str_inv[s[0]]
-        return self.dct_expr[i]
-
-    def expr2regi(self, e):
-        return self.dct_expr_inv[e]
-
-
-def gen_reg(reg_name, sz=32):
-    """Gen reg expr and parser"""
-    reg = m2_expr.ExprId(reg_name, sz)
-    reginfo = reg_info([reg_name], [reg])
-    return reg, reginfo
-
-
-def gen_reg_bs(reg_name, reg_info, base_cls):
-    """
-    Generate:
-        class bs_reg_name(base_cls):
-            reg = reg_info
-
-        bs_reg_name = bs(l=0, cls=(bs_reg_name,))
-    """
-
-    bs_name = "bs_%s" % reg_name
-    cls = type(bs_name, base_cls, {'reg': reg_info})
-
-    bs_obj = bs(l=0, cls=(cls,))
-
-    return cls, bs_obj
-
-
-def gen_regs(rnames, env, sz=32):
-    regs_str = []
-    regs_expr = []
-    regs_init = []
-    for rname in rnames:
-        r = m2_expr.ExprId(rname, sz)
-        r_init = m2_expr.ExprId(rname+'_init', sz)
-        regs_str.append(rname)
-        regs_expr.append(r)
-        regs_init.append(r_init)
-        env[rname] = r
-
-    reginfo = reg_info(regs_str, regs_expr)
-    return regs_expr, regs_init, reginfo
-
-
-LPARENTHESIS = pyparsing.Literal("(")
-RPARENTHESIS = pyparsing.Literal(")")
-
-
-def int2expr(tokens):
-    v = tokens[0]
-    return (m2_expr.ExprInt, v)
-
-
-def parse_op(tokens):
-    v = tokens[0]
-    return (m2_expr.ExprOp, v)
-
-
-def parse_id(tokens):
-    v = tokens[0]
-    return (m2_expr.ExprId, v)
-
-
-def ast_parse_op(tokens):
-    if len(tokens) == 1:
-        return tokens[0]
-    if len(tokens) == 2:
-        if tokens[0] in ['-', '+', '!']:
-            return m2_expr.ExprOp(tokens[0], tokens[1])
-    if len(tokens) == 3:
-        if tokens[1] == '-':
-            # a - b => a + (-b)
-            tokens[1] = '+'
-            tokens[2] = - tokens[2]
-        return m2_expr.ExprOp(tokens[1], tokens[0], tokens[2])
-    tokens = tokens[::-1]
-    while len(tokens) >= 3:
-        o1, op, o2 = tokens.pop(), tokens.pop(), tokens.pop()
-        if op == '-':
-            # a - b => a + (-b)
-            op = '+'
-            o2 = - o2
-        e = m2_expr.ExprOp(op, o1, o2)
-        tokens.append(e)
-    if len(tokens) != 1:
-        raise NotImplementedError('strange op')
-    return tokens[0]
-
-
-def ast_id2expr(a):
-    return m2_expr.ExprId(a, 32)
-
-
-def ast_int2expr(a):
-    return m2_expr.ExprInt(a, 32)
-
-
-def neg_int(tokens):
-    x = -tokens[0]
-    return x
-
-
-integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda tokens: int(tokens[0]))
-hex_word = pyparsing.Literal('0x') + pyparsing.Word(pyparsing.hexnums)
-hex_int = pyparsing.Combine(hex_word).setParseAction(lambda tokens: int(tokens[0], 16))
-
-# str_int = (Optional('-') + (hex_int | integer))
-str_int_pos = (hex_int | integer)
-str_int_neg = (pyparsing.Suppress('-') + \
-                   (hex_int | integer)).setParseAction(neg_int)
-
-str_int = str_int_pos | str_int_neg
-str_int.setParseAction(int2expr)
-
-logicop = pyparsing.oneOf('& | ^ >> << <<< >>>')
-signop = pyparsing.oneOf('+ -')
-multop = pyparsing.oneOf('* / %')
-plusop = pyparsing.oneOf('+ -')
-
-
-##########################
-
-def literal_list(l):
-    l = l[:]
-    l.sort()
-    l = l[::-1]
-    o = pyparsing.Literal(l[0])
-    for x in l[1:]:
-        o |= pyparsing.Literal(x)
-    return o
-
-
-def cb_int(tokens):
-    assert len(tokens) == 1
-    integer = AstInt(tokens[0])
-    return integer
-
-
-def cb_parse_id(tokens):
-    assert len(tokens) == 1
-    reg = tokens[0]
-    return AstId(reg)
-
-
-def cb_op_not(tokens):
-    tokens = tokens[0]
-    assert len(tokens) == 2
-    assert tokens[0] == "!"
-    result = AstOp("!", tokens[1])
-    return result
-
-
-def merge_ops(tokens, op):
-    args = []
-    if len(tokens) >= 3:
-        args = [tokens.pop(0)]
-        i = 0
-        while i < len(tokens):
-            op_tmp = tokens[i]
-            arg = tokens[i+1]
-            i += 2
-            if op_tmp != op:
-                raise ValueError("Bad operator")
-            args.append(arg)
-    result = AstOp(op, *args)
-    return result
-
-
-def cb_op_and(tokens):
-    result = merge_ops(tokens[0], "&")
-    return result
-
-
-def cb_op_xor(tokens):
-    result = merge_ops(tokens[0], "^")
-    return result
-
-
-def cb_op_sign(tokens):
-    assert len(tokens) == 1
-    op, value = tokens[0]
-    return -value
-
-
-def cb_op_div(tokens):
-    tokens = tokens[0]
-    assert len(tokens) == 3
-    assert tokens[1] == "/"
-    result = AstOp("/", tokens[0], tokens[2])
-    return result
-
-
-def cb_op_plusminus(tokens):
-    tokens = tokens[0]
-    if len(tokens) == 3:
-        # binary op
-        assert isinstance(tokens[0], AstNode)
-        assert isinstance(tokens[2], AstNode)
-        op, args = tokens[1], [tokens[0], tokens[2]]
-    elif len(tokens) > 3:
-        args = [tokens.pop(0)]
-        i = 0
-        while i < len(tokens):
-            op = tokens[i]
-            arg = tokens[i+1]
-            i += 2
-            if op == '-':
-                arg = -arg
-            elif op == '+':
-                pass
-            else:
-                raise ValueError("Bad operator")
-            args.append(arg)
-        op = '+'
-    else:
-        raise ValueError("Parsing error")
-    assert all(isinstance(arg, AstNode) for arg in args)
-    result = AstOp(op, *args)
-    return result
-
-
-def cb_op_mul(tokens):
-    tokens = tokens[0]
-    assert len(tokens) == 3
-    assert isinstance(tokens[0], AstNode)
-    assert isinstance(tokens[2], AstNode)
-
-    # binary op
-    op, args = tokens[1], [tokens[0], tokens[2]]
-    result = AstOp(op, *args)
-    return result
-
-
-integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda tokens: int(tokens[0]))
-hex_word = pyparsing.Literal('0x') + pyparsing.Word(pyparsing.hexnums)
-hex_int = pyparsing.Combine(hex_word).setParseAction(lambda tokens: int(tokens[0], 16))
-
-str_int_pos = (hex_int | integer)
-
-str_int = str_int_pos
-str_int.setParseAction(cb_int)
-
-notop = pyparsing.oneOf('!')
-andop = pyparsing.oneOf('&')
-orop = pyparsing.oneOf('|')
-xorop = pyparsing.oneOf('^')
-shiftop = pyparsing.oneOf('>> <<')
-rotop = pyparsing.oneOf('<<< >>>')
-signop = pyparsing.oneOf('+ -')
-mulop = pyparsing.oneOf('*')
-plusop = pyparsing.oneOf('+ -')
-divop = pyparsing.oneOf('/')
-
-
-variable = pyparsing.Word(pyparsing.alphas + "_$.", pyparsing.alphanums + "_")
-variable.setParseAction(cb_parse_id)
-operand = str_int | variable
-
-base_expr = pyparsing.infixNotation(operand,
-                               [(notop,   1, pyparsing.opAssoc.RIGHT, cb_op_not),
-                                (andop, 2, pyparsing.opAssoc.RIGHT, cb_op_and),
-                                (xorop, 2, pyparsing.opAssoc.RIGHT, cb_op_xor),
-                                (signop,  1, pyparsing.opAssoc.RIGHT, cb_op_sign),
-                                (mulop,  2, pyparsing.opAssoc.RIGHT, cb_op_mul),
-                                (divop,  2, pyparsing.opAssoc.RIGHT, cb_op_div),
-                                (plusop,  2, pyparsing.opAssoc.LEFT, cb_op_plusminus),
-                                ])
-
-
-default_prio = 0x1337
-
-
-def isbin(s):
-    return re.match(r'[0-1]+$', s)
-
-
-def int2bin(i, l):
-    s = '0' * l + bin(i)[2:]
-    return s[-l:]
-
-
-def myror32(v, r):
-    return ((v & 0xFFFFFFFF) >> r) | ((v << (32 - r)) & 0xFFFFFFFF)
-
-
-def myrol32(v, r):
-    return ((v & 0xFFFFFFFF) >> (32 - r)) | ((v << r) & 0xFFFFFFFF)
-
-
-class bs(object):
-    all_new_c = {}
-    prio = default_prio
-
-    def __init__(self, strbits=None, l=None, cls=None,
-                 fname=None, order=0, flen=None, **kargs):
-        if fname is None:
-            fname = hex(id(str((strbits, l, cls, fname, order, flen, kargs))))
-        if strbits is None:
-            strbits = ""  # "X"*l
-        elif l is None:
-            l = len(strbits)
-        if strbits and isbin(strbits):
-            value = int(strbits, 2)
-        elif 'default_val' in kargs:
-            value = int(kargs['default_val'], 2)
-        else:
-            value = None
-        allbits = list(strbits)
-        allbits.reverse()
-        fbits = 0
-        fmask = 0
-        while allbits:
-            a = allbits.pop()
-            if a == " ":
-                continue
-            fbits <<= 1
-            fmask <<= 1
-            if a in '01':
-                a = int(a)
-                fbits |= a
-                fmask |= 1
-        lmask = (1 << l) - 1
-        # gen conditional field
-        if cls:
-            for b in cls:
-                if 'flen' in b.__dict__:
-                    flen = getattr(b, 'flen')
-
-        self.strbits = strbits
-        self.l = l
-        self.cls = cls
-        self.fname = fname
-        self.order = order
-        self.fbits = fbits
-        self.fmask = fmask
-        self.flen = flen
-        self.value = value
-        self.kargs = kargs
-
-    lmask = property(lambda self:(1 << self.l) - 1)
-
-    def __getitem__(self, item):
-        return getattr(self, item)
-
-    def __repr__(self):
-        o = self.__class__.__name__
-        if self.fname:
-            o += "_%s" % self.fname
-        o += "_%(strbits)s" % self
-        if self.cls:
-            o += '_' + '_'.join([x.__name__ for x in self.cls])
-        return o
-
-    def gen(self, parent):
-        c_name = 'nbsi'
-        if self.cls:
-            c_name += '_' + '_'.join([x.__name__ for x in self.cls])
-            bases = list(self.cls)
-        else:
-            bases = []
-        # bsi added at end of list
-        # used to use first function of added class
-        bases += [bsi]
-        k = c_name, tuple(bases)
-        if k in self.all_new_c:
-            new_c = self.all_new_c[k]
-        else:
-            new_c = type(c_name, tuple(bases), {})
-            self.all_new_c[k] = new_c
-        c = new_c(parent,
-                  self.strbits, self.l, self.cls,
-                  self.fname, self.order, self.lmask, self.fbits,
-                  self.fmask, self.value, self.flen, **self.kargs)
-        return c
-
-    def check_fbits(self, v):
-        return v & self.fmask == self.fbits
-
-    @classmethod
-    def flen(cls, v):
-        raise NotImplementedError('not fully functional')
-
-
-class dum_arg(object):
-
-    def __init__(self, e=None):
-        self.expr = e
-
-
-class bsopt(bs):
-
-    def ispresent(self):
-        return True
-
-
-class bsi(object):
-
-    def __init__(self, parent, strbits, l, cls, fname, order,
-                 lmask, fbits, fmask, value, flen, **kargs):
-        self.parent = parent
-        self.strbits = strbits
-        self.l = l
-        self.cls = cls
-        self.fname = fname
-        self.order = order
-        self.fbits = fbits
-        self.fmask = fmask
-        self.flen = flen
-        self.value = value
-        self.kargs = kargs
-        self.__dict__.update(self.kargs)
-
-    lmask = property(lambda self:(1 << self.l) - 1)
-
-    def decode(self, v):
-        self.value = v & self.lmask
-        return True
-
-    def encode(self):
-        return True
-
-    def clone(self):
-        s = self.__class__(self.parent,
-                           self.strbits, self.l, self.cls,
-                           self.fname, self.order, self.lmask, self.fbits,
-                           self.fmask, self.value, self.flen, **self.kargs)
-        s.__dict__.update(self.kargs)
-        if hasattr(self, 'expr'):
-            s.expr = self.expr
-        return s
-
-    def __hash__(self):
-        kargs = []
-        for k, v in list(viewitems(self.kargs)):
-            if isinstance(v, list):
-                v = tuple(v)
-            kargs.append((k, v))
-        l = [self.strbits, self.l, self.cls,
-             self.fname, self.order, self.lmask, self.fbits,
-             self.fmask, self.value]  # + kargs
-
-        return hash(tuple(l))
-
-
-class bs_divert(object):
-    prio = default_prio
-
-    def __init__(self, **kargs):
-        self.args = kargs
-
-    def __getattr__(self, item):
-        if item in self.__dict__:
-            return self.__dict__[item]
-        elif item in self.args:
-            return self.args.get(item)
-        else:
-            raise AttributeError
-
-
-class bs_name(bs_divert):
-    prio = 1
-
-    def divert(self, i, candidates):
-        out = []
-        for cls, _, bases, dct, fields in candidates:
-            for new_name, value in viewitems(self.args['name']):
-                nfields = fields[:]
-                s = int2bin(value, self.args['l'])
-                args = dict(self.args)
-                args.update({'strbits': s})
-                f = bs(**args)
-                nfields[i] = f
-                ndct = dict(dct)
-                ndct['name'] = new_name
-                out.append((cls, new_name, bases, ndct, nfields))
-        return out
-
-
-class bs_mod_name(bs_divert):
-    prio = 2
-
-    def divert(self, i, candidates):
-        out = []
-        for cls, _, bases, dct, fields in candidates:
-            tab = self.args['mn_mod']
-            if isinstance(tab, list):
-                tmp = {}
-                for j, v in enumerate(tab):
-                    tmp[j] = v
-                tab = tmp
-            for value, new_name in viewitems(tab):
-                nfields = fields[:]
-                s = int2bin(value, self.args['l'])
-                args = dict(self.args)
-                args.update({'strbits': s})
-                f = bs(**args)
-                nfields[i] = f
-                ndct = dict(dct)
-                ndct['name'] = self.modname(ndct['name'], value)
-                out.append((cls, new_name, bases, ndct, nfields))
-        return out
-
-    def modname(self, name, i):
-        return name + self.args['mn_mod'][i]
-
-
-class bs_cond(bsi):
-    pass
-
-
-class bs_swapargs(bs_divert):
-
-    def divert(self, i, candidates):
-        out = []
-        for cls, name, bases, dct, fields in candidates:
-            # args not permuted
-            ndct = dict(dct)
-            nfields = fields[:]
-            # gen fix field
-            f = gen_bsint(0, self.args['l'], self.args)
-            nfields[i] = f
-            out.append((cls, name, bases, ndct, nfields))
-
-            # args permuted
-            ndct = dict(dct)
-            nfields = fields[:]
-            ap = ndct['args_permut'][:]
-            a = ap.pop(0)
-            b = ap.pop(0)
-            ndct['args_permut'] = [b, a] + ap
-            # gen fix field
-            f = gen_bsint(1, self.args['l'], self.args)
-            nfields[i] = f
-
-            out.append((cls, name, bases, ndct, nfields))
-        return out
-
-
-class m_arg(object):
-
-    def fromstring(self, text, loc_db, parser_result=None):
-        if parser_result:
-            e, start, stop = parser_result[self.parser]
-            self.expr = e
-            return start, stop
-        try:
-            v, start, stop = next(self.parser.scanString(text))
-        except StopIteration:
-            return None, None
-        arg = v[0]
-        expr = self.asm_ast_to_expr(arg, loc_db)
-        self.expr = expr
-        return start, stop
-
-    def asm_ast_to_expr(self, arg, loc_db, **kwargs):
-        raise NotImplementedError("Virtual")
-
-
-class m_reg(m_arg):
-    prio = default_prio
-
-    @property
-    def parser(self):
-        return self.reg.parser
-
-    def decode(self, v):
-        self.expr = self.reg.expr[0]
-        return True
-
-    def encode(self):
-        return self.expr == self.reg.expr[0]
-
-
-class reg_noarg(object):
-    reg_info = None
-    parser = None
-
-    def fromstring(self, text, loc_db, parser_result=None):
-        if parser_result:
-            e, start, stop = parser_result[self.parser]
-            self.expr = e
-            return start, stop
-        try:
-            v, start, stop = next(self.parser.scanString(text))
-        except StopIteration:
-            return None, None
-        arg = v[0]
-        expr = self.parses_to_expr(arg, loc_db)
-        self.expr = expr
-        return start, stop
-
-    def decode(self, v):
-        v = v & self.lmask
-        if v >= len(self.reg_info.expr):
-            return False
-        self.expr = self.reg_info.expr[v]
-        return True
-
-    def encode(self):
-        if not self.expr in self.reg_info.expr:
-            log.debug("cannot encode reg %r", self.expr)
-            return False
-        self.value = self.reg_info.expr.index(self.expr)
-        return True
-
-    def check_fbits(self, v):
-        return v & self.fmask == self.fbits
-
-
-class mn_prefix(object):
-    pass
-
-
-def swap16(v):
-    return struct.unpack('<H', struct.pack('>H', v))[0]
-
-
-def swap32(v):
-    return struct.unpack('<I', struct.pack('>I', v))[0]
-
-
-def perm_inv(p):
-    o = [None for x in range(len(p))]
-    for i, x in enumerate(p):
-        o[x] = i
-    return o
-
-
-def gen_bsint(value, l, args):
-    s = int2bin(value, l)
-    args = dict(args)
-    args.update({'strbits': s})
-    f = bs(**args)
-    return f
-
-total_scans = 0
-
-
-def branch2nodes(branch, nodes=None):
-    if nodes is None:
-        nodes = []
-    for k, v in viewitems(branch):
-        if not isinstance(v, dict):
-            continue
-        for k2 in v:
-            nodes.append((k, k2))
-        branch2nodes(v, nodes)
-
-
-def factor_one_bit(tree):
-    if isinstance(tree, set):
-        return tree
-    new_keys = defaultdict(lambda: defaultdict(dict))
-    if len(tree) == 1:
-        return tree
-    for k, v in viewitems(tree):
-        if k == "mn":
-            new_keys[k] = v
-            continue
-        l, fmask, fbits, fname, flen = k
-        if flen is not None or l <= 1:
-            new_keys[k] = v
-            continue
-        cfmask = fmask >> (l - 1)
-        nfmask = fmask & ((1 << (l - 1)) - 1)
-        cfbits = fbits >> (l - 1)
-        nfbits = fbits & ((1 << (l - 1)) - 1)
-        ck = 1, cfmask, cfbits, None, flen
-        nk = l - 1, nfmask, nfbits, fname, flen
-        if nk in new_keys[ck]:
-            raise NotImplementedError('not fully functional')
-        new_keys[ck][nk] = v
-    for k, v in list(viewitems(new_keys)):
-        new_keys[k] = factor_one_bit(v)
-    # try factor sons
-    if len(new_keys) != 1:
-        return new_keys
-    subtree = next(iter(viewvalues(new_keys)))
-    if len(subtree) != 1:
-        return new_keys
-    if next(iter(subtree)) == 'mn':
-        return new_keys
-
-    return new_keys
-
-
-def factor_fields(tree):
-    if not isinstance(tree, dict):
-        return tree
-    if len(tree) != 1:
-        return tree
-    # merge
-    k1, v1 = next(iter(viewitems(tree)))
-    if k1 == "mn":
-        return tree
-    l1, fmask1, fbits1, fname1, flen1 = k1
-    if fname1 is not None:
-        return tree
-    if flen1 is not None:
-        return tree
-
-    if not isinstance(v1, dict):
-        return tree
-    if len(v1) != 1:
-        return tree
-    k2, v2 = next(iter(viewitems(v1)))
-    if k2 == "mn":
-        return tree
-    l2, fmask2, fbits2, fname2, flen2 = k2
-    if fname2 is not None:
-        return tree
-    if flen2 is not None:
-        return tree
-    l = l1 + l2
-    fmask = (fmask1 << l2) | fmask2
-    fbits = (fbits1 << l2) | fbits2
-    fname = fname2
-    flen = flen2
-    k = l, fmask, fbits, fname, flen
-    new_keys = {k: v2}
-    return new_keys
-
-
-def factor_fields_all(tree):
-    if not isinstance(tree, dict):
-        return tree
-    new_keys = {}
-    for k, v in viewitems(tree):
-        v = factor_fields(v)
-        new_keys[k] = factor_fields_all(v)
-    return new_keys
-
-
-def graph_tree(tree):
-    nodes = []
-    branch2nodes(tree, nodes)
-
-    out = """
-          digraph G {
-          """
-    for a, b in nodes:
-        if b == 'mn':
-            continue
-        out += "%s -> %s;\n" % (id(a), id(b))
-    out += "}"
-    open('graph.txt', 'w').write(out)
-
-
-def add_candidate_to_tree(tree, c):
-    branch = tree
-    for f in c.fields:
-        if f.l == 0:
-            continue
-        node = f.l, f.fmask, f.fbits, f.fname, f.flen
-
-        if not node in branch:
-            branch[node] = {}
-        branch = branch[node]
-    if not 'mn' in branch:
-        branch['mn'] = set()
-    branch['mn'].add(c)
-
-
-def add_candidate(bases, c):
-    add_candidate_to_tree(bases[0].bintree, c)
-
-
-def getfieldby_name(fields, fname):
-    f = [x for x in fields if hasattr(x, 'fname') and x.fname == fname]
-    if len(f) != 1:
-        raise ValueError('more than one field with name: %s' % fname)
-    return f[0]
-
-
-def getfieldindexby_name(fields, fname):
-    for i, f in enumerate(fields):
-        if hasattr(f, 'fname') and f.fname == fname:
-            return f, i
-    return None
-
-
-class metamn(type):
-
-    def __new__(mcs, name, bases, dct):
-        if name == "cls_mn" or name.startswith('mn_'):
-            return type.__new__(mcs, name, bases, dct)
-        alias = dct.get('alias', False)
-
-        fields = bases[0].mod_fields(dct['fields'])
-        if not 'name' in dct:
-            dct["name"] = bases[0].getmn(name)
-        if 'args' in dct:
-            # special case for permuted arguments
-            o = []
-            p = []
-            for i, a in enumerate(dct['args']):
-                o.append((i, a))
-                if a in fields:
-                    p.append((fields.index(a), a))
-            p.sort()
-            p = [x[1] for x in p]
-            p = [dct['args'].index(x) for x in p]
-            dct['args_permut'] = perm_inv(p)
-        # order fields
-        f_ordered = [x for x in enumerate(fields)]
-        f_ordered.sort(key=lambda x: (x[1].prio, x[0]))
-        candidates = bases[0].gen_modes(mcs, name, bases, dct, fields)
-        for i, fc in f_ordered:
-            if isinstance(fc, bs_divert):
-                candidates = fc.divert(i, candidates)
-        for cls, name, bases, dct, fields in candidates:
-            ndct = dict(dct)
-            fields = [f for f in fields if f]
-            ndct['fields'] = fields
-            ndct['mn_len'] = sum([x.l for x in fields])
-            c = type.__new__(cls, name, bases, ndct)
-            c.alias = alias
-            c.check_mnemo(fields)
-            c.num = bases[0].num
-            bases[0].num += 1
-            bases[0].all_mn.append(c)
-            mode = dct['mode']
-            bases[0].all_mn_mode[mode].append(c)
-            bases[0].all_mn_name[c.name].append(c)
-            i = c()
-            i.init_class()
-            bases[0].all_mn_inst[c].append(i)
-            add_candidate(bases, c)
-            # gen byte lookup
-            o = ""
-            for f in i.fields_order:
-                if not isinstance(f, bsi):
-                    raise ValueError('f is not bsi')
-                if f.l == 0:
-                    continue
-                o += f.strbits
-        return c
-
-
-class instruction(object):
-    __slots__ = ["name", "mode", "args",
-                 "l", "b", "offset", "data",
-                 "additional_info", "delayslot"]
-
-    def __init__(self, name, mode, args, additional_info=None):
-        self.name = name
-        self.mode = mode
-        self.args = args
-        self.additional_info = additional_info
-        self.offset = None
-        self.l = None
-        self.b = None
-        self.delayslot = 0
-
-    def gen_args(self, args):
-        out = ', '.join([str(x) for x in args])
-        return out
-
-    def __str__(self):
-        return self.to_string()
-
-    def to_string(self, loc_db=None):
-        o = "%-10s " % self.name
-        args = []
-        for i, arg in enumerate(self.args):
-            if not isinstance(arg, m2_expr.Expr):
-                raise ValueError('zarb arg type')
-            x = self.arg2str(arg, i, loc_db)
-            args.append(x)
-        o += self.gen_args(args)
-        return o
-
-    def to_html(self, loc_db=None):
-        out = "%-10s " % self.name
-        out = '<font color="%s">%s</font>' % (utils.COLOR_MNEMO, out)
-
-        args = []
-        for i, arg in enumerate(self.args):
-            if not isinstance(arg, m2_expr.Expr):
-                raise ValueError('zarb arg type')
-            x = self.arg2html(arg, i, loc_db)
-            args.append(x)
-        out += self.gen_args(args)
-        return out
-
-    def get_asm_offset(self, expr):
-        return m2_expr.ExprInt(self.offset, expr.size)
-
-    def get_asm_next_offset(self, expr):
-        return m2_expr.ExprInt(self.offset+self.l, expr.size)
-
-    def resolve_args_with_symbols(self, loc_db):
-        args_out = []
-        for expr in self.args:
-            # try to resolve symbols using loc_db (0 for default value)
-            loc_keys = m2_expr.get_expr_locs(expr)
-            fixed_expr = {}
-            for exprloc in loc_keys:
-                loc_key = exprloc.loc_key
-                names = loc_db.get_location_names(loc_key)
-                # special symbols
-                if '$' in names:
-                    fixed_expr[exprloc] = self.get_asm_offset(exprloc)
-                    continue
-                if '_' in names:
-                    fixed_expr[exprloc] = self.get_asm_next_offset(exprloc)
-                    continue
-                arg_int = loc_db.get_location_offset(loc_key)
-                if arg_int is not None:
-                    fixed_expr[exprloc] = m2_expr.ExprInt(arg_int, exprloc.size)
-                    continue
-                if not names:
-                    raise ValueError('Unresolved symbol: %r' % exprloc)
-
-                offset = loc_db.get_location_offset(loc_key)
-                if offset is None:
-                    raise ValueError(
-                        'The offset of loc_key "%s" cannot be determined' % names
-                    )
-                else:
-                    # Fix symbol with its offset
-                    size = exprloc.size
-                    if size is None:
-                        default_size = self.get_symbol_size(exprloc, loc_db)
-                        size = default_size
-                    value = m2_expr.ExprInt(offset, size)
-                fixed_expr[exprloc] = value
-
-            expr = expr.replace_expr(fixed_expr)
-            expr = expr_simp(expr)
-            args_out.append(expr)
-        return args_out
-
-    def get_info(self, c):
-        return
-
-
-class cls_mn(with_metaclass(metamn, object)):
-    args_symb = []
-    instruction = instruction
-    # Block's offset alignment
-    alignment = 1
-
-    @classmethod
-    def guess_mnemo(cls, bs, attrib, pre_dis_info, offset):
-        candidates = []
-
-        candidates = set()
-
-        fname_values = pre_dis_info
-        todo = [
-            (dict(fname_values), branch, offset * 8)
-            for branch in list(viewitems(cls.bintree))
-        ]
-        for fname_values, branch, offset_b in todo:
-            (l, fmask, fbits, fname, flen), vals = branch
-
-            if flen is not None:
-                l = flen(attrib, fname_values)
-            if l is not None:
-                try:
-                    v = cls.getbits(bs, attrib, offset_b, l)
-                except IOError:
-                    # Raised if offset is out of bound
-                    continue
-                offset_b += l
-                if v & fmask != fbits:
-                    continue
-                if fname is not None and not fname in fname_values:
-                    fname_values[fname] = v
-            for nb, v in viewitems(vals):
-                if 'mn' in nb:
-                    candidates.update(v)
-                else:
-                    todo.append((dict(fname_values), (nb, v), offset_b))
-
-        return [c for c in candidates]
-
-    def reset_class(self):
-        for f in self.fields_order:
-            if f.strbits and isbin(f.strbits):
-                f.value = int(f.strbits, 2)
-            elif 'default_val' in f.kargs:
-                f.value = int(f.kargs['default_val'], 2)
-            else:
-                f.value = None
-            if f.fname:
-                setattr(self, f.fname, f)
-
-    def init_class(self):
-        args = []
-        fields_order = []
-        to_decode = []
-        off = 0
-        for i, fc in enumerate(self.fields):
-            f = fc.gen(self)
-            f.offset = off
-            off += f.l
-            fields_order.append(f)
-            to_decode.append((i, f))
-
-            if isinstance(f, m_arg):
-                args.append(f)
-            if f.fname:
-                setattr(self, f.fname, f)
-        if hasattr(self, 'args_permut'):
-            args = [args[self.args_permut[i]]
-                    for i in range(len(self.args_permut))]
-        to_decode.sort(key=lambda x: (x[1].order, x[0]))
-        to_decode = [fields_order.index(f[1]) for f in to_decode]
-        self.args = args
-        self.fields_order = fields_order
-        self.to_decode = to_decode
-
-    def add_pre_dis_info(self, prefix=None):
-        return True
-
-    @classmethod
-    def getbits(cls, bs, attrib, offset_b, l):
-        return bs.getbits(offset_b, l)
-
-    @classmethod
-    def getbytes(cls, bs, offset, l):
-        return bs.getbytes(offset, l)
-
-    @classmethod
-    def pre_dis(cls, v_o, attrib, offset):
-        return {}, v_o, attrib, offset, 0
-
-    def post_dis(self):
-        return self
-
-    @classmethod
-    def check_mnemo(cls, fields):
-        pass
-
-    @classmethod
-    def mod_fields(cls, fields):
-        return fields
-
-    @classmethod
-    def dis(cls, bs_o, mode_o = None, offset=0):
-        if not isinstance(bs_o, bin_stream):
-            bs_o = bin_stream_str(bs_o)
-
-        bs_o.enter_atomic_mode()
-
-        offset_o = offset
-        try:
-            pre_dis_info, bs, mode, offset, prefix_len = cls.pre_dis(
-                bs_o, mode_o, offset)
-        except:
-            bs_o.leave_atomic_mode()
-            raise
-        candidates = cls.guess_mnemo(bs, mode, pre_dis_info, offset)
-        if not candidates:
-            bs_o.leave_atomic_mode()
-            raise Disasm_Exception('cannot disasm (guess) at %X' % offset)
-
-        out = []
-        out_c = []
-        if hasattr(bs, 'getlen'):
-            bs_l = bs.getlen()
-        else:
-            bs_l = len(bs)
-
-        alias = False
-        for c in candidates:
-            log.debug("*" * 40, mode, c.mode)
-            log.debug(c.fields)
-
-            c = cls.all_mn_inst[c][0]
-
-            c.reset_class()
-            c.mode = mode
-
-            if not c.add_pre_dis_info(pre_dis_info):
-                continue
-
-            todo = {}
-            getok = True
-            fname_values = dict(pre_dis_info)
-            offset_b = offset * 8
-
-            total_l = 0
-            for i, f in enumerate(c.fields_order):
-                if f.flen is not None:
-                    l = f.flen(mode, fname_values)
-                else:
-                    l = f.l
-                if l is not None:
-                    total_l += l
-                    f.l = l
-                    f.is_present = True
-                    log.debug("FIELD %s %s %s %s", f.__class__, f.fname,
-                              offset_b, l)
-                    if bs_l * 8 - offset_b < l:
-                        getok = False
-                        break
-                    try:
-                        bv = cls.getbits(bs, mode, offset_b, l)
-                    except:
-                        bs_o.leave_atomic_mode()
-                        raise
-                    offset_b += l
-                    if not f.fname in fname_values:
-                        fname_values[f.fname] = bv
-                    todo[i] = bv
-                else:
-                    f.is_present = False
-                    todo[i] = None
-
-            if not getok:
-                continue
-
-            c.l = prefix_len + total_l // 8
-            for i in c.to_decode:
-                f = c.fields_order[i]
-                if f.is_present:
-                    ret = f.decode(todo[i])
-                    if not ret:
-                        log.debug("cannot decode %r", f)
-                        break
-
-            if not ret:
-                continue
-            for a in c.args:
-                a.expr = expr_simp(a.expr)
-
-            c.b = cls.getbytes(bs, offset_o, c.l)
-            c.offset = offset_o
-            c = c.post_dis()
-            if c is None:
-                continue
-            c_args = [a.expr for a in c.args]
-            instr = cls.instruction(c.name, mode, c_args,
-                                    additional_info=c.additional_info())
-            instr.l = prefix_len + total_l // 8
-            instr.b = cls.getbytes(bs, offset_o, instr.l)
-            instr.offset = offset_o
-            instr.get_info(c)
-            if c.alias:
-                alias = True
-            out.append(instr)
-            out_c.append(c)
-
-        bs_o.leave_atomic_mode()
-
-        if not out:
-            raise Disasm_Exception('cannot disasm at %X' % offset_o)
-        if len(out) != 1:
-            if not alias:
-                log.warning('dis multiple args ret default')
-
-            for i, o in enumerate(out_c):
-                if o.alias:
-                    return out[i]
-            raise NotImplementedError(
-                'Multiple disas: \n' +
-                "\n".join(str(x) for x in out)
-            )
-        return out[0]
-
-    @classmethod
-    def fromstring(cls, text, loc_db, mode = None):
-        global total_scans
-        name = re.search(r'(\S+)', text).groups()
-        if not name:
-            raise ValueError('cannot find name', text)
-        name = name[0]
-
-        if not name in cls.all_mn_name:
-            raise ValueError('unknown name', name)
-        clist = [x for x in cls.all_mn_name[name]]
-        out = []
-        out_args = []
-        parsers = defaultdict(dict)
-
-        for cc in clist:
-            for c in cls.get_cls_instance(cc, mode):
-                args_expr = []
-                args_str = text[len(name):].strip(' ')
-
-                start = 0
-                cannot_parse = False
-                len_o = len(args_str)
-
-                for i, f in enumerate(c.args):
-                    start_i = len_o - len(args_str)
-                    if type(f.parser) == tuple:
-                        parser = f.parser
-                    else:
-                        parser = (f.parser,)
-                    for p in parser:
-                        if p in parsers[(i, start_i)]:
-                            continue
-                        try:
-                            total_scans += 1
-                            v, start, stop = next(p.scanString(args_str))
-                        except StopIteration:
-                            v, start, stop = [None], None, None
-                        if start != 0:
-                            v, start, stop = [None], None, None
-                        if v != [None]:
-                            v = f.asm_ast_to_expr(v[0], loc_db)
-                        if v is None:
-                            v, start, stop = [None], None, None
-                        parsers[(i, start_i)][p] = v, start, stop
-                    start, stop = f.fromstring(args_str, loc_db, parsers[(i, start_i)])
-                    if start != 0:
-                        log.debug("cannot fromstring %r", args_str)
-                        cannot_parse = True
-                        break
-                    if f.expr is None:
-                        raise NotImplementedError('not fully functional')
-                    f.expr = expr_simp(f.expr)
-                    args_expr.append(f.expr)
-                    args_str = args_str[stop:].strip(' ')
-                    if args_str.startswith(','):
-                        args_str = args_str[1:]
-                    args_str = args_str.strip(' ')
-                if args_str:
-                    cannot_parse = True
-                if cannot_parse:
-                    continue
-
-                out.append(c)
-                out_args.append(args_expr)
-                break
-
-        if len(out) == 0:
-            raise ValueError('cannot fromstring %r' % text)
-        if len(out) != 1:
-            log.debug('fromstring multiple args ret default')
-        c = out[0]
-        c_args = out_args[0]
-
-        instr = cls.instruction(c.name, mode, c_args,
-                                additional_info=c.additional_info())
-        return instr
-
-    def dup_info(self, infos):
-        return
-
-    @classmethod
-    def get_cls_instance(cls, cc, mode, infos=None):
-        c = cls.all_mn_inst[cc][0]
-
-        c.reset_class()
-        c.add_pre_dis_info()
-        c.dup_info(infos)
-
-        c.mode = mode
-        yield c
-
-    @classmethod
-    def asm(cls, instr, loc_db=None):
-        """
-        Re asm instruction by searching mnemo using name and args. We then
-        can modify args and get the hex of a modified instruction
-        """
-        clist = cls.all_mn_name[instr.name]
-        clist = [x for x in clist]
-        vals = []
-        candidates = []
-        args = instr.resolve_args_with_symbols(loc_db)
-
-        for cc in clist:
-
-            for c in cls.get_cls_instance(
-                cc, instr.mode, instr.additional_info):
-
-                cannot_parse = False
-                if len(c.args) != len(instr.args):
-                    continue
-
-                # only fix args expr
-                for i in range(len(c.args)):
-                    c.args[i].expr = args[i]
-
-                v = c.value(instr.mode)
-                if not v:
-                    log.debug("cannot encode %r", c)
-                    cannot_parse = True
-                if cannot_parse:
-                    continue
-                vals += v
-                candidates.append((c, v))
-        if len(vals) == 0:
-            raise ValueError(
-                'cannot asm %r %r' %
-                (instr.name, [str(x) for x in instr.args])
-            )
-        if len(vals) != 1:
-            log.debug('asm multiple args ret default')
-
-        vals = cls.filter_asm_candidates(instr, candidates)
-        return vals
-
-    @classmethod
-    def filter_asm_candidates(cls, instr, candidates):
-        o = []
-        for _, v in candidates:
-            o += v
-        o.sort(key=len)
-        return o
-
-    def value(self, mode):
-        todo = [(0, 0, [(x, self.fields_order[x]) for x in self.to_decode[::-1]])]
-
-        result = []
-        done = []
-
-        while todo:
-            index, cur_len, to_decode = todo.pop()
-            # TEST XXX
-            for _, f in to_decode:
-                setattr(self, f.fname, f)
-            if (index, [x[1].value for x in to_decode]) in done:
-                continue
-            done.append((index, [x[1].value for x in to_decode]))
-
-            can_encode = True
-            for i, f in to_decode[index:]:
-                f.parent.l = cur_len
-                ret = f.encode()
-                if not ret:
-                    log.debug('cannot encode %r', f)
-                    can_encode = False
-                    break
-
-                if f.value is not None and f.l:
-                    if f.value > f.lmask:
-                        log.debug('cannot encode %r', f)
-                        can_encode = False
-                        break
-                    cur_len += f.l
-                index += 1
-                if ret is True:
-                    continue
-
-                for _ in ret:
-                    o = []
-                    if ((index, cur_len, [xx[1].value for xx in to_decode]) in todo or
-                        (index, cur_len, [xx[1].value for xx in to_decode]) in done):
-                        raise NotImplementedError('not fully functional')
-
-                    for p, f in to_decode:
-                        fnew = f.clone()
-                        o.append((p, fnew))
-                    todo.append((index, cur_len, o))
-                can_encode = False
-
-                break
-            if not can_encode:
-                continue
-            result.append(to_decode)
-
-        return self.decoded2bytes(result)
-
-    def encodefields(self, decoded):
-        bits = bitobj()
-        for _, f in decoded:
-            setattr(self, f.fname, f)
-
-            if f.value is None:
-                continue
-            bits.putbits(f.value, f.l)
-
-        return bits.tostring()
-
-    def decoded2bytes(self, result):
-        if not result:
-            return []
-
-        out = []
-        for decoded in result:
-            decoded.sort()
-
-            o = self.encodefields(decoded)
-            if o is None:
-                continue
-            out.append(o)
-        out = list(set(out))
-        return out
-
-    def gen_args(self, args):
-        out = ', '.join([str(x) for x in args])
-        return out
-
-    def args2str(self):
-        args = []
-        for arg in self.args:
-            # XXX todo test
-            if not (isinstance(arg, m2_expr.Expr) or
-                    isinstance(arg.expr, m2_expr.Expr)):
-                raise ValueError('zarb arg type')
-            x = str(arg)
-            args.append(x)
-        return args
-
-    def __str__(self):
-        o = "%-10s " % self.name
-        args = []
-        for arg in self.args:
-            # XXX todo test
-            if not (isinstance(arg, m2_expr.Expr) or
-                    isinstance(arg.expr, m2_expr.Expr)):
-                raise ValueError('zarb arg type')
-            x = str(arg)
-            args.append(x)
-
-        o += self.gen_args(args)
-        return o
-
-    def parse_prefix(self, v):
-        return 0
-
-    def set_dst_symbol(self, loc_db):
-        dst = self.getdstflow(loc_db)
-        args = []
-        for d in dst:
-            if isinstance(d, m2_expr.ExprInt):
-                l = loc_db.get_or_create_offset_location(int(d))
-
-                a = m2_expr.ExprId(l.name, d.size)
-            else:
-                a = d
-            args.append(a)
-        self.args_symb = args
-
-    def getdstflow(self, loc_db):
-        return [self.args[0].expr]
-
-
-class imm_noarg(object):
-    intsize = 32
-    intmask = (1 << intsize) - 1
-
-    def int2expr(self, v):
-        if (v & ~self.intmask) != 0:
-            return None
-        return m2_expr.ExprInt(v, self.intsize)
-
-    def expr2int(self, e):
-        if not isinstance(e, m2_expr.ExprInt):
-            return None
-        v = int(e)
-        if v & ~self.intmask != 0:
-            return None
-        return v
-
-    def fromstring(self, text, loc_db, parser_result=None):
-        if parser_result:
-            e, start, stop = parser_result[self.parser]
-        else:
-            try:
-                e, start, stop = next(self.parser.scanString(text))
-            except StopIteration:
-                return None, None
-        if e == [None]:
-            return None, None
-
-        assert(m2_expr.is_expr(e))
-        self.expr = e
-        if self.expr is None:
-            log.debug('cannot fromstring int %r', text)
-            return None, None
-        return start, stop
-
-    def decodeval(self, v):
-        return v
-
-    def encodeval(self, v):
-        return v
-
-    def decode(self, v):
-        v = v & self.lmask
-        v = self.decodeval(v)
-        e = self.int2expr(v)
-        if not e:
-            return False
-        self.expr = e
-        return True
-
-    def encode(self):
-        v = self.expr2int(self.expr)
-        if v is None:
-            return False
-        v = self.encodeval(v)
-        if v is False:
-            return False
-        self.value = v
-        return True
-
-
-class imm08_noarg(object):
-    int2expr = lambda self, x: m2_expr.ExprInt(x, 8)
-
-
-class imm16_noarg(object):
-    int2expr = lambda self, x: m2_expr.ExprInt(x, 16)
-
-
-class imm32_noarg(object):
-    int2expr = lambda self, x: m2_expr.ExprInt(x, 32)
-
-
-class imm64_noarg(object):
-    int2expr = lambda self, x: m2_expr.ExprInt(x, 64)
-
-
-class int32_noarg(imm_noarg):
-    intsize = 32
-    intmask = (1 << intsize) - 1
-
-    def decode(self, v):
-        v = sign_ext(v, self.l, self.intsize)
-        v = self.decodeval(v)
-        self.expr = self.int2expr(v)
-        return True
-
-    def encode(self):
-        if not isinstance(self.expr, m2_expr.ExprInt):
-            return False
-        v = int(self.expr)
-        if sign_ext(v & self.lmask, self.l, self.intsize) != v:
-            return False
-        v = self.encodeval(v & self.lmask)
-        if v is False:
-            return False
-        self.value = v & self.lmask
-        return True
-
-class bs8(bs):
-    prio = default_prio
-
-    def __init__(self, v, cls=None, fname=None, **kargs):
-        super(bs8, self).__init__(int2bin(v, 8), 8,
-                                  cls=cls, fname=fname, **kargs)
-
-
-
-
-def swap_uint(size, i):
-    if size == 8:
-        return i & 0xff
-    elif size == 16:
-        return struct.unpack('<H', struct.pack('>H', i & 0xffff))[0]
-    elif size == 32:
-        return struct.unpack('<I', struct.pack('>I', i & 0xffffffff))[0]
-    elif size == 64:
-        return struct.unpack('<Q', struct.pack('>Q', i & 0xffffffffffffffff))[0]
-    raise ValueError('unknown int len %r' % size)
-
-
-def swap_sint(size, i):
-    if size == 8:
-        return i
-    elif size == 16:
-        return struct.unpack('<h', struct.pack('>H', i & 0xffff))[0]
-    elif size == 32:
-        return struct.unpack('<i', struct.pack('>I', i & 0xffffffff))[0]
-    elif size == 64:
-        return struct.unpack('<q', struct.pack('>Q', i & 0xffffffffffffffff))[0]
-    raise ValueError('unknown int len %r' % size)
-
-
-def sign_ext(v, s_in, s_out):
-    assert(s_in <= s_out)
-    v &= (1 << s_in) - 1
-    sign_in = v & (1 << (s_in - 1))
-    if not sign_in:
-        return v
-    m = (1 << (s_out)) - 1
-    m ^= (1 << s_in) - 1
-    v |= m
-    return v