Load a CHR Bank at a specific addres.
@param {number} address - The absolute address to load bank at (eg. 0x8000).
@param {bank} bank - Index of bank to load at given address.
@param {size} size - Size of all banks.
356136
function( address, bank, size ) {
		var offset = bank * size,
			bankData = this.chrData.subarray( offset, offset + size );

		this.chrRead.set( bankData, address );
	}
766268
function(qrContainer) {

        var elem = qrContainer.parents(".bitcoin-address-container");
        var url;
        //var addr = elem.attr("data-bc-address");

        if(this.config.qrRawAddress) {
            url = elem.attr("data-bc-address");
        } else {
            url = this.buildBitcoinURI(elem.attr("data-bc-address"),
            elem.attr("data-bc-amount"),
            elem.attr("data-bc-label"));
        }

        var options = $.extend({}, this.config.qr, {
            text: url
        });
        var qrCode = new qrcode.QRCode(qrContainer.get(0), options);
    }
1075505
function (priv) {
        if (utils.isString(priv) || Buffer.isBuffer(priv)) {
            this.privKey = priv.length === 32 ? priv : Buffer(priv, 'hex');
            this.pubKey = null;
            this.address = null;
        }
    }
1260619
function process(payload) {
  var addressType = parseInt(payload.substr(0,1),16);
  var typeCode = payload.substr(1,1);
  var length = parseInt(payload.substr(2,2),16) % 64;
  var rxAdd = "public";
  var txAdd = "public";
  if(addressType & 0x8) {
    rxAdd = "random";
  }
  if(addressType & 0x4) {
    txAdd = "random";
  }   
  var type;
  switch(typeCode) {
    case("0"):
      type = TYPE0_NAME;
      break;
    case("1"):
      type = TYPE1_NAME;
      break;
    case("2"):
      type = TYPE2_NAME;
      break;
    case("3"):
      type = TYPE3_NAME;
      break;
    case("4"):
      type = TYPE4_NAME;
      break;
    case("5"):
      type = TYPE5_NAME;
      break;
    case("6"):
      type = TYPE6_NAME;
      break;
    default: 
      type = TYPE_UNDEFINED_NAME;
  }
  return { type: type,
           length: length,
           txAdd: txAdd,
           rxAdd: rxAdd
  };
}
1328705
private void expandIfNecessary(int size) {
    if (bytes.length >= size) {
      // no need to expand
      return;
    }
    // either double, or expand to fit size
    int newlength = Math.max(2 * bytes.length, size);
    bytes = Arrays.copyOf(bytes, newlength);
  }
1058308
private void setBitsImpl(int position, long value, int length) {
		int i = position >> ADDRESS_BITS;
		int s = position & ADDRESS_MASK;
		long m = length == ADDRESS_SIZE ? -1L : (1L << length) - 1L;
		long v = value & m;
		performAdjSet(length, i, s, m, v);
	}
950649
def add_space(address, size)
      if size <= 0
        PEROBS.log.fatal "Size (#{size}) must be larger than 0."
      end
      # The following check is fairly costly and should never trigger unless
      # there is a bug in the PEROBS code. Only use this for debugging.
      #if has_space?(address, size)
      #  PEROBS.log.fatal "The space with address #{address} and size " +
      #    "#{size} can't be added twice."
      #end
      root.add_space(address, size)
    end
1269678
function(r, ptr, chr, len) {
        var i;
        for (i=0;i<len;i++) {
            r[ptr+i] = chr;
        }
    }
704787
def address_by_name(parent_id, name)
      body = self.gov_talk_request({
        service: 'AddrFindeAddressByNameParameter',
        message: 'CRA_AddrFindeAddressByName',
        class:   'CRA_AddrFindeAddressByName',
        params: {
          Id: parent_id,
          Word: name,
        }
      })
      CRA::Address.list_from_hash(body['ArrayOfResults']['Results'])
    end
166512
public void setSize(DBIDRef id, int size) {
    if(csize == null) {
      csize = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1);
    }
    csize.putInt(id, size);
  }
3943
function(size){
  this.data = [];
  if(typeof size === 'undefined'){
    return; // Empty instance of a bit array
  }
  if(typeof size !== 'number'){
    size = shred(size);
  }
  for(var i=0; i<Math.ceil(size/INTEGER_SIZE); ++i){
    this.data.push(0);
  }
}
442378
function (address, cb) {
          setupMultiserver()
          ms_client.client(coearseAddress(address), function (err, stream) {
            return err ? cb(err) : cb(null, setupRPC(stream, null, true))
          })
        }
137816
public static void setCacheSize(int size) {
        if (size > 3276700) size = 3276700;
        if (size <= byteCacheSize) return;
        byte[][] tmpCache = new byte[size][];
        System.arraycopy(byteCache, 0, tmpCache, 0, byteCacheSize);
        byteCache = tmpCache;
        byteCacheSize = size;
    }
1013825
def mark_address(self, addr, size):
        """"""
        i = 0
        while i < size:
            self._register_map[addr] = True
            i += 1
479079
function(address, value) {
        var columnModel = this.columnModel.getColumnModel(address.columnName);

        if (_.isString(value)) {
            value = $.trim(value);
        }
        if (columnModel.validation && columnModel.validation.dataType === 'number') {
            value = convertToNumber(value);
        }
        if (columnModel.name === '_button') {
            if (value) {
                this.dataModel.check(address.rowKey);
            } else {
                this.dataModel.uncheck(address.rowKey);
            }
        } else {
            this.dataModel.setValue(address.rowKey, address.columnName, value);
        }
    }
488145
function( address, value ) {
		if ( address & 0x8000 ) {
			this.writeRegister( address, value );
		} else if ( address >= 0x6000 ) {
			// writing RAM
			this.ramData[ address - 0x6000 ] = value;
		}

		return;
	}
1095068
function mkScriptHashReplayScript(address) {
  var addrHex = bs58check.decode(address).toString('hex');
  var subAddrHex = addrHex.substring(4, addrHex.length); // Cut out the '00' (we also only want 14 bytes instead of 16)



  // '14' is the length of the subAddrHex (in bytes)
return zopcodes.OP_DUP + zopcodes.OP_HASH160 + zbufferutils.getStringBufferLength(subAddrHex) + subAddrHex + zopcodes.OP_EQUALVERIFY + zopcodes.OP_CHECKSIG;

}