* has to explicitly reverse the order of the bytes as it packs them into the result which makes
   * it slower than the native version.
   *
   * @param input the input bytes
   * @param offset the offset into the array at which to start reading
   * @param length the number of bytes from the input to read
   * @return a long of a concatenated 8 bytes
   */
  static long load64Safely(byte[] input, int offset, int length) {
    long result = 0;

    // TODO(jwilson): detect overflow.
    var result = 0L
    while (true) {
      val byteN = source.readByte().toLong() and 0xff
      if ((byteN and 0b1000_0000L) == 0b1000_0000L) {
        result = (result + (byteN and 0b0111_1111)) shl 7
      } else {
        return result + byteN
      }
    }
  }

  /** Read a value as bytes without interpretation of its contents. */

		}
	}
	return true, ""
}

func TestCmpReaders(t *testing.T) {
	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abc"))
		ok, msg := cmpReaders(r1, r2)
		if !ok || msg != "" {
			t.Fatalf("unexpected")
		}
	}

	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abcd"))
		ok, _ := cmpReaders(r1, r2)
		if ok {
			t.Fatalf("unexpected")
		}
	}

  }

  /**
   * Reads all bytes from a file into a byte array.
   *
   * <p><b>{@link java.nio.file.Path} equivalent:</b> {@link java.nio.file.Files#readAllBytes}.
   *
   * @param file the file to read from
   * @return a byte array containing all the bytes from file
   * @throws IllegalArgumentException if the file is bigger than the largest possible byte array
   *     (2^31 - 1)

     * Constructs a KerberosToken from token bytes.
     *
     * @param token the token bytes
     * @throws PACDecodingException if token decoding fails
     */
    public KerberosToken(byte[] token) throws PACDecodingException {
        this(token, null);
    }

    /**
     * Constructs a KerberosToken from token bytes with decryption keys.
     *
     * @param token the token bytes

	},
	{
		KeyID:      "my-key",
		Plaintext:  "UnPWsZgVI+T4L9WGNzFlP1PsP1Z6hn2Fx8ISeZfDGnA=",
		Ciphertext: `{"aead":"ChaCha20Poly1305","iv":"r4+yfiVbVIYR0Z2I9Fq+6g==","nonce":"2YpwGwE59GcVraI3","bytes":"k/svMglOU7/Kgwv73heG38NWW575XLcFp3SaxQHDMjJGYyRI3Fiygu2OeutGPXNL"}`,

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */
    const val HEADER_TABLE_SIZE = 1

    /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 3

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 4

     * @return the calculated MAC bytes (truncated to 12 bytes)
     * @throws GeneralSecurityException if cryptographic operations fail
     */
    public static byte[] calculateMacHMACAES(int usage, KerberosKey baseKey, byte[] input) throws GeneralSecurityException {
        byte[] cst = { (byte) (usage >> 24 & 0xFF), (byte) (usage >> 16 & 0xFF), (byte) (usage >> 8 & 0xFF), (byte) (usage & 0xFF),
                (byte) 0x99 };

import java.io.OutputStream;

/**
 * An OutputStream that counts the number of bytes written.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class CountingOutputStream extends FilterOutputStream {

  private long count;

  /**
   * Wraps another output stream, counting the number of bytes written.
   *
   * @param out the output stream to be wrapped
   */

        private int dataWireFormatReturn = 0;
        private byte[] setupBuffer;
        private byte[] parametersBuffer;
        private byte[] dataBuffer;

        public TestSmbComTransaction(Configuration config, byte command, byte subCommand) {
            super(config, command, subCommand);
        }

        @Override
        protected int writeSetupWireFormat(byte[] dst, int dstIndex) {