@Override
    protected SortedSet<Integer> create(Integer[] elements) {
      return checkedCreate(nullCheckedTreeSet(elements));
    }
  }

  public static class ContiguousSetHeadsetGenerator extends AbstractContiguousSetGenerator {
    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      SortedSet<Integer> set = nullCheckedTreeSet(elements);

  }

  AbstractSortedMultiset(Comparator<? super E> comparator) {
    this.comparator = checkNotNull(comparator);
  }

  @Override
  public SortedSet<E> elementSet() {
    return (SortedSet<E>) super.elementSet();
  }

  @Override
  SortedSet<E> createElementSet() {
    return new SortedMultisets.ElementSet<E>(this);
  }

  @Override
  public Comparator<? super E> comparator() {
    return comparator;

    SortedSet<String> set = of("e", "a", "f", "b", "d", "c");
    SortedSet<String> subset = set.subSet("c", "e");
    SortedSet<String> copy = copyOf(subset);
    assertEquals(subset, copy);
  }

  public void testCopyOf_headSet() {
    SortedSet<String> set = of("e", "a", "f", "b", "d", "c");
    SortedSet<String> headset = set.headSet("d");
    SortedSet<String> copy = copyOf(headset);
    assertEquals(headset, copy);
  }

    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      return checkedCreate(nullCheckedTreeSet(elements));
    }
  }

  public static class ContiguousSetHeadsetGenerator extends AbstractContiguousSetGenerator {
    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      SortedSet<Integer> set = nullCheckedTreeSet(elements);

  }

  private static boolean hasSameComparator(Iterable<?> elements, Comparator<?> comparator) {
    if (elements instanceof SortedSet) {
      SortedSet<?> sortedSet = (SortedSet<?>) elements;
      Comparator<?> comparator2 = sortedSet.comparator();
      return (comparator2 == null)
          ? comparator == Ordering.natural()
          : comparator.equals(comparator2);
    }
    return false;
  }

  }

  public static class Strings extends SampleElements<String> {
    public Strings() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super("b", "a", "c", "d", "e");
    }

    // for testing SortedSet and SortedMap methods
    public static final String BEFORE_FIRST = "\0";
    public static final String BEFORE_FIRST_2 = "\0\0";

        }
      }
    }

  private suspend fun readImportResults(): ImportResults =
    withContext(Dispatchers.IO) {
      val sortedRules: SortedSet<ByteString> = TreeSet()
      val sortedExceptionRules: SortedSet<ByteString> = TreeSet()
      var totalRuleBytes = 0
      var totalExceptionRuleBytes = 0

      fileSystem.source(publicSuffixListDotDat).buffer().use { source ->

    ms.add("a", 1);
    ms.add("b", 3);
    ms.add("c", 2);
    ms.add("d", 1);
    ms.add("e", 3);
    ms.add("f", 2);

    SortedSet<String> elementSet = ms.elementSet();
    assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder();
    SortedSet<String> subset = elementSet.subSet("b", "f");
    assertThat(subset).containsExactly("b", "c", "d", "e").inOrder();

    assertTrue(subset.remove("c"));

      return multiset().comparator();
    }

    @Override
    public SortedSet<E> subSet(@ParametricNullness E fromElement, @ParametricNullness E toElement) {
      return multiset().subMultiset(fromElement, CLOSED, toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> headSet(@ParametricNullness E toElement) {
      return multiset().headMultiset(toElement, OPEN).elementSet();
    }

  }

  public static class Strings extends SampleElements<String> {
    public Strings() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super("b", "a", "c", "d", "e");
    }

    // for testing SortedSet and SortedMap methods
    public static final String BEFORE_FIRST = "\0";
    public static final String BEFORE_FIRST_2 = "\0\0";