/**
     * Specifies a single quantile index to be calculated, i.e. the k in the kth q-quantile.
     *
     * @param index the quantile index, which must be in the inclusive range [0, q] for q-quantiles
     */
    public ScaleAndIndex index(int index) {
      return new ScaleAndIndex(scale, index);
    }

    /**
     * Specifies multiple quantile indexes to be calculated, each index being the k in the kth
     * q-quantile.

    }

    /**
     * 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
     */
    public static int enc_utf8(final String str, final byte[] dst, int di, final int dlim) {

		shuffledPartsMetadata[blockIndex-1] = partsMetadata[index]
		shuffledDisks[blockIndex-1] = disks[index]
	}
	return shuffledDisks, shuffledPartsMetadata
}

func shuffleWithDist[T any](input []T, distribution []int) []T {
	if distribution == nil {
		return input
	}
	shuffled := make([]T, len(input))
	for index := range input {
		blockIndex := distribution[index]
		shuffled[blockIndex-1] = input[index]
	}

     * Returns the entry at the specified position.
     *
     * @param index the index
     * @return the entry
     */
    public Entry getEntry(final int index) {
        assertIndex(0 <= index && index < size, "Index: " + index + ", Size: " + size);
        Entry e = header;
        if (index < size / 2) {
            for (int i = 0; i <= index; i++) {
                e = e.next;
            }
        } else {

        index += 4;

        // Reserved
        SMBUtil.writeInt2(0, aad, index);
        index += 2;

        // Flags
        SMBUtil.writeInt2(this.flags, aad, index);
        index += 2;

        // Session ID (8 bytes)
        SMBUtil.writeInt8(this.sessionId, aad, index);

        return aad;
    }

        Map<String, MavenProject> index = new LinkedHashMap<>();
        Map<String, List<File>> collisions = new LinkedHashMap<>();

        for (MavenProject project : projects) {
            String projectId = ArtifactUtils.key(project.getGroupId(), project.getArtifactId(), project.getVersion());

            MavenProject collision = index.get(projectId);

            if (collision == null) {

     *
     * @param index
     *            the index of the parameter
     * @return the key type if the parameter type at the specified index is a parameterized {@link Map}, otherwise {@literal null}
     */
    Class<?> getKeyClassOfMap(int index);

    /**
     * Returns the value type if the method's parameter type at the specified index is a parameterized {@link Map}.
     *

    level = DeprecationLevel.ERROR,
  )
  fun size(): Int = size

  fun encodedName(index: Int): String = encodedNames[index]

  fun name(index: Int): String = encodedName(index).percentDecode(plusIsSpace = true)

  fun encodedValue(index: Int): String = encodedValues[index]

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

    }

    /**
     * Gets the name of the data index for the crawler.
     *
     * @return the data index name
     */
    @Override
    public String getDataIndex() {
        return ComponentUtil.getFessConfig().getIndexDocumentCrawlerIndex() + ".data";
    }

    /**
     * Gets the name of the filter index for the crawler.
     *
     * @return the filter index name
     */
    @Override

    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 @Nullable Entry<E> firstEntry() {