* of the returned array is that of the specified array. If the collection fits in the specified
   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more

   * of the returned array is that of the specified array. If the collection fits in the specified
   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more

        // Given
        byte[] buffer = new byte[512];
        int bodyStart = 0;
        int dataLength = 10;
        // Use a large but safe offset value that fits in signed byte range (120)
        int dataOffsetValue = 120;

        // Write structure
        SMBUtil.writeInt2(17, buffer, bodyStart);
        buffer[bodyStart + 2] = (byte) dataOffsetValue;

     *
     * @return byte array containing associated data
     */
    public byte[] getAssociatedData() {
        final byte[] aad = new byte[52]; // Use full header size to ensure all data fits
        int index = 0;

        // Protocol ID
        SMBUtil.writeInt4(TRANSFORM_PROTOCOL_ID, aad, index);
        index += 4;

        // Skip signature (16 bytes of zeros for AAD)
        index += 16;

  public static boolean isPowerOfTwo(long x) {
    return x > 0 & (x & (x - 1)) == 0;
  }

  /**
   * Returns 1 if {@code x < y} as unsigned longs, and 0 otherwise. Assumes that x - y fits into a
   * signed long. The implementation is branch-free, and benchmarks suggest it is measurably faster
   * than the straightforward ternary expression.
   */
  @VisibleForTesting

	// Add leading zeros, but leave room for a NUL.
	if n := len(b) - len(s) - 1; n > 0 {
		s = strings.Repeat("0", n) + s
	}
	f.formatString(b, s)
}

// fitsInOctal reports whether the integer x fits in a field n-bytes long
// using octal encoding with the appropriate NUL terminator.
func fitsInOctal(n int, x int64) bool {
	octBits := uint(n-1) * 3
	return x >= 0 && (n >= 22 || x < 1<<octBits)
}

				"application/emma+xml",
				"application/epp+xml",
				"application/epub+zip",
				"application/eshop",
				"application/example",
				"application/fastinfoset",
				"application/fastsoap",
				"application/fits",
				"application/font-tdpfr",
				"application/h224",
				"application/http",
				"application/hyperstudio",
				"application/ibe-key-request+xml",
				"application/ibe-pkg-reply+xml",

	i := copy(b2, b)
	return b2[:i]
}

// WriteTo writes data to w until the buffer is drained or an error occurs.
// The return value n is the number of bytes written; it always fits into an
// int, but it is int64 to match the [io.WriterTo] interface. Any error
// encountered during the write is also returned.
func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
	b.lastRead = opInvalid

                    // don't have enough credits/space for the first request, block until available
                    // for space there is nothing we can do, callers need to make sure that a single message fits

                    try {
                        final long timeout = getResponseTimeout(chain);
                        if (params.contains(RequestParam.NO_TIMEOUT)) {

      <match value="SIMPLE  =                T" type="string" offset="0"/>
    </magic>
    <glob pattern="*.fits"/>
    <glob pattern="*.fit"/>
    <glob pattern="*.fts"/>
  </mime-type>

  <mime-type type="application/font-tdpfr">
    <glob pattern="*.pfr"/>
  </mime-type>
  <mime-type type="application/h224"/>
  <mime-type type="application/http"/>