}

  @Override
  public void write(int b) throws IOException {
    hasher.putByte((byte) b);
    out.write(b);
  }

  @Override
  public void write(byte[] bytes, int off, int len) throws IOException {
    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**
   * Returns the {@link HashCode} based on the data written to this stream. The result is

    private long v2 = 0x6c7967656e657261L;
    private long v3 = 0x7465646279746573L;

    // The number of bytes in the input.
    private long b = 0;

    // The final 64-bit chunk includes the last 0 through 7 bytes of m followed by null bytes
    // and ending with a byte encoding the positive integer b mod 256.
    private long finalM = 0;

    SipHasher(int c, int d, long k0, long k1) {

     * 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

            // Default constructor
        }

        /** The revision level of the SID structure */
        public byte revision;
        /** The number of sub-authorities in the SID */
        public byte sub_authority_count;
        /** The identifier authority value (6 bytes) */
        public byte[] identifier_authority;
        /** The array of sub-authority values */
        public int[] sub_authority;

		return nil, nil, fmt.Errorf("Failed to create certificate: %w", err)
	}

	certOut := bytes.NewBuffer([]byte{})
	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})

	keyOut := bytes.NewBuffer([]byte{})
	pem.Encode(keyOut, pemBlockForKey(priv))

	return certOut.Bytes(), keyOut.Bytes(), nil
}

func mustGetPoolEndpoints(poolIdx int, args ...string) EndpointServerPools {

        securityDescriptorBytes[22] = 8; // ACL size (low byte)
        securityDescriptorBytes[23] = 0; // ACL size (high byte)
        securityDescriptorBytes[24] = 0; // ACE count (low byte) - 0 ACEs
        securityDescriptorBytes[25] = 0; // ACE count (high byte)
        securityDescriptorBytes[26] = 0; // sbz2 (low byte)
        securityDescriptorBytes[27] = 0; // sbz2 (high byte)

    static void writeInt2(final int val, final byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) (val >> 8 & 0xFF);
        dstIndex++;
        dst[dstIndex] = (byte) (val & 0xFF);
    }

    static void writeInt4(final int val, final byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) (val >> 24 & 0xFF);
        dstIndex++;
        dst[dstIndex++] = (byte) (val >> 16 & 0xFF);

//   - Exactly 0 bytes are read and EOF is hit.
//   - Exactly 1 block of zeros is read and EOF is hit.
//   - At least 2 blocks of zeros are read.
func (tr *Reader) readHeader() (*Header, *block, error) {
	// Two blocks of zero bytes marks the end of the archive.
	if _, err := io.ReadFull(tr.r, tr.blk[:]); err != nil {
		return nil, nil, err // EOF is okay here; exactly 0 bytes read
	}

// license that can be found in the LICENSE file.

package bytes_test

import (
	. "bytes"
	"testing"
)

func BenchmarkSplitSeqEmptySeparator(b *testing.B) {
	for range b.N {
		for range SplitSeq(benchInputHard, nil) {
		}
	}
}

func BenchmarkSplitSeqSingleByteSeparator(b *testing.B) {
	sep := []byte("/")
	for range b.N {
		for range SplitSeq(benchInputHard, sep) {
		}
	}
}

        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.
        assertEquals(8, bytesRead);
    }

    /**