// KGS!@#$%
    private static final byte[] S8 =
            { (byte) 0x4b, (byte) 0x47, (byte) 0x53, (byte) 0x21, (byte) 0x40, (byte) 0x23, (byte) 0x24, (byte) 0x25 };

    /* Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */
    private static void E(final byte[] key, final byte[] data, final byte[] e) {
        final byte[] key7 = new byte[7];

   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 4 elements
   */
  public static int fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
  }

  /**
   * Returns the {@code int} value whose byte representation is the given 4 bytes, in big-endian

            assertEquals(12288, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should return correct bytes consumed")
        void testReturnBytesConsumed() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[100];
            byte[] responseData = createValidCopyChunkResponse(8, 16384, 131072);
            System.arraycopy(responseData, 0, buffer, 20, responseData.length);

        byte[] buffer = new byte[256];
        Arrays.fill(buffer, (byte) 0xCC); // Fill with pattern to detect unwritten areas

        int written = request.writeBytesWireFormat(buffer, 0);

        // Verify structure according to SMB2 FLUSH specification
        // Structure Size (2 bytes) - should be 24
        assertEquals(24, SMBUtil.readInt2(buffer, 0));

        // Create buffer with exact decode size
        byte[] tempBuffer = new byte[50];
        original.encode(tempBuffer, 0);

        // Copy only the first 36 bytes (what decode reads)
        byte[] buffer = new byte[36];
        System.arraycopy(tempBuffer, 0, buffer, 0, 36);

        // Decode

							}

							var buf bytes.Buffer
							if err := rs.Join(&buf, splitFilled, m.size); err == nil {
								m.filled = buf.Bytes()
							}
							buf = bytes.Buffer{}
							if err := rs.Join(&buf, splitData, m.size); err == nil {
								m.mapped = buf.Bytes()
							}
							for i, v := range m.filled {
								if v == 0 {

		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgMetricDescription(b *testing.B) {

		"Total number of bytes failed at least once to replicate in the last hour on a bucket",
		bucketL, targetArnL)
	bucketReplLastHrFailedCountMD = NewGaugeMD(bucketReplLastHrFailedCount,
		"Total number of objects which failed replication in the last hour on a bucket",
		bucketL, targetArnL)
	bucketReplLastMinFailedBytesMD = NewGaugeMD(bucketReplLastMinFailedBytes,

        // Padding to align data to 8-byte boundary
        dstIndex += 4;

        // Write durable handle V2 request data (32 bytes total)
        // MS-SMB2 2.2.13.2.4 structure:
        SMBUtil.writeInt4((int) getTimeoutFor100Ns(), dst, dstIndex); // Timeout (4 bytes in 100-ns intervals)
        dstIndex += 4;

        SMBUtil.writeInt4(flags, dst, dstIndex); // Flags (4 bytes)
        dstIndex += 4;

     * Reads up to len bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @param off the offset in the array at which to start storing bytes
     * @param len the maximum number of bytes to read
     * @return the number of bytes read, or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs
     */