}

    ensureCapacity(size + 1);
    keys[size] = key;
    values[size] = value;

    insertIntoTableKToV(size, keyHash);
    insertIntoTableVToK(size, valueHash);

    setSucceeds(lastInInsertionOrder, size);
    setSucceeds(size, ENDPOINT);
    size++;
    modCount++;
    return null;
  }

  @Override
  @CanIgnoreReturnValue

   */
  public static <E> Set<Set<E>> combinations(Set<E> set, int size) {
    ImmutableMap<E, Integer> index = Maps.indexMap(set);
    checkNonnegative(size, "size");
    checkArgument(size <= index.size(), "size (%s) must be <= set.size() (%s)", size, index.size());
    if (size == 0) {
      return ImmutableSet.<Set<E>>of(ImmutableSet.<E>of());
    } else if (size == index.size()) {
      return ImmutableSet.<Set<E>>of(index.keySet());

        // The validation in getBuffer() ensures size is within bounds (0 < size <= 1MB)
        assertTrue(buffer.length > 0, "Buffer size should be positive");
        assertTrue(buffer.length <= 0x100000, "Buffer size should not exceed 1MB");
    }

    /**
     * Test that releaseBuffer validates buffer before accepting it.
     */
    @Test

    }

    @Override
    public Map<String, Object> set(final int index, final Map<String, Object> element) {
        return parent.set(index, element);
    }

    @Override
    public int size() {
        return parent.size();
    }

    @Override
    public List<Map<String, Object>> subList(final int fromIndex, final int toIndex) {
        return parent.subList(fromIndex, toIndex);
    }

    @Override

}

// BucketUsageInfo - bucket usage info provides
// - total size of the bucket
// - total objects in a bucket
// - object size histogram per bucket
type BucketUsageInfo struct {
	Size uint64 `json:"size"`
	// Following five fields suffixed with V1 are here for backward compatibility
	// Total Size for objects that have not yet been replicated

        header.previous = header;
        size = 0;
    }

    /**
     * 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) {

      Map<E, Integer> delegateMap, ImmutableList<Entry<E>> entries, long size) {
    this.delegateMap = delegateMap;
    this.entries = entries;
    this.size = size;
  }

  @Override
  public int count(@Nullable Object element) {
    return delegateMap.getOrDefault(element, 0);
  }

  @LazyInit private transient @Nullable ImmutableSet<E> elementSet;

  @Override
  public ImmutableSet<E> elementSet() {

        @Test
        @DisplayName("Should decode error response with correct structure size")
        void testReadErrorResponseValid() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int bufferIndex = 0;

            // Write error response structure
            SMBUtil.writeInt2(9, buffer, bufferIndex); // structure size
            buffer[bufferIndex + 2] = 2; // error context count

    }

    /**
     * Returns the number of elements in this set (its cardinality).
     *
     * @return the number of elements in this set (its cardinality).
     */
    @Override
    public int size() {
        return map.size();
    }

    /**
     * Returns true if this set contains no elements.
     *
     * @return true if this set contains no elements.
     */
    @Override
    public boolean isEmpty() {

  private final transient int size;

  @LazyInit private transient @Nullable ImmutableSet<E> elementSet;

  RegularImmutableMultiset(ObjectCountHashMap<E> contents) {
    this.contents = contents;
    long size = 0;
    for (int i = 0; i < contents.size(); i++) {
      size += contents.getValue(i);
    }
    this.size = Ints.saturatedCast(size);
  }

  @Override
  boolean isPartialView() {