*/
    public void align(final int mask) throws IOException {
        final int position = this.size - this.dis.available();
        final int shift = position & mask - 1;
        if (mask != 0 && shift != 0) {
            this.dis.skip(mask - shift);
        }
    }

    /**
     * Returns the number of bytes available to read.
     * @return the number of available bytes

@REM POM location, if supplied.

set FILE_ARG=
:arg_loop
if "%~1" == "-f" (
  set "FILE_ARG=%~2"
  shift
  goto process_file_arg
)
if "%~1" == "--file" (
  set "FILE_ARG=%~2"
  shift
  goto process_file_arg
)
@REM If none of the above, skip the argument
shift
if not "%~1" == "" (
  goto arg_loop
) else (
  goto findBaseDir
)

:process_file_arg

      if (child == null) {
        child = Node()
        children[childIndex] = child
      }
      node = child
    }

    val shift = 8 - accumulatorBitCount
    val start = (code shl shift) and 0xff
    val end = 1 shl shift
    node.children!!.fill(terminal, start, start + end)
  }

  private class Node {
    /** Null if terminal. */
    val children: Array<Node?>?

            ret.append(Hexdump.toHexString(this.identifier_authority, 0, 6));
        } else {
            long shift = 0;
            long id = 0;
            for (int i = 5; i > 1; i--) {
                id += (this.identifier_authority[i] & 0xFFL) << shift;
                shift += 8;
            }
            ret.append(id);
        }

        for (int i = 0; i < this.sub_authority_count; i++) {

#
# Options:
#   -e: stop at first failure

if [ ! -f run.bash ]; then
	echo 'buildall.bash must be run from $GOROOT/src' 1>&2
	exit 1
fi

sete=false
if [ "$1" = "-e" ]; then
	sete=true
	shift
fi

if [ "$sete" = true ]; then
	set -e
fi

pattern="$1"
if [ "$pattern" = "" ]; then
	pattern=.
fi

./make.bash || exit 1
GOROOT="$(cd .. && pwd)"

gettargets() {

        var result = prefixMask
        var shift = 0
        while (true) {
          val b = readByte()
          if (b and 0x80 != 0) { // Equivalent to (b >= 128) since b is in [0..255].
            result += b and 0x7f shl shift
            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result

t.Run(fmt.Sprint(shift-1), func(t *testing.T) { testShift(t, shift-1) }) t.Run(fmt.Sprint(shift), func(t *testing.T) { testShift(t, shift) }) t.Run(fmt.Sprint(shift+1), func(t *testing.T) { testShift(t, shift+1) }) } } func natBytes(n *Nat) []byte { return n.Bytes(maxModulus(uint(len(n.limbs)))) } func natFromBytes(b []byte) *Nat { // Must not use Nat.SetBytes as it's used in TestSetBytes. bb := new(big.Int).SetBytes(b) return NewNat().setBig(bb) } func modulusFromBytes(b []byte) *Modulus { bb := new(big.Int).SetBytes(b)...

    long result = 0;
    // Due to the way we shift, we can stop iterating once we've run out of data, the rest
    // of the result already being filled with zeros.

    // This loop is critical to performance, so please check HashBenchmark if altering it.
    int limit = min(length, 8);
    for (int i = 0; i < limit; i++) {
      // Shift value left while iterating logically through the array.

	{"$1000000000", "$1000000000"},
	{"$__tsan_func_enter(SB)", "$__tsan_func_enter(SB)"},
	{"$main(SB)", "$main(SB)"},
	{"$masks<>(SB)", "$masks<>(SB)"},
	{"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
	{"$shifts<>(SB)", "$shifts<>(SB)"},
	{"$~(1<<63)", "$9223372036854775807"},
	{"$~0x3F", "$-64"},
	{"$~15", "$-16"},
	{"(((8)&0xf)*4)(SP)", "32(SP)"},
	{"(((8-14)&0xf)*4)(SP)", "40(SP)"},
	{"(6+8)(AX)", "14(AX)"},

set -e

if [ "$GOOS" = "" -o "$GOARCH" = "" ]; then
	echo "usage: GOOS=os GOARCH=arch ./bootstrap.bash [-force]" >&2
	exit 2
fi

forceflag=""
if [ "$1" = "-force" ]; then
	forceflag=-force
	shift
fi

targ="../../go-${GOOS}-${GOARCH}-bootstrap"
if [ -e $targ ]; then
	echo "$targ already exists; remove before continuing"
	exit 2
fi

unset GOROOT
src=$(cd .. && pwd)
echo "#### Copying to $targ"