for (byte value : VALUES) {
      assertThat(SignedBytes.saturatedCast((long) value)).isEqualTo(value);
    }
    assertThat(SignedBytes.saturatedCast(GREATEST + 1L)).isEqualTo(GREATEST);
    assertThat(SignedBytes.saturatedCast(LEAST - 1L)).isEqualTo(LEAST);
    assertThat(SignedBytes.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(SignedBytes.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

    for (byte value : VALUES) {
      assertThat(SignedBytes.saturatedCast((long) value)).isEqualTo(value);
    }
    assertThat(SignedBytes.saturatedCast(GREATEST + 1L)).isEqualTo(GREATEST);
    assertThat(SignedBytes.saturatedCast(LEAST - 1L)).isEqualTo(LEAST);
    assertThat(SignedBytes.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(SignedBytes.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

    for (char value : VALUES) {
      assertThat(Chars.saturatedCast((long) value)).isEqualTo(value);
    }
    assertThat(Chars.saturatedCast(GREATEST + 1L)).isEqualTo(GREATEST);
    assertThat(Chars.saturatedCast(LEAST - 1L)).isEqualTo(LEAST);
    assertThat(Chars.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(Chars.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

    for (int value : VALUES) {
      assertThat(Ints.saturatedCast((long) value)).isEqualTo(value);
    }
    assertThat(Ints.saturatedCast(GREATEST + 1L)).isEqualTo(GREATEST);
    assertThat(Ints.saturatedCast(LEAST - 1L)).isEqualTo(LEAST);
    assertThat(Ints.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(Ints.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

            b,
            "s*",
            saturatedCast(valueOf(a).multiply(valueOf(b))),
            IntMath.saturatedMultiply(a, b));
      }
    }
  }

  @GwtIncompatible // TODO
  public void testSaturatedPow() {
    for (int a : ALL_INTEGER_CANDIDATES) {
      for (int b : EXPONENTS) {
        assertOperationEquals(
            a, b, "s^", saturatedCast(valueOf(a).pow(b)), IntMath.saturatedPow(a, b));
      }

  @Override
  Entry<E> getEntry(int index) {
    return entries.get(index);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

  // redeclare to help optimizers with b/310253115
  @SuppressWarnings("RedundantOverride")
  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {

            b,
            "s*",
            saturatedCast(valueOf(a).multiply(valueOf(b))),
            LongMath.saturatedMultiply(a, b));
      }
    }
  }

  @GwtIncompatible // TODO
  public void testSaturatedPow() {
    for (long a : ALL_LONG_CANDIDATES) {
      for (int b : EXPONENTS) {
        assertOperationEquals(
            a, b, "s^", saturatedCast(valueOf(a).pow(b)), LongMath.saturatedPow(a, b));
      }

    for (short value : VALUES) {
      assertThat(Shorts.saturatedCast((long) value)).isEqualTo(value);
    }
    assertThat(Shorts.saturatedCast(GREATEST + 1L)).isEqualTo(GREATEST);
    assertThat(Shorts.saturatedCast(LEAST - 1L)).isEqualTo(LEAST);
    assertThat(Shorts.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(Shorts.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

    this.contents = contents;
    long size = 0;
    for (int i = 0; i < contents.size(); i++) {
      size += contents.getValue(i);
    }
    this.size = Ints.saturatedCast(size);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public int count(@Nullable Object element) {
    return contents.get(element);
  }

  @Override

    return (index >= 0) ? getCount(index) : 0;
  }

  @Override
  public int size() {
    long size = cumulativeCounts[offset + length] - cumulativeCounts[offset];
    return Ints.saturatedCast(size);
  }

  @Override
  public ImmutableSortedSet<E> elementSet() {
    return elementSet;
  }

  @Override
  public ImmutableSortedMultiset<E> headMultiset(E upperBound, BoundType boundType) {