public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

        assertVersionOlder("1.0-SNAPSHOT-SNAPSHOT", "1.0-SNAPSHOT");
        assertVersionOlder("1.0-alpha-1-SNAPSHOT-SNAPSHOT", "1.0-alpha-1-SNAPSHOT");

        assertVersionOlder("1.0-SNAPSHOT", "1.0-1-SNAPSHOT");
        assertVersionOlder("1.0-1-SNAPSHOT", "1.0-2-SNAPSHOT");
        // assertVersionEqual( "2.0-0-SNAPSHOT", "2.0-SNAPSHOT" );
        assertVersionOlder("2.0-SNAPSHOT", "2.0-1-SNAPSHOT");

  @Test
  fun sameKeypairSamePin() {
    val heldCertificateA2 =
      HeldCertificate
        .Builder()
        .keyPair(certA1.keyPair)
        .serialNumber(101L)
        .build()
    val keypairACertificate2Pin = pin(heldCertificateA2.certificate)
    val heldCertificateB2 =
      HeldCertificate
        .Builder()
        .keyPair(certB1.keyPair)
        .serialNumber(201L)

    // separate above
    expected =
        assertThrows(
            IllegalArgumentException.class, () -> range.intersection(Range.closed(10, 12)));
    assertThat(expected).hasMessageThat().contains("connected");
  }

  public void testGap_overlapping() {
    Range<Integer> range = Range.closedOpen(3, 5);

   * (10, ∞) => "baz"} then {@code rangeMap.subRangeMap(Range.open(3, 12))} would return a range map
   * with the entries {@code (3, 5] => "foo", (6, 8) => "bar", (10, 12) => "baz"}.
   *
   * <p>The returned range map supports all optional operations that this range map supports, except
   * for {@code asMapOfRanges().iterator().remove()}.
   *

    where an integer (but not int typed) is used. Encoding this as a float
    results in failed round-tripping between encode and parse.
    Our Id type is a prime example of this.

    >>> decimal_encoder(Decimal("1.0"))
    1.0

    >>> decimal_encoder(Decimal("1"))
    1

    >>> decimal_encoder(Decimal("NaN"))
    nan
    """
    exponent = dec_value.as_tuple().exponent
    if isinstance(exponent, int) and exponent >= 0:

   * (10, ∞) => "baz"} then {@code rangeMap.subRangeMap(Range.open(3, 12))} would return a range map
   * with the entries {@code (3, 5] => "foo", (6, 8) => "bar", (10, 12) => "baz"}.
   *
   * <p>The returned range map supports all optional operations that this range map supports, except
   * for {@code asMapOfRanges().iterator().remove()}.
   *

common:release_macos_x86 --config=avx_linux
common:release_macos_x86 --cpu=darwin
# Target Catalina as the minimum compatible OS version
common:release_macos_x86 --macos_minimum_os=10.15
common:release_macos_x86 --action_env MACOSX_DEPLOYMENT_TARGET=10.15

# Build configs for macOS Arm64
common:release_macos_arm64 --config=release_macos_base
common:release_macos_arm64 --cpu=darwin_arm64

p256const0<>(SB), const0 MOVD p256const1<>(SB), const1 LDP 0*16(a_ptr), (x0, x1) LDP 1*16(a_ptr), (x2, x3) LDP 0*16(b_ptr), (y0, y1) LDP 1*16(b_ptr), (y2, y3) CALL p256MulInternal<>(SB) STP (y0, y1), 0*16(res_ptr) STP (y2, y3), 1*16(res_ptr) RET /* ---------- // func p256FromMont(res, in *p256Element) TEXT ·p256FromMont(SB),NOSPLIT,$0 MOVD res+0(FP), res_ptr MOVD in+8(FP), a_ptr MOVD p256const0<>(SB), const0 MOVD p256const1<>(SB), const1 LDP 0*16(a_ptr), (acc0, acc1) LDP 1*16(a_ptr), (acc2, acc3) // Only...

	hammerRWMutex(t, 1, 1, n)
	hammerRWMutex(t, 1, 3, n)
	hammerRWMutex(t, 1, 10, n)
	hammerRWMutex(t, 4, 1, n)
	hammerRWMutex(t, 4, 3, n)
	hammerRWMutex(t, 4, 10, n)
	hammerRWMutex(t, 10, 1, n)
	hammerRWMutex(t, 10, 3, n)
	hammerRWMutex(t, 10, 10, n)
	hammerRWMutex(t, 10, 5, n)
}

// Borrowed from rwmutex_test.go
func TestUnlockPanic(t *testing.T) {
	defer func() {
		if recover() == nil {