CODE128A or CODE128B
436505
function autoSelectFromAB(string, isA) {
	var ranges = isA ? A_CHARS : B_CHARS;
	var untilC = string.match(new RegExp('^(' + ranges + '+?)(([0-9]{2}){2,})([^0-9]|$)'));

	if (untilC) {
		return untilC[1] + String.fromCharCode(204) + autoSelectFromC(string.substring(untilC[1].length));
	}

	var chars = string.match(new RegExp('^' + ranges + '+'))[0];

	if (chars.length === string.length) {
		return string;
	}

	return chars + String.fromCharCode(isA ? 205 : 206) + autoSelectFromAB(string.substring(chars.length), !isA);
}
1281444
def readsleb128(buff):
    
    result = 0
    shift = 0

    for x in range(0, 5):
        cur = get_byte(buff)
        result |= (cur & 0x7f) << shift
        shift += 7

        if not cur & 0x80:
            bit_left = max(32 - shift, 0)
            result = result << bit_left
            if result > 0x7fffffff:
                result = (0x7fffffff & result) - 0x80000000
            result = result >> bit_left
            break

    return result
993300
def _get_decimal128(data, position, dummy0, dummy1, dummy2):
    """"""
    end = position + 16
    return Decimal128.from_bid(data[position:end]), end
563057
function MPR121(address, bus_number) {
	EventEmitter.call(this);

	this.address = address || MPR121_I2CADDR_DEFAULT;
	if (bus_number != undefined) {
		this.bus_number = bus_number;
	} else {
		this.bus_number = 1;
	}
}
793828
function write_ws_biff8(idx, opts, wb) {
	var ba = buf_array();
	var s = wb.SheetNames[idx], ws = wb.Sheets[s] || {};
	var _WB = ((wb||{}).Workbook||{});
	var _sheet = ((_WB.Sheets||[])[idx]||{});
	var dense = Array.isArray(ws);
	var b8 = opts.biff == 8;
	var ref, rr = "", cols = [];
	var range = safe_decode_range(ws['!ref'] || "A1");
	var MAX_ROWS = b8 ? 65536 : 16384;
	if(range.e.c > 0xFF || range.e.r >= MAX_ROWS) {
		if(opts.WTF) throw new Error("Range " + (ws['!ref'] || "A1") + " exceeds format limit A1:IV16384");
		range.e.c = Math.min(range.e.c, 0xFF);
		range.e.r = Math.min(range.e.c, MAX_ROWS-1);
	}

	write_biff_rec(ba, 0x0809, write_BOF(wb, 0x10, opts));
	/* ... */
	write_biff_rec(ba, "CalcMode", writeuint16(1));
	write_biff_rec(ba, "CalcCount", writeuint16(100));
	write_biff_rec(ba, "CalcRefMode", writebool(true));
	write_biff_rec(ba, "CalcIter", writebool(false));
	write_biff_rec(ba, "CalcDelta", write_Xnum(0.001));
	write_biff_rec(ba, "CalcSaveRecalc", writebool(true));
	write_biff_rec(ba, "PrintRowCol", writebool(false));
	write_biff_rec(ba, "PrintGrid", writebool(false));
	write_biff_rec(ba, "GridSet", writeuint16(1));
	write_biff_rec(ba, "Guts", write_Guts([0,0]));
	/* ... */
	write_biff_rec(ba, "HCenter", writebool(false));
	write_biff_rec(ba, "VCenter", writebool(false));
	/* ... */
	write_biff_rec(ba, 0x200, write_Dimensions(range, opts));
	/* ... */

	if(b8) ws['!links'] = [];
	for(var R = range.s.r; R <= range.e.r; ++R) {
		rr = encode_row(R);
		for(var C = range.s.c; C <= range.e.c; ++C) {
			if(R === range.s.r) cols[C] = encode_col(C);
			ref = cols[C] + rr;
			var cell = dense ? (ws[R]||[])[C] : ws[ref];
			if(!cell) continue;
			/* write cell */
			write_ws_biff8_cell(ba, cell, R, C, opts);
			if(b8 && cell.l) ws['!links'].push([ref, cell.l]);
		}
	}
	var cname = _sheet.CodeName || _sheet.name || s;
	/* ... */
	if(b8 && _WB.Views) write_biff_rec(ba, "Window2", write_Window2(_WB.Views[0]));
	/* ... */
	if(b8 && (ws['!merges']||[]).length) write_biff_rec(ba, "MergeCells", write_MergeCells(ws['!merges']));
	/* ... */
	if(b8) write_ws_biff8_hlinks(ba, ws);
	/* ... */
	write_biff_rec(ba, "CodeName", write_XLUnicodeString(cname, opts));
	/* ... */
	if(b8) write_FEAT(ba, ws);
	/* ... */
	write_biff_rec(ba, "EOF");
	return ba.end();
}
1200891
private function parseSignedInt8()
    {
        try {
            $result = \ord($this->buffer);

            if ($result & 0x80) {
                return $result - 0x100;
            }

            return $result;
        } finally {
            $this->buffer = mb_orig_substr($this->buffer, 1);
        }
    }
812481
public final void mT__136() throws RecognitionException {
        try {
            int _type = T__136;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // InternalSARL.g:122:8: ( 'try' )
            // InternalSARL.g:122:10: 'try'
            {
            match("try"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
446038
synchronized public BigInteger generateId128() {
        long timestamp = System.currentTimeMillis();
        long sequence = 0;
        boolean done = false;
        while (!done) {
            done = true;
            while (timestamp < lastTimestampMillisec.get()) {
                timestamp = waitTillNextMillisec(timestamp);
            }
            if (timestamp == lastTimestampMillisec.get()) {
                // increase sequence
                sequence = sequenceMillisec.incrementAndGet();
                if (sequence > MAX_SEQUENCE_128) {
                    // reset sequence
                    sequenceMillisec.set(sequence = 0);
                    timestamp = waitTillNextMillisec(timestamp);
                    done = false;
                }
            }
        }
        sequenceMillisec.set(sequence);
        lastTimestampMillisec.set(timestamp);
        BigInteger biSequence = BigInteger.valueOf(sequence & MASK_SEQUENCE_128);
        BigInteger biResult = BigInteger.valueOf(timestamp);
        biResult = biResult.shiftLeft((int) SHIFT_TIMESTAMP_128);
        biResult = biResult.or(template128).or(biSequence);
        return biResult;
    }
596824
@TCB
  private static int longestPrefixOfGoodCodeunits(String s) {
    int n = s.length(), i;
    for (i = 0; i < n; ++i) {
      char ch = s.charAt(i);
      if (ch < 0x20) {
        if (IS_BANNED_ASCII[ch]) {
          return i;
        }
      } else if (0xd800 <= ch) {
        if (ch <= 0xdfff) {
          if (i+1 < n && Character.isSurrogatePair(ch, s.charAt(i+1))) {
            ++i;  // Skip over low surrogate since we know it's ok.
          } else {
            return i;
          }
        } else if ((ch & 0xfffe) == 0xfffe) {
          return i;
        }
      }
    }
    return -1;
  }
1077292
def leb128_encode(value):
        
        if value == 0:
            return b'\x00'

        result = []
        while value != 0:
            byte = value & 0x7f
            value >>= 7
            if value != 0:
                byte |= 0x80
            result.append(byte)

        return bytes(result)
1194387
def _not8(ins):
    
    output = _8bit_oper(ins.quad[2])
    output.append('sub 1')  # Gives carry only if A = 0
    output.append('sbc a, a')  # Gives FF only if Carry else 0
    output.append('push af')

    return output
804761
private static boolean isLegalNameByte(byte b) {
		if(b > 31) {
			if(b < 128) {
				return b == SP ? false : b != COLON;
			}
		}
		return false;
	}
999898
def leb128_decode(data):
        
        result = 0
        shift = 0

        while True:
            character = data.read(1)
            if len(character) == 0:
                raise bitcoin.core.SerializationTruncationError('Invalid LEB128 integer')

            b = ord(character)
            result |= (b & 0x7f) << shift
            if b & 0x80 == 0:
                break
            shift += 7
        return result
742518
def _write8(self, reg, value):
        """"""
        self.i2c.write8(TCS34725_COMMAND_BIT | reg, value)
63167
public static String getXAExceptionCodeString(int code) {

        // Note, two cases are commented out below.  This is because in the implementation of
        // XAException, they have defined two constants to be the same int (or so it would
        // seem).

        // This is because XA_RBBASE and XA_RBEND define the lower and upper bounds of the
        // XA_RB error codes.  These two are correctly commented out below.

        switch (code) {
            case XAException.XA_RBTRANSIENT:
                return "XA_RBTRANSIENT (" + code + ')'; 
            case XAException.XA_RBROLLBACK:
                return "XA_RBROLLBACK (" + code + ')'; 
            case XAException.XA_HEURCOM:
                return "XA_HEURCOM (" + code + ')'; 
            case XAException.XA_HEURHAZ:
                return "XA_HEURHAZ (" + code + ')'; 
            case XAException.XA_HEURMIX:
                return "XA_HEURMIX (" + code + ')'; 
            case XAException.XA_HEURRB:
                return "XA_HEURRB (" + code + ')'; 
            case XAException.XA_NOMIGRATE:
                return "XA_NOMIGRATE (" + code + ')'; 
                //case XAException.XA_RBBASE:
                //    return "XA_RBBASE (" + code + ')'; 
            case XAException.XA_RBCOMMFAIL:
                return "XA_RBCOMMFAIL (" + code + ')'; 
            case XAException.XA_RBDEADLOCK:
                return "XA_RBDEADLOCK (" + code + ')'; 
                //case XAException.XA_RBEND:
                //    return "XA_RBEND (" + code + ')'; 
            case XAException.XA_RBINTEGRITY:
                return "XA_RBINTEGRITY (" + code + ')'; 
            case XAException.XA_RBOTHER:
                return "XA_RBOTHER (" + code + ')'; 
            case XAException.XA_RBPROTO:
                return "XA_RBPROTO (" + code + ')'; 
            case XAException.XA_RBTIMEOUT:
                return "XA_RBTIMEOUT (" + code + ')'; 
            case XAException.XA_RDONLY:
                return "XA_RDONLY (" + code + ')'; 
            case XAException.XA_RETRY:
                return "XA_RETRY (" + code + ')'; 
            case XAException.XAER_ASYNC:
                return "XAER_ASYNC (" + code + ')'; 
            case XAException.XAER_DUPID:
                return "XAER_DUPID (" + code + ')'; 
            case XAException.XAER_INVAL:
                return "XAER_INVAL (" + code + ')'; 
            case XAException.XAER_NOTA:
                return "XAER_NOTA (" + code + ')'; 
            case XAException.XAER_OUTSIDE:
                return "XAER_OUTSIDE (" + code + ')'; 
            case XAException.XAER_PROTO:
                return "XAER_PROTO (" + code + ')'; 
            case XAException.XAER_RMERR:
                return "XAER_RMERR (" + code + ')'; 
            case XAException.XAER_RMFAIL:
                return "XAER_RMFAIL (" + code + ')'; 

        }
        return "UNKNOWN XA EXCEPTION CODE (" + code + ')'; 
    }
625490
private int bytesNetworkOrder2Number(byte[] bytesInNetworkOrder) {
    int sourceNumber = 0;
    for (int i = 0; i < 4; i++) {
      sourceNumber <<= 8;
      sourceNumber |= bytesInNetworkOrder[i] & 0xff;
    }
    return sourceNumber;
  }
1309875
public final String formatE123International(final String pphoneNumber,
      final String pcountryCode) {
    return this.formatE123International(this.parsePhoneNumber(pphoneNumber, pcountryCode));
  }