Return a LDM instruction.
15715
def gen_ldm(src, dst):
        
        return ReilBuilder.build(ReilMnemonic.LDM, src, ReilEmptyOperand(), dst)
336378
def _load_lib():
    """"""
    lib_path = find_lib_path()
    if len(lib_path) == 0:
        return None
    lib = ctypes.cdll.LoadLibrary(lib_path[0])
    lib.LGBM_GetLastError.restype = ctypes.c_char_p
    return lib
596543
def lset(self, name, index, value):
        ""
        return self.execute_command('LSET', name, index, value)
1059152
def _load_lib():
    """"""
    lib_path = libinfo.find_lib_path()
    lib = ctypes.CDLL(lib_path[0], ctypes.RTLD_LOCAL)
    # DMatrix functions
    lib.MXGetLastError.restype = ctypes.c_char_p
    return lib
598261
def snap(self, instruction):
        
        return self.from_datetime(snaptime.snap(self.datetime(), instruction))
356093
def _gt_from_le(self, other):
    """"""
    op_result = self.__le__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result
627689
def target_from_compact(bits):
    """"""
    size = bits >> 24
    word = bits & 0x007fffff
    if size < 3:
        word >>= 8 * (3 - size)
    else:
        word <<= 8 * (size - 3)
    if bits & 0x00800000:
        word = -word
    return word
826949
def build(mnemonic, oprnd1, oprnd2, oprnd3):
        
        ins = ReilInstruction()

        ins.mnemonic = mnemonic
        ins.operands = [oprnd1, oprnd2, oprnd3]

        return ins
352592
def dM(self, k, t, param, Mkt, tips=None, gaps=None):
        """"""
        assert 0 <= k < self.ncats
        assert ((param in self.freeparams) or (param == 't') or (
                param == self.distributedparam))
        assert param not in self.distributionparams
        return self._models[k].dM(t, param, Mkt, tips=tips, gaps=gaps)
618342
def execute_lite(self, instructions, context=None):
        
        if context:
            self.__cpu.registers = dict(context)

        for instr in instructions:
            self.__execute_one(instr)

        return dict(self.__cpu.registers), self.__mem
1129809
def _getel(key, value):
    """"""
    if key in ['HorizontalRule', 'Null']:
        return elt(key, 0)()
    elif key in ['Plain', 'Para', 'BlockQuote', 'BulletList',
                 'DefinitionList', 'HorizontalRule', 'Null']:
        return elt(key, 1)(value)
    return elt(key, len(value))(*value)
1209781
def lpop(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'LPOP', key, encoding=encoding)
267065
def mnemonic(self, value):
        
        if value not in REIL_MNEMONICS:
            raise Exception("Invalid instruction mnemonic : %s" % str(value))

        self._mnemonic = value
1194747
def replace(self, old, new):
        """"""
        if old.type != new.type:
            raise TypeError("new instruction has a different type")
        pos = self.instructions.index(old)
        self.instructions.remove(old)
        self.instructions.insert(pos, new)

        for bb in self.parent.basic_blocks:
            for instr in bb.instructions:
                instr.replace_usage(old, new)
354667
def instruction_LD8(self, opcode, m, register):
        
#        log.debug("$%x LD8 %s = $%x" % (
#            self.program_counter,
#            register.name, m,
#        ))
        register.set(m)
        self.clear_NZV()
        self.update_NZ_8(m)
1366532
def instruction_path(cls, project, instruction):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/instructions/{instruction}",
            project=project,
            instruction=instruction,
        )
439086
def compiler(name):
    
    pinfo = __get_paths()
    _compiler = local[name]
    _compiler = _compiler.setenv(
        PATH=pinfo["path"], LD_LIBRARY_PATH=pinfo["ld_library_path"])
    return _compiler