private int index = -1;
        private final int maxIndex = keyToIndex().size();

        @Override
        protected @Nullable Entry<K, V> computeNext() {
          for (index++; index < maxIndex; index++) {
            V value = getValue(index);
            if (value != null) {
              return immutableEntry(getKey(index), value);
            }
          }

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Iterator;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * {@link Iterator} with index. The index starts from {@literal 0}.
 *
 * <p>
 * Usage example:
 * </p>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 *
 * List&lt;String&gt; list = ...;

     */
    PropertyDesc getPropertyDesc(String propertyName);

    /**
     * Returns the {@link PropertyDesc}.
     *
     * @param index
     *            The index of the {@link PropertyDesc}
     * @return {@link PropertyDesc}
     */
    PropertyDesc getPropertyDesc(int index);

    /**
     * Returns the number of {@link PropertyDesc}.
     *
     * @return The number of {@link PropertyDesc}
     */

        final int index = indexOf(array, obj);
        if (index < 0) {
            return array;
        }
        @SuppressWarnings("unchecked")
        final T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), array.length - 1);
        if (index > 0) {
            System.arraycopy(array, 0, newArray, 0, index);
        }
        if (index < array.length - 1) {

          return i - start;
        }
      }
      return -1;
    }

    @Override
    public Boolean set(int index, Boolean element) {
      checkElementIndex(index, size());
      boolean oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override

/**
 * Strategy interface for formatting exported index documents.
 */
public interface IndexExportFormatter {

    /**
     * Returns the file extension for this format (e.g. ".html", ".json").
     *
     * @return the file extension including the leading dot
     */
    String getFileExtension();

    /**
     * Returns the default index file name for this format (e.g. "index.html", "index.json").
     *

    }

    /**
     * Encodes a String as UTF-8 bytes.
     *
     * @param str the String to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @param dlim the maximum index in the destination array
     * @return the number of bytes written
     * @throws IOException if an encoding error occurs
     */

     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T extends ASN1Primitive> T as(final Class<T> type, final ASN1Sequence sequence, final int index)
            throws PACDecodingException {
        return as(type, sequence.getObjectAt(index));
    }

    /**
     * Read a tagged object without parsing it's contents
     *

	g := errgroup.WithNErrs(len(users))

	for index := range users {
		g.Go(func() error {
			userName := path.Dir(users[index])
			user, err := iamOS.loadUserIdentity(ctx, userName, userType)
			if err != nil && !errors.Is(err, errNoSuchUser) {
				return fmt.Errorf("unable to load the user `%s`: %w", userName, err)
			}
			userIdentities[index] = user
			return nil
		}, index)
	}

	err := errors.Join(g.Wait()...)

        val index = orderBy.indexOfFirst { it.matches(ianaSuite) }
        if (index == -1) Integer.MAX_VALUE else index
      }
    for (suiteId in sortedSuites) {
      print(suiteId.name)
      for (client in clients) {
        print("\t")
        val index = client.enabled.indexOfFirst { it.matches(suiteId) }
        if (index != -1) {
          print(index + 1)
        }
      }
      println()