// Gather test files
	for i := 0; i < maxFiles; i++ {
		name, err := f.GetString()
		if err != nil {
			return files, err
		}
		rBytes, err := f.GetBytes()
		if err != nil {
			return files, err
		}
		r := bytes.NewReader(rBytes)
		files = append(files, local.ReaderSource{Name: name, Reader: r})
	}
	return files, nil
}

// runAnalyzer runs the analyzer

	VLD1	(R2), [V28.S4, V29.S4, V30.S4, V31.S4]     //load 64*4bytes K constant(K0-K63)

blockloop:

	VLD1.P	16(R1), [V4.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V5.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V6.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V7.B16]                            // load 16bytes message

	got = bytes.TrimSpace(got)

	// Make sure that there were exactly 100 bytes written to the corpus entry
	prefix := []byte("[]byte(")
	i := bytes.Index(got, prefix)
	gotBytes := got[i+len(prefix) : len(got)-1]
	s, err := strconv.Unquote(string(gotBytes))
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if want, got := numBytes, len(s); want != got {

        "abbaabba"                         | ByteArrayBackedHashCode | 4      | 0xBAABBAAB | toBytes([0xAB, 0xBA] * 2)
        "abbaabbaabba"                     | ByteArrayBackedHashCode | 6      | 0xBAABBAAB | toBytes([0xAB, 0xBA] * 3)
        "aB" * 255                         | ByteArrayBackedHashCode | 255    | 0xABABABAB | toBytes([0xAB] * 255)

        def serializer = registry.build(Number)

        expect:
        serialize(123L, serializer) == 123L
        serialize(123, serializer) == 123
        toBytes(123L, serializer).length == toBytes(123L, longSerializer).length + 1
    }

    def "does not write type tag when there is only one matching registered type"() {
        given:
        def registry = new DefaultSerializerRegistry()

        return fromBytes(bytes, serializer)
    }

    <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(getDecoder().newInstance(new ByteArrayInputStream(bytes)))
    }

    <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()
        def encoder = getEncoder().newInstance(bytes)
        serializer.write(encoder, value)

/**
 * Static utility methods pertaining to {@code byte} primitives, that are not already found in
 * either {@link Byte} or {@link Arrays}, <i>and interpret bytes as neither signed nor unsigned</i>.
 * The methods which specifically treat bytes as signed or unsigned are found in {@link SignedBytes}
 * and {@link UnsignedBytes}.
 *
 * <p>See the Guava User Guide article on <a

Daryl White <******@****.***> 1664425725 -0500

    }

    def "multiple writes of the same custom reason"() {
        when:
        def single = toBytes(withReason("hello"), serializer)
        def withDuplicate = toBytes(withReasons("hello", "hello"), serializer)
        def withoutDuplicate = toBytes(withReasons("hello", "other"), serializer)

        then:
        single.length < withDuplicate.length
        withDuplicate.length < 2*single.length

		n := w.nbytes
		bytes := w.bytes[n : n+6]
		bytes[0] = byte(bits)
		bytes[1] = byte(bits >> 8)
		bytes[2] = byte(bits >> 16)
		bytes[3] = byte(bits >> 24)
		bytes[4] = byte(bits >> 32)
		bytes[5] = byte(bits >> 40)
		n += 6
		if n >= bufferFlushSize {
			w.write(w.bytes[:n])
			n = 0
		}
		w.nbytes = n
	}
}

func (w *huffmanBitWriter) writeBytes(bytes []byte) {
	if w.err != nil {
		return
	}