BX Rj

        Jump to the address in the Link Register
495534
def BX(self, params):
        
        Rj = self.get_one_parameter(self.ONE_PARAMETER, params)

        self.check_arguments(LR_or_general_purpose_registers=(Rj,))

        def BX_func():
            self.register['PC'] = self.register[Rj]

        return BX_func
189705
private void maybeMarkCurrentAddressAsUsed(LegacyAddress address) {
        checkArgument(address.getOutputScriptType() == ScriptType.P2SH);
        for (Map.Entry<KeyChain.KeyPurpose, Address> entry : currentAddresses.entrySet()) {
            if (entry.getValue() != null && entry.getValue().equals(address)) {
                log.info("Marking P2SH address as used: {}", address);
                currentAddresses.put(entry.getKey(), freshAddress(entry.getKey()));
                return;
            }
        }
    }
820417
def target!(addr)
      unless (address = Address.first(:address => addr))
        raise("unknown address #{addr.dump}")
      end

      return Target.first_or_create(:campaign => self, :address => address)
    end
939539
async def register(*address_list, cluster=None, loop=None):
    

    loop = loop or asyncio.get_event_loop()
    for address in address_list:
        host, port = address.rsplit(':', 1)
        node = Node(address=(host, int(port)), loop=loop)
        await node.start()

        for address in cluster:
            host, port = address.rsplit(':', 1)
            port = int(port)

            if (host, port) != (node.host, node.port):
                node.update_cluster((host, port))
84564
def setup_link(self, interface, cidr):
        
        # clear old ipaddr in interface
        cmd = ['ip', 'addr', 'flush', 'dev', interface]
        agent_utils.execute(cmd, root=True)
        ip = IPNetwork(cidr)
        cmd = ['ip', 'addr', 'add', cidr, 'broadcast',
               str(ip.broadcast), 'dev', interface]
        stdcode, stdout = agent_utils.execute(cmd, root=True)
        if stdcode == 0:
            cmd = ['ip', 'link', 'set', 'dev', interface, 'up']
            stdcode, stdout = agent_utils.execute(cmd, root=True)
            if stdcode == 0:
                return agent_utils.make_response(code=stdcode)
        # execute failed.
        message = stdout.pop(0)
        return agent_utils.make_response(code=stdcode, message=message)
308069
def addbr(name):
    '''  '''
    fcntl.ioctl(ifconfig.sockfd, SIOCBRADDBR, name)
    return Bridge(name)
1293500
def bind(self, queue, exchange, routing_key='', nowait=True, arguments={},
             ticket=None, cb=None):
        '''
        
        '''
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
            write_shortstr(queue).\
            write_shortstr(exchange).\
            write_shortstr(routing_key).\
            write_bit(nowait).\
            write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 20, args))

        if not nowait:
            self._bind_cb.append(cb)
            self.channel.add_synchronous_cb(self._recv_bind_ok)
978379
public function JumpToBasketPage()
    {
        $bJumpAsFarAsPossible = false;
        if ('1' === $this->getInputFilterUtil()->getFilteredInput('bJumpAsFarAsPossible')) {
            $bJumpAsFarAsPossible = true;
        }

        // save calling url to session
        $sCallingURL = $this->getCallingUrl();

        MTShopOrderWizardCore::SetCallingURL($sCallingURL);

        $systemPageService = $this->getSystemPageService();
        $checkoutSystemPage = $systemPageService->getSystemPage('checkout');
        if (null === $checkoutSystemPage) {
            throw new RouteNotFoundException("No system page with system name 'checkout' found - unable to redirect to the basket.");
        }
        $iRequestRedirectNodeId = $checkoutSystemPage->fieldCmsTreeId;

        $bNeedToRedirect = true;
        if (false === $bJumpAsFarAsPossible && $this->getActivePageService()->getActivePage()->GetMainTreeId() == $iRequestRedirectNodeId) {
            // we are already on the
            $bNeedToRedirect = false;
        }
        if (true === $bNeedToRedirect) {
            $oNode = new TCMSTreeNode();
            /** @var $oNode TCMSTreeNode */
            if ($oNode->Load($iRequestRedirectNodeId)) {
                $sURL = null;
                if ($bJumpAsFarAsPossible) {
                    $oUser = $this->getExtranetUserProvider()->getActiveUser();
                    $oStep = null;
                    $oBillingAdr = $oUser->GetBillingAddress();
                    if ($oUser->IsLoggedIn() && !is_null($oBillingAdr) && $oBillingAdr->ValidateData(TdbDataExtranetUserAddress::FORM_DATA_NAME_BILLING)) {
                        $oStep = TdbShopOrderStep::GetStep('shipping');
                    } else {
                        $oStep = TdbShopOrderStep::GetStep('user');
                    }
                    if (!is_null($oStep)) {
                        $sURL = $oStep->GetStepURL();
                    }
                }
                if (null === $sURL) {
                    $sURL = $systemPageService->getLinkToSystemPageRelative('checkout');
                }
                $this->getRedirect()->redirect($sURL);
            } else {
                $this->RedirectToCallingPage();
            }
        }
    }
722660
def add_jumpout_site(self, node):
        

        self._register_nodes(True, node)
        self._jumpout_sites.add(node)
        self._add_endpoint(node, 'transition')
779758
def set_raw_holding_register(self, name, value):
        """"""
        self._conn.write_register(
            unit=self._slave,
            address=(self._holding_regs[name]['addr']),
            value=value)
1301267
function getObjFromIKeyIx(ix) {
			var link, key = keys[ix], id;
			if(error) return;
			key = key.split(flds);
			id = key[key.length-2];
			link = self.links[key[0].split(hdrs)[1]];
			order[ix] = id;
			
			fc++;
			getObjFromDKey(self.getDataKey(id), function(err, obj) {
				if(err) error = err;
				else os[ix] = obj;
				done();
			});

			if(link) {
				fc++;
				getObjFromDKey(link.getDataKey(id, key[1]), function (err, obj) {
					if(err) error = err;
					else ds[ix] = obj;
					done();
				});
			}
		}
858250
function getTargetBBox(linkView, opt) {

        // expand by padding box
        if (opt && opt.paddingBox) return linkView.targetBBox.clone().moveAndExpand(opt.paddingBox);

        return linkView.targetBBox.clone();
    }
103863
def get_addr(iface='lo0', iface_type='link'):
    
    if platform.system() in ['Darwin', 'Linux']:
        if iface_type == 'link':
            _AF_FAMILY = psutil.AF_LINK
        elif iface_type in ['inet', 'inet6']:
            _AF_FAMILY = getattr(socket, 'AF_{}'.format(iface_type.upper()))
        else:
            raise SystemError('Not valid address FAMILY')
    else:
        raise SystemExit('Unsupported System. Only Mac/Linux Supported')

    addrs = psutil.net_if_addrs()
    for n in addrs[iface]:
        if n.family == _AF_FAMILY:
            return n.address
946578
async def write_registers(self, address, values, skip_encode=False):
        
        while len(values) > 62:
            await self._request('write_registers',
                                address, values, skip_encode=skip_encode)
            address, values = address + 124, values[62:]
        await self._request('write_registers',
                            address, values, skip_encode=skip_encode)
492656
def _translate_src_register_oprnd(self, operand):
        
        reg_info = self._arch_alias_mapper.get(operand.name, None)

        if reg_info:
            var_base_name, offset = reg_info

            var_size = self._arch_regs_size[var_base_name]
        else:
            var_base_name = operand.name
            var_size = operand.size

        var_name = self._get_var_name(var_base_name)
        ret_val = self.make_bitvec(var_size, var_name)

        if reg_info:
            ret_val = smtfunction.extract(ret_val, offset, operand.size)

        return ret_val
491059
def execute_DynamicJump
      method =  get_register(@instruction.register)
      pos = Position.get(method.binary)
      log.debug "Jump to binary at: #{pos} #{method.name}:#{method.binary.class}"
      raise "Invalid position for #{method.name}" unless pos.valid?
      pos = pos + Parfait::BinaryCode.byte_offset
      set_pc( pos )
      false
    end
1312011
def scan_interface(self, address):
        
        if self.cfusb is None:
            try:
                self.cfusb = CfUsb()
            except Exception as e:
                logger.warn(
                    'Exception while scanning for Crazyflie USB: {}'.format(
                        str(e)))
                return []
        else:
            raise Exception('Cannot scan for links while the link is open!')

        # FIXME: implements serial number in the Crazyradio driver!
        # serial = "N/A"

        found = self.cfusb.scan()

        self.cfusb.close()
        self.cfusb = None

        return found