// Owner SID at offset 20
        buffer.position(20);
        buffer.put((byte) 0x01); // Revision
        buffer.put((byte) 0x01); // SubAuthorityCount
        buffer.put(new byte[] { 0, 0, 0, 0, 0, 1 }); // IdentifierAuthority
        buffer.putInt(0); // SubAuthority

        // Group SID at offset 40
        buffer.position(40);
        buffer.put((byte) 0x01); // Revision

import jcifs.internal.util.SMBUtil;

/**
 * File System Control Code (FSCC) structure for File End-of-File Information.
 * Used in SMB2/SMB3 operations to set or query the end-of-file position for a file,
 * effectively controlling file size truncation or extension.
 *
 * @author mbechler
 */
public class FileEndOfFileInformation implements FileInformation, Encodable {

    private long endOfFile;

    };
  }

  /**
   * Returns the element at the specified position in an iterable.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.skip(position).findFirst().get()} (throws
   * {@code NoSuchElementException} if out of bounds)
   *
   * @param position position of the element to return
   * @return the element at the specified position in {@code iterable}

            bb.putShort((short) 3); // rflags
            // v1 node string follows
            bb.put("\\server1\0".getBytes(StandardCharsets.UTF_16LE));

            // Position for second referral
            bb.position(28); // 8 header + 20 first referral

            // Second Referral v1
            bb.putShort((short) 1); // version
            bb.putShort((short) 22); // size

    for (int i = 0; i < numInsertions * 2; i += 2) {
      assertTrue(bf.mightContain(Integer.toString(i)));
    }

    // Now we check for known false positives using a set of known false positives.
    // (These are all of the false positives under 900.)
    ImmutableSet<Integer> falsePositives =
        ImmutableSet.of(
            49, 51, 59, 163, 199, 321, 325, 363, 367, 469, 545, 561, 727, 769, 773, 781);

    border-radius: 4px;
    padding: 75px 45px 35px;
    position: relative;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    /* Custom line-height */
    line-height: 1.2;
}

[data-termynal]:before {
    content: '';
    position: absolute;
    top: 15px;
    left: 15px;
    display: inline-block;
    width: 15px;
    height: 15px;

            writeBuffer.limit(writeBuffer.position() + bytesToWrite);

            int totalWritten = 0;
            while (writeBuffer.hasRemaining()) {
                int written = socketChannel.write(writeBuffer);
                totalWritten += written;
            }

            // Update original buffer position
            buffer.position(buffer.position() + totalWritten);

        // Test writeSecurityBufferContent
        byte[] dest = new byte[20];
        byte[] src = "Content".getBytes();
        int pos = 8; // Position where content should be written
        int off = 0; // Offset where position should be written

        // Test with non-null source array
        int bytesWritten = NtlmMessage.writeSecurityBufferContent(dest, pos, off, src);

   * in (by dividing by 4) and out (by multiplying by 4).
   */
  private fun findRangesOffset(
    codePoint: Int,
    position: Int,
    limit: Int,
  ): Int {
    val target = codePoint and 0x7f
    val offset =
      binarySearch(
        position = position,
        limit = limit,
      ) { index ->
        val entryIndex = index * 4
        val b0 = ranges[entryIndex].code

    /**
     * Finds the null termination in a UTF-16LE encoded string buffer.
     *
     * @param buffer the byte buffer to search
     * @param bufferIndex the starting position in the buffer
     * @param maxLen the maximum length to search
     * @return position of terminating null bytes
     */
    public static int findUNITermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;