assertEquals(0, copy.indexOf(list.get(0)));
    assertEquals(0, head.indexOf(list.get(0)));
    assertEquals(0, tail.indexOf(list.get(1)));
    // The following assumes all elements are distinct.
    assertEquals(size - 1, copy.indexOf(list.get(size - 1)));
    assertEquals(size - 2, head.indexOf(list.get(size - 2)));
    assertEquals(size - 2, tail.indexOf(list.get(size - 1)));

        List<String> order = new ArrayList<>();
        for (String s : insertionOrder) {
          int index = order.indexOf(s);
          if (index == -1) {
            order.add(s);
          } else {
            order.add(index, s);
          }
        }
        return order;
      }
    };
  }

  public void testCreate() {

    }
  }

  abstract static class Indexed<E> extends ImmutableSet<E> {
    abstract E get(int index);

    @Override
    public UnmodifiableIterator<E> iterator() {
      return asList().iterator();
    }

    @Override
    ImmutableList<E> createAsList() {
      return new ImmutableAsList<E>() {
        @Override
        public E get(int index) {
          return Indexed.this.get(index);

                int index = auth.indexOf(':');
                String user = index != -1 ? auth.substring(0, index) : auth;
                final String password = index != -1 ? auth.substring(index + 1) : "";
                index = user.indexOf('\\');
                if (index == -1) {
                    index = user.indexOf('/');
                }

  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.get(key);
    }
    int index = indexOf(key);
    if (index == -1) {
      return null;
    }
    accessEntry(index);
    return value(index);
  }

  @CanIgnoreReturnValue

        return getEntryAt(index).getKey();
    }

    /**
     * Returns the {@link java.util.Map.Entry} at the specified index.
     *
     * @param index
     *            the index
     * @return the {@link java.util.Map.Entry} at the specified index
     */
    public Map.Entry<K, V> getEntryAt(final int index) {
        assertIndex(index < size, "Index:" + index + ", Size:" + size);

    }

    private int reverseIndex(int index) {
      int size = size();
      checkElementIndex(index, size);
      return (size - 1) - index;
    }

    private int reversePosition(int index) {
      int size = size();
      checkPositionIndex(index, size);
      return size - index;
    }

    @Override
    public void add(int index, @ParametricNullness T element) {

├── api/                       # REST API infrastructure
├── opensearch/                # DBFlute integration for OpenSearch
│   ├── config/                # Config index (crawl configs, schedules)
│   ├── log/                   # Log index (search logs, click logs)
│   └── user/                  # User index (users, groups, roles)
├── helper/                    # Cross-cutting utilities (~40+ helpers)

    @Override
    public Range<C> get(int index) {
      checkElementIndex(index, size);

      Cut<C> lowerBound;
      if (positiveBoundedBelow) {
        lowerBound = (index == 0) ? Cut.belowAll() : ranges.get(index - 1).upperBound;
      } else {
        lowerBound = ranges.get(index).upperBound;
      }

      Cut<C> upperBound;
      if (positiveBoundedAbove && index == size - 1) {

    this.offset = offset;
    this.length = length;
  }

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

  @Override
  Entry<E> getEntry(int index) {
    return Multisets.immutableEntry(elementSet.asList().get(index), getCount(index));
  }

  @Override
  public void forEachEntry(ObjIntConsumer<? super E> action) {