}

  @Override
  public int size() {
    return size;
  }

  @Override
  public ImmutableSet<E> elementSet() {
    ImmutableSet<E> result = elementSet;
    return (result == null) ? elementSet = new ElementSet() : result;
  }

  @WeakOuter
  private final class ElementSet extends IndexedImmutableSet<E> {

    @Override
    E get(int index) {
      return contents.getKey(index);
    }

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A {@link Multiset} which maintains the ordering of its elements, according to either their
 * natural order or an explicit {@link Comparator}. This order is reflected when iterating over the
 * sorted multiset, either directly, or through its {@code elementSet} or {@code entrySet} views. In
 * all cases, this implementation uses {@link Comparable#compareTo} or {@link Comparator#compare}

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A {@link Multiset} which maintains the ordering of its elements, according to either their
 * natural order or an explicit {@link Comparator}. This order is reflected when iterating over the
 * sorted multiset, either directly, or through its {@code elementSet} or {@code entrySet} views. In
 * all cases, this implementation uses {@link Comparable#compareTo} or {@link Comparator#compare}

)

func TestNewSet(t *testing.T) {
	elements := []string{"a", "b", "c"}
	set := New(elements...)

	if len(set) != len(elements) {
		t.Errorf("Expected length %d != %d", len(set), len(elements))
	}

	for _, e := range elements {
		if _, exist := set[e]; !exist {
			t.Errorf("%s is not in set %v", e, set)
		}
	}
}

func TestUnion(t *testing.T) {
	elements := []string{"a", "b", "c", "d"}

    this.length = 0;
  }

  RegularImmutableSortedMultiset(
      RegularImmutableSortedSet<E> elementSet, long[] cumulativeCounts, int offset, int length) {
    this.elementSet = elementSet;
    this.cumulativeCounts = cumulativeCounts;
    this.offset = offset;
    this.length = length;
  }

  private int getCount(int index) {
    return (int) (cumulativeCounts[offset + index + 1] - cumulativeCounts[offset + index]);
  }

    this.length = 0;
  }

  RegularImmutableSortedMultiset(
      RegularImmutableSortedSet<E> elementSet, long[] cumulativeCounts, int offset, int length) {
    this.elementSet = elementSet;
    this.cumulativeCounts = cumulativeCounts;
    this.offset = offset;
    this.length = length;
  }

  private int getCount(int index) {
    return (int) (cumulativeCounts[offset + index + 1] - cumulativeCounts[offset + index]);
  }

public class MultisetReadsTester<E> extends AbstractMultisetTester<E> {

  @CollectionSize.Require(absent = ZERO)
  public void testElementSet_contains() {
    assertTrue(
        "multiset.elementSet().contains(present) returned false",
        getMultiset().elementSet().contains(e0()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testEntrySet_contains() {
    assertTrue(
        "multiset.entrySet() didn't contain [present, 1]",

public class MultisetReadsTester<E> extends AbstractMultisetTester<E> {

  @CollectionSize.Require(absent = ZERO)
  public void testElementSet_contains() {
    assertTrue(
        "multiset.elementSet().contains(present) returned false",
        getMultiset().elementSet().contains(e0()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testEntrySet_contains() {
    assertTrue(
        "multiset.entrySet() didn't contain [present, 1]",

  Entry<E> pollFirstEntry();

  @CheckForNull
  Entry<E> pollLastEntry();

  /**
   * Returns a {@link SortedSet} view of the distinct elements in this multiset. (Outside GWT, this
   * returns a {@code NavigableSet}.)
   */
  @Override
  SortedSet<E> elementSet();

  SortedMultiset<E> descendingMultiset();

  SortedMultiset<E> headMultiset(E upperBound, BoundType boundType);

  SortedMultiset<E> subMultiset(

      }
    }
    return 0;
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  public ImmutableSet<E> elementSet() {
    ImmutableSet<E> result = elementSet;
    return (result == null) ? elementSet = new ElementSet<>(Arrays.asList(entries), this) : result;
  }

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

  @Override