- positions.bottom).css('top', top >= 0 ? top : 0)\n        $controlsidebarContent.css('height', heights.window - (heights.footer - positions.bottom))\n      } else {\n        $controlSidebar.css('bottom', heights.footer)\n      }\n    } else if (positions.top <= heights.header) {\n      if (navbarFixed === false) {\n        $controlSidebar.css('top', heights.header - positions.top)\n        $controlsidebarContent.css('height', heights.window - (heights.header - positions.top))\n      } else {\n...

  }

  /**
   * Updates the specified entry to point to the new value: removes the old value from the V-to-K
   * mapping and puts the new one in. The entry is moved to the end of the insertion order, or to
   * the position of the new key if it was previously present.
   */
  private void replaceKeyInEntry(int entry, @ParametricNullness K newKey, boolean force) {
    checkArgument(entry != ABSENT);
    int newKeyHash = smearedHash(newKey);

   *     {@link ByteOrder#LITTLE_ENDIAN}, to which a BYTES-long byte representation of this instance
   *     is written. In the process increases the position of {@link ByteBuffer} by BYTES.
   */
  void writeTo(ByteBuffer buffer) {
    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,

      }
    }
    return new RegularImmutableMap<>(entries, table, mask);
  }

  /**
   * Constructs a new entry array where each duplicated key from the original appears only once, at
   * its first position but with its final value. The {@code duplicates} map is modified.
   *
   * @param entries the original array of entries including duplicates
   * @param n the number of valid entries in {@code entries}

        // Set SMB 3.1.1 dialect and 1 context
        SMBUtil.writeInt2(0x0311, buffer, 4);
        SMBUtil.writeInt2(1, buffer, 6);
        SMBUtil.writeInt4(100, buffer, 60); // Context offset

        // At context position, set data that extends beyond buffer
        int contextPos = 164; // 100 + 64 (header start)
        if (contextPos + 8 < buffer.length) {
            SMBUtil.writeInt2(1, buffer, contextPos); // Context type

     * @return the allocationSize
     */
    public final long getAllocationSize() {
        return this.allocationSize;
    }

    /**
     * Get the end of file position
     * @return the endOfFile
     */
    public final long getEndOfFile() {
        return this.endOfFile;
    }

    /**
     * {@inheritDoc}
     *

		}
		if !meta.IsValid() {
			inconsistent++
			continue
		}
		if meta.XLV1 != fi.XLV1 {
			inconsistent++
			continue
		}
		// check if erasure distribution order matches the index
		// position if this is not correct we discard the disk
		// and move to collect others
		if distribution[i] != meta.Erasure.Index {
			inconsistent++ // keep track of inconsistent entries
			continue
		}

 *    no pinning will be enforced if additional prefixes are present, or if no prefixes are present.
 *
 * Note that any other form is unsupported. You may not use asterisks in any position other than
 * the leftmost label.
 *
 * If multiple patterns match a hostname, any match is sufficient. For example, suppose pin A

        byte[] nameBytes = shareName.getBytes(StandardCharsets.US_ASCII);
        System.arraycopy(nameBytes, 0, buffer, bufferIndex, 13);
        buffer[13] = 0; // null terminator at position 13
        bufferIndex += 14;

        // Write type
        SMBUtil.writeInt2(0, buffer, bufferIndex);
        bufferIndex += 2;

        // Write remark offset

    insertEntry(newEntryIndex, key, value, hash, mask);
    this.size = newSize;
    incrementModCount();
    return null;
  }

  /**
   * Creates a fresh entry with the specified object at the specified position in the entry arrays.
   */
  void insertEntry(
      int entryIndex, @ParametricNullness K key, @ParametricNullness V value, int hash, int mask) {
    this.setEntry(entryIndex, CompactHashing.maskCombine(hash, UNSET, mask));