MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25

	want complex128
}{
	// Derived from Sin(z) = -i * Sinh(i * z), G.6 #7
	{complex(zero, zero),
		complex(zero, zero)},
	{complex(zero, inf),
		complex(zero, inf)},
	{complex(zero, nan),
		complex(zero, nan)},
	{complex(1.0, inf),
		complex(inf, inf)},
	{complex(1.0, nan),
		NaN()},
	{complex(inf, zero),
		complex(nan, zero)},
	{complex(inf, 1.0),
		NaN()},
	{complex(inf, inf),
		complex(nan, inf)},

   * first decrementing to zero, and then removing. putIfAbsent or replace could observe the
   * intermediate zero-state. Ways we could deal with this are:
   *
   * - Don't define any of the ConcurrentMap operations. This is the current state of affairs.
   *
   * - Define putIfAbsent and replace as treating zero and absent identically (as currently

  }

  // retainAll(empty)

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRetainAll_emptyPreviouslyEmpty() {
    expectReturnsFalse(empty);
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRetainAll_emptyPreviouslyEmptyUnsupported() {
    expectReturnsFalseOrThrows(empty);

  }

  // retainAll(empty)

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRetainAll_emptyPreviouslyEmpty() {
    expectReturnsFalse(empty);
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRetainAll_emptyPreviouslyEmptyUnsupported() {
    expectReturnsFalseOrThrows(empty);

        !expired.mustCheck
        expired.keepFor == Duration.ZERO

        def notExpired = cachePolicy.versionListExpiry(moduleIdentifier, versions, Duration.ofMillis(2 * SECOND))
        !notExpired.mustCheck
        notExpired.keepFor == Duration.ofMillis(DAY - 2 * SECOND)

        def thisBuild = cachePolicy.versionListExpiry(moduleIdentifier, versions, Duration.ZERO)
        !thisBuild.mustCheck

	LXVD2X (HTBL)(R0), VH // Load H

	VSPLTISB $-16, XC2           // 0xf0
	VSPLTISB $1, T0              // one
	VADDUBM  XC2, XC2, XC2       // 0xe0
	VXOR     ZERO, ZERO, ZERO
	VOR      XC2, T0, XC2        // 0xe1
	VSLDOI   $15, XC2, ZERO, XC2 // 0xe1...
	VSLDOI   $1, ZERO, T0, T1    // ...1
	VADDUBM  XC2, XC2, XC2       // 0xc2...
	VSPLTISB $7, T2
	VOR      XC2, T1, XC2        // 0xc2....01

		at := Integ(zero, MonSubst(Ones, neg(one), 2))
		for c, i := 1, 0; i < N; i++ {
			if i%2 == 0 {
				a[i] = zero
			} else {
				a[i] = i2tor(int64(c), int64(i))
				c *= -1
			}
		}
		checka(at, a, "ATan") // 0 -1 0 -1/3 0 -1/5
		/*
			t := Revert(Integ(zero, MonSubst(Ones, neg(one), 2)))
			a[0] = zero
			a[1] = itor(1)
			a[2] = zero
			a[3] = i2tor(1,3)
			a[4] = zero

 * is {@code addAndGet(K, long)}, which adds a {@code long} to the value currently associated with
 * {@code K}. If a key has not yet been associated with a value, its implicit value is zero.
 *
 * <p>Most methods in this class treat absent values and zero values identically, as individually
 * documented. Exceptions to this are {@link #containsKey}, {@link #size}, {@link #isEmpty}, {@link
 * #asMap}, and {@link #toString}.
 *

  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSetCount_oneToOne_addSupported() {
    assertOneToOne();
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testSetCount_oneToOne_removeSupported() {
    assertOneToOne();
  }

  @CollectionSize.Require(absent = ZERO)