long bHi = b >>> 32; // < 2^31
        long aLo = a & 0xFFFFFFFFL; // < 2^32
        long bLo = b & 0xFFFFFFFFL; // < 2^32

        /*
         * a * b == aHi * bHi * 2^64 + (aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo.
         *       == (aHi * bHi * 2^32 + aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo
         *

pkg syscall (openbsd-386), const SIOCBRDGGPARAM = 3224922456
pkg syscall (openbsd-386), const SIOCBRDGSADDR = 3223873860
pkg syscall (openbsd-386), const SYS_CLOCK_GETRES = 234
pkg syscall (openbsd-386), const SYS_CLOCK_GETTIME = 232
pkg syscall (openbsd-386), const SYS_CLOCK_SETTIME = 233
pkg syscall (openbsd-386), const SYS_FHSTATFS = 309
pkg syscall (openbsd-386), const SYS_FSTAT = 292
pkg syscall (openbsd-386), const SYS_FSTATAT = 316

        void testValueConsistency() {
            // Given: Same input value
            int inputValue = 1000;
            int expectedMasked = inputValue & 0xFF; // 232

            // When: Creating multiple NdrShort instances
            NdrShort ndrShort1 = new NdrShort(inputValue);
            NdrShort ndrShort2 = new NdrShort(inputValue);

import java.util.Comparator;

/**
 * Static utility methods pertaining to {@code int} primitives that interpret values as
 * <i>unsigned</i> (that is, any negative value {@code x} is treated as the positive value {@code
 * 2^32 + x}). The methods for which signedness is not an issue are in {@link Ints}, as well as
 * signed versions of methods for which signedness is an issue.
 *

    rangeMap.putCoalescing(Range.closedOpen(0, 1), 1);
    rangeMap.putCoalescing(Range.closedOpen(1, 2), 1);
    rangeMap.putCoalescing(Range.closedOpen(2, 3), 2);
    assertEquals(
        ImmutableMap.of(Range.closedOpen(0, 2), 1, Range.closedOpen(2, 3), 2),
        rangeMap.asMapOfRanges());
  }

  public void testPutCoalescingEmpty() {
    RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create();

	_ = x[ErrHealAlreadyRunning-227]
	_ = x[ErrHealOverlappingPaths-228]
	_ = x[ErrIncorrectContinuationToken-229]
	_ = x[ErrEmptyRequestBody-230]
	_ = x[ErrUnsupportedFunction-231]
	_ = x[ErrInvalidExpressionType-232]
	_ = x[ErrBusy-233]
	_ = x[ErrUnauthorizedAccess-234]
	_ = x[ErrExpressionTooLong-235]
	_ = x[ErrIllegalSQLFunctionArgument-236]
	_ = x[ErrInvalidKeyPath-237]
	_ = x[ErrInvalidCompressionFormat-238]

pkg maps, func Copy[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 interface{}]($0, $1) #57436
pkg maps, func DeleteFunc[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, func($1, $2) bool) #57436
pkg maps, func Equal[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 comparable]($0, $1) bool #57436

    cache.put(6, 2);
    cache.put(98, 45);
    cache.put(56, 76);
    cache.put(23, 84);

    // Replace the two present elements.
    cache.put(23, 20);
    cache.put(56, 49);
    cache.put(23, 2);
    cache.put(56, 4);

    // Expire the two present elements.
    fakeTicker.advance(1001, MILLISECONDS);

    cache.getIfPresent(23);
    cache.getIfPresent(56);

        return sqrtFloor;
      case CEILING:
      case UP:
        int sqrtFloorInt = sqrtFloor.intValue();
        boolean sqrtFloorIsExact =
            (sqrtFloorInt * sqrtFloorInt == x.intValue()) // fast check mod 2^32
                && sqrtFloor.pow(2).equals(x); // slow exact check
        return sqrtFloorIsExact ? sqrtFloor : sqrtFloor.add(BigInteger.ONE);
      case HALF_DOWN:
      case HALF_UP:
      case HALF_EVEN:

    }
  }

  @Test fun goAwayWithoutDebugDataRoundTrip() {
    val expectedError = ErrorCode.PROTOCOL_ERROR
    writeMedium(frame, 8) // Without debug data there's only 2 32-bit fields.
    frame.writeByte(TYPE_GOAWAY)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0) // connection-scope
    frame.writeInt(expectedStreamId) // last good stream.
    frame.writeInt(expectedError.httpCode)