SMBUtil.writeInt2(Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED, buffer, offset + 2);

        // Dialect revision
        SMBUtil.writeInt2(0x0311, buffer, offset + 4);

        // Negotiate context count
        SMBUtil.writeInt2(0, buffer, offset + 6);

        // Server GUID (16 bytes)
        for (int i = 0; i < 16; i++) {
            buffer[offset + 8 + i] = (byte) i;
        }

        // Capabilities

        }
        esCb.request().build(builder);
        SearchResponse response = esCb.build(builder).execute().actionGet(scrollSearchTimeout);
        String scrollId = response.getScrollId();
        int count = 0;
        try {
            while (scrollId != null) {
                final SearchHits searchHits = getSearchHits(response);
                final SearchHit[] hits = searchHits.getHits();

            int count = 0;
            try {
                while (scrollId != null) {
                    final SearchHit[] hits = response.getHits().getHits();
                    if (hits.length == 0) {
                        break;
                    }
                    for (final SearchHit hit : hits) {
                        array[count] = hit.getSourceAsMap();

	return 0, &fs.PathError{Op: "read", Path: d.e.name, Err: errors.New("is a directory")}
}

func (d *openDir) ReadDir(count int) ([]fs.DirEntry, error) {
	n := len(d.files) - d.offset
	if count > 0 && n > count {
		n = count
	}
	if n == 0 {
		if count <= 0 {
			return nil, nil
		}
		return nil, io.EOF
	}
	list := make([]fs.DirEntry, n)
	for i := range list {

         * The number of shares in the array.
         */
        public int count;
        /**
         * Array of ShareInfo0 structures containing share information.
         */
        public ShareInfo0[] array;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.count);
            _dst.enc_ndr_referent(this.array, 1);

    }

    // Test getBucketOrder with count.desc
    @Test
    public void test_getBucketOrder_countDesc() {
        facetInfo.sort = "count.desc";
        BucketOrder order = facetInfo.getBucketOrder();
        assertNotNull(order);
        assertEquals(BucketOrder.count(false), order);
    }

    // Test getBucketOrder with count.asc
    @Test
    public void test_getBucketOrder_countAsc() {

        super(config, command);
        this.subCommand = subcommand;
    }

    /**
     * Gets the data count for this transaction response
     * @return the dataCount
     */
    protected final int getDataCount() {
        return this.dataCount;
    }

    /**
     * Sets the data count for this transaction response
     * @param dataCount
     *            the dataCount to set
     */

    }

    /**
     * Retrieves a list of session IDs with their document counts from the search engine.
     * Uses aggregation to get session segments and their corresponding document counts.
     *
     * @param searchEngineClient the search engine client to perform the query
     * @return a list of maps containing session IDs and their document counts
     */

			// appear earlier in this array of intervals, see
			// ObjectsHistogramIntervals
			splCount += count
			fallthrough
		default:
			res[szInt.name] = count
		}
	}
	return res
}

// add a version count to the histogram.
func (h *versionsHistogram) add(versions uint64) {
	// Fetch the histogram interval corresponding
	// to the passed object size.

            @SuppressWarnings("unchecked")
            final List<String> existingKinds = (List<String>) kindsObj;
            concatValues(existingKinds, Stream.of(item.getKinds()).map(SuggestItem.Kind::toString).toArray(count -> new String[count]));
            map.put(FieldNames.KINDS, existingKinds);
        } else {
            map.put(FieldNames.KINDS, Stream.of(item.getKinds()).map(SuggestItem.Kind::toString).toArray());
        }