private final ByteBuffer buffer;

  /** Number of bytes to be filled before process() invocation(s). */
  private final int bufferSize;

  /** Number of bytes processed per process() invocation. */
  private final int chunkSize;

  /**
   * Constructor for use by subclasses. This hasher instance will process chunks of the specified
   * size.
   *

        // Verify file attributes have distinct bit patterns
        int[] attributes = { SmbConstants.ATTR_READONLY, SmbConstants.ATTR_HIDDEN, SmbConstants.ATTR_SYSTEM, SmbConstants.ATTR_VOLUME,
                SmbConstants.ATTR_DIRECTORY, SmbConstants.ATTR_ARCHIVE };

        for (int i = 0; i < attributes.length; i++) {
            for (int j = i + 1; j < attributes.length; j++) {

     */
    public LruHashMap(final int limitSize) {
        this(limitSize, DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Creates an {@link LruHashMap}.
     *
     * @param limitSize the upper limit on the number of entries
     * @param initialCapacity the initial capacity
     * @param loadFactor the load factor
     */
    public LruHashMap(final int limitSize, final int initialCapacity, final float loadFactor) {

    public SmbShareInfo(final String netName, final int type, final String remark) {
        this.netName = netName;
        this.type = type;
        this.remark = remark;
    }

    @Override
    public String getName() {
        return this.netName;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.FileEntry#getFileIndex()
     */
    @Override
    public int getFileIndex() {
        return 0;
    }

        internal val bar = "bar"

        internal var bazar = "bazar"

        internal fun String.fooExt() {}

        internal fun Int.fooExt() {}

        internal val String.barExt: String
            get() = "bar"

        internal var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

    """

    @Language("kotlin")
    private
    val publicMembers = """

      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public int indexOf(Object element) {
      return standardIndexOf(element);
    }

    @Override
    public int lastIndexOf(Object element) {
      return standardLastIndexOf(element);
    }

    @Override

      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public int indexOf(Object element) {
      return standardIndexOf(element);
    }

    @Override
    public int lastIndexOf(Object element) {
      return standardLastIndexOf(element);
    }

    @Override

// in the slices returned.
func hashOrder(key string, cardinality int) []int {
	if cardinality <= 0 {
		// Returns an empty int slice for cardinality < 0.
		return nil
	}

	nums := make([]int, cardinality)
	keyCrc := crc32.Checksum([]byte(key), crc32.IEEETable)

	start := int(keyCrc % uint32(cardinality))
	for i := 1; i <= cardinality; i++ {
		nums[i-1] = 1 + ((start + i) % cardinality)

    public int numTags = 2;

    private AllocationService strategy;
    private ClusterState initialClusterState;

    @Setup
    public void setUp() throws Exception {
        final String[] params = indicesShardsReplicasNodes.split("\\|");

        int numIndices = toInt(params[0]);
        int numShards = toInt(params[1]);
        int numReplicas = toInt(params[2]);

pkg slices, func All[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
pkg slices, func AppendSeq[$0 interface{ ~[]$1 }, $1 interface{}]($0, iter.Seq[$1]) $0 #61899
pkg slices, func Backward[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
pkg slices, func Chunk[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) iter.Seq[$0] #53987
pkg slices, func Collect[$0 interface{}](iter.Seq[$0]) []$0 #61899