for (float x : VALUES) {
      for (float y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Floats.compare(x, y))
            .isEqualTo(Float.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Floats.contains(EMPTY, (float) 1)).isFalse();
    assertThat(Floats.contains(ARRAY1, (float) 2)).isFalse();

    for (long x : VALUES) {
      for (long y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Longs.compare(x, y))
            .isEqualTo(Long.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Longs.contains(EMPTY, (long) 1)).isFalse();
    assertThat(Longs.contains(ARRAY1, (long) 2)).isFalse();

HSPLokio/ByteString$Companion;->encodeUtf8(Ljava/lang/String;)Lokio/ByteString;
HSPLokio/ByteString;-><clinit>()V
HSPLokio/ByteString;-><init>([B)V
HSPLokio/ByteString;->compareTo(Ljava/lang/Object;)I
HSPLokio/ByteString;->compareTo(Lokio/ByteString;)I
HSPLokio/ByteString;->equals(Ljava/lang/Object;)Z
HSPLokio/ByteString;->getSize$okio()I
HSPLokio/ByteString;->hashCode()I

		oVer := oVers.versions[i]
		if eVer.header != oVer.header {
			if eVer.header.hasEC() != oVer.header.hasEC() {
				// One version has EC and the other doesn't - may have been written later.
				// Compare without considering EC.
				a, b := eVer.header, oVer.header
				a.EcN, a.EcM = 0, 0
				b.EcN, b.EcM = 0, 0
				if a == b {
					continue
				}
			}

pkg go/constant, func BinaryOp(Value, token.Token, Value) Value
pkg go/constant, func BitLen(Value) int
pkg go/constant, func BoolVal(Value) bool
pkg go/constant, func Bytes(Value) []uint8
pkg go/constant, func Compare(Value, token.Token, Value) bool
pkg go/constant, func Denom(Value) Value
pkg go/constant, func Float32Val(Value) (float32, bool)
pkg go/constant, func Float64Val(Value) (float64, bool)
pkg go/constant, func Imag(Value) Value

      Predicate<? super K> keyPredicate) {
    return compose(keyPredicate, Maps.<K>keyFunction());
  }

  static <V extends @Nullable Object> Predicate<Entry<?, V>> valuePredicateOnEntries(
      Predicate<? super V> valuePredicate) {
    return compose(valuePredicate, Maps.<V>valueFunction());
  }

  /**

      Predicate<? super K> keyPredicate) {
    return compose(keyPredicate, Maps.<K>keyFunction());
  }

  static <V extends @Nullable Object> Predicate<Entry<?, V>> valuePredicateOnEntries(
      Predicate<? super V> valuePredicate) {
    return compose(valuePredicate, Maps.<V>valueFunction());
  }

  /**

    assertEquals(liveCount, countLiveEntries(map));
    ImmutableMap<Object, Object> originalMap = ImmutableMap.copyOf(map);
    assertEquals(liveCount, originalMap.size());
    // can't compare map contents until cleanup occurs

    for (int i = 1; i <= originalCount * 2; i *= 2) {
      if (i > 1) {
        // TODO(b/145386688): This access should be guarded by 'segment', which is not currently
        // held

    assertEquals(liveCount, countLiveEntries(map));
    ImmutableMap<Object, Object> originalMap = ImmutableMap.copyOf(map);
    assertEquals(liveCount, originalMap.size());
    // can't compare map contents until cleanup occurs

    for (int i = 1; i <= originalCount * 2; i *= 2) {
      if (i > 1) {
        // TODO(b/145386688): This access should be guarded by 'segment', which is not currently
        // held

	b.buf[b.n] = c
	b.n++
	return nil
}

// WriteRune writes a single Unicode code point, returning
// the number of bytes written and any error.
func (b *Writer) WriteRune(r rune) (size int, err error) {
	// Compare as uint32 to correctly handle negative runes.
	if uint32(r) < utf8.RuneSelf {
		err = b.WriteByte(byte(r))
		if err != nil {
			return 0, err
		}
		return 1, nil
	}
	if b.err != nil {