}
  }

  /**
   * A value class representing single connection between the origin node and another node.
   *
   * <p>There can be two types of connections (predecessor and successor), which is represented by
   * the two implementations.
   */
  private abstract static class NodeConnection<N> {
    final N node;

    NodeConnection(N node) {
      this.node = checkNotNull(node);
    }

   * point values. Two instances are guaranteed to be considered equal if one is copied from the
   * other using {@code second = new PairedStatsAccumulator().addAll(first).snapshot()}, if both
   * were obtained by calling {@code snapshot()} on the same {@link PairedStatsAccumulator} without
   * adding any values in between the two calls, or if one is obtained from the other after

@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class UnsignedBytes {
  private UnsignedBytes() {}

  /**
   * The largest power of two that can be represented as an unsigned {@code byte}.
   *
   * @since 10.0
   */
  public static final byte MAX_POWER_OF_TWO = (byte) 0x80;

  /**
   * The largest value that fits into an unsigned byte.
   *
   * @since 13.0
   */

    assertMultimapEquals(ImmutableSetMultimap.of("one", 1, "two", 2), "one", 1, "two", 2);
    assertMultimapEquals(
        ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3);
    assertMultimapEquals(
        ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3, "four", 4),
        "one",
        1,
        "two",
        2,
        "three",
        3,
        "four",

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    return ImmutableMap.of();
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    return ImmutableMap.of("one", 1, "two", 2, "three", 3);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

    extends AbstractImmutableMapMapInterfaceTest<String, Integer> {
  @Override
  protected Map<String, Integer> makePopulatedMap() {
    return SerializableTester.reserialize(ImmutableMap.of("one", 1, "two", 2, "three", 3));
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

    extends AbstractImmutableSortedMapMapInterfaceTest<String, Integer> {
  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    return SerializableTester.reserialize(ImmutableSortedMap.of("one", 1, "two", 2, "three", 3));
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

    super(allowsNulls, allowsNulls, false, modifiable, modifiable, supportsIteratorRemove);
  }

  protected void populate(Multimap<String, Integer> multimap) {
    multimap.put("one", 1);
    multimap.put("two", 2);
    multimap.put("two", 22);
    multimap.put("three", 3);
    multimap.put("three", 33);
    multimap.put("three", 333);
  }

  @Override
  protected String getKeyNotInPopulatedMap() throws UnsupportedOperationException {

     *
     * @throws IllegalArgumentException if any two keys are equal according to the comparator (which
     *     might be the keys' natural order)
     */
    @Override
    public ImmutableSortedMap<K, V> build() {
      return buildOrThrow();
    }

    /**
     * Returns a newly-created immutable sorted map, or throws an exception if any two keys are
     * equal.
     *

    throw new UnsupportedOperationException();
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return ArrayTable.create(
        Arrays.asList("one", "two", "three", "four"), Arrays.asList('a', 'b', 'c'));
  }