extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

    Optional<@NonNull T> getOptional() {
      if (extras.isEmpty()) {

        }

        int toIndex = offset + size;
        if (toIndex > protwordsItemList.size()) {
            toIndex = protwordsItemList.size();
        }

        return new PagingList<>(protwordsItemList.subList(offset, toIndex), offset, size, protwordsItemList.size());
    }

    @Override
    public synchronized void insert(final ProtwordsItem item) {
        try (ProtwordsUpdater updater = new ProtwordsUpdater(item)) {

                            request.getPom()));
            int resumeFromProjectIndex = projects.indexOf(resumingFromProject);
            List<MavenProject> retainingProjects = result.subList(resumeFromProjectIndex, projects.size());

            result = includeAlsoMakeTransitively(retainingProjects, request, graph);
        }

        return result;
    }

        }

        int toIndex = offset + size;
        if (toIndex > stopwordsItemList.size()) {
            toIndex = stopwordsItemList.size();
        }

        return new PagingList<>(stopwordsItemList.subList(offset, toIndex), offset, size, stopwordsItemList.size());
    }

    @Override
    public synchronized void insert(final StopwordsItem item) {
        try (StopwordsUpdater updater = new StopwordsUpdater(item)) {

    if (newFromIndex == 0 && newToIndex == size()) {
      return this;
    } else if (newFromIndex < newToIndex) {
      return new RegularImmutableSortedSet<>(
          elements.subList(newFromIndex, newToIndex), comparator);
    } else {
      return emptySet(comparator);
    }
  }

  @Override
  int indexOf(@Nullable Object target) {
    if (target == null) {
      return -1;

        }

        int toIndex = offset + size;
        if (toIndex > mappingItemList.size()) {
            toIndex = mappingItemList.size();
        }

        return new PagingList<>(mappingItemList.subList(offset, toIndex), offset, size, mappingItemList.size());
    }

    /**
     * Inserts a new character mapping item into the dictionary file.
     *
     * @param item the character mapping item to insert

        int toIndex = offset + size;
        if (toIndex > stemmerOverrideItemList.size()) {
            toIndex = stemmerOverrideItemList.size();
        }

        return new PagingList<>(stemmerOverrideItemList.subList(offset, toIndex), offset, size, stemmerOverrideItemList.size());
    }

    @Override
    public synchronized void insert(final StemmerOverrideItem item) {

        }

        int toIndex = offset + size;
        if (toIndex > kuromojiItemList.size()) {
            toIndex = kuromojiItemList.size();
        }

        return new PagingList<>(kuromojiItemList.subList(offset, toIndex), offset, size, kuromojiItemList.size());
    }

    @Override
    public synchronized void insert(final KuromojiItem item) {
        try (KuromojiUpdater updater = new KuromojiUpdater(item)) {

        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }
    return absentBehavior.resultIndex(lower);
  }

            return true;
          }
        }
        to++;
      }
    }

    // Clear the tail of any remaining items
    list.subList(to, list.size()).clear();
    return from != to;
  }

  private static <T extends @Nullable Object> void slowRemoveIfForRemainingElements(
      List<T> list, Predicate<? super T> predicate, int to, int from) {