Sink.Float64, Sink.Error = ParseFloat(string(bytes.Number), 64)
	}))
	t.Run("ParseComplex", checkNoAllocs(func() {
		Sink.Complex128, Sink.Error = ParseComplex(string(bytes.Number), 128)
	}))
	t.Run("CanBackquote", checkNoAllocs(func() {
		Sink.Bool = CanBackquote(string(bytes.String))
	}))
	t.Run("AppendQuote", checkNoAllocs(func() {
		Sink.Bytes = AppendQuote(bytes.Buffer[:0], string(bytes.String))
	}))

    grows 32 bytes, calls main.chain0<0>
        grows 48 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
    grows 32 bytes, calls main.chain2<0>
        grows 80 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
`, 32+48+1008-limit, 32+80+1008-limit),
		"main.startRec": `main.startRec<0>
    grows 8 bytes, calls main.startRec0<0>

        }
        int byte2 = bytes[index++];
        if (byte2 > (byte) 0xBF
            // Overlong? 5 most significant bits must not all be zero.
            || (byte1 == (byte) 0xE0 && byte2 < (byte) 0xA0)
            // Check for illegal surrogate codepoints.
            || (byte1 == (byte) 0xED && (byte) 0xA0 <= byte2)
            // Third byte trailing-byte test.
            || bytes[index++] > (byte) 0xBF) {
          return false;

        }
        int byte2 = bytes[index++];
        if (byte2 > (byte) 0xBF
            // Overlong? 5 most significant bits must not all be zero.
            || (byte1 == (byte) 0xE0 && byte2 < (byte) 0xA0)
            // Check for illegal surrogate codepoints.
            || (byte1 == (byte) 0xED && (byte) 0xA0 <= byte2)
            // Third byte trailing-byte test.
            || bytes[index++] > (byte) 0xBF) {
          return false;

    }

    def "formats bytes (#bytes -> #humanReadableString)"(long bytes, String humanReadableString) {
        expect:
        formatBytes(bytes) == humanReadableString
        formatBytes(-bytes) == "-$humanReadableString"

        where:
        bytes               | humanReadableString
        1                   | "1 B"
        999                 | "999 B"

    return hashLength16(
        rotateRight(e + f, 43) + rotateRight(g, 30) + h, e + rotateRight(f + a, 18) + g, mul);
  }

  /*
   * Compute an 8-byte hash of a byte array of length greater than 64 bytes.
   */
  private static long hashLength65Plus(byte[] bytes, int offset, int length) {
    int seed = 81;

    return hashLength16(
        rotateRight(e + f, 43) + rotateRight(g, 30) + h, e + rotateRight(f + a, 18) + g, mul);
  }

  /*
   * Compute an 8-byte hash of a byte array of length greater than 64 bytes.
   */
  private static long hashLength65Plus(byte[] bytes, int offset, int length) {
    int seed = 81;

   * {@code bytes[off + len - 1]} is the last.
   *
   * @param bytes a byte array
   * @param off the start offset in the array
   * @param len the number of bytes to write
   * @return this instance
   * @throws IndexOutOfBoundsException if {@code off < 0} or {@code off + len > bytes.length} or
   *     {@code len < 0}
   */
  @CanIgnoreReturnValue

	Headers map[string]string // Optional headers.
	Bytes   []byte            // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.
}

// getLine results the first \r\n or \n delineated line from the given byte
// array. The line does not include trailing whitespace or the trailing new
// line bytes. The remainder of the byte array (also not including the new line

	for _, test := range tests {
		f.Add([]byte(test.uncompressed))
	}

	// Add some larger data, as that has more interesting compression.
	f.Add(bytes.Repeat([]byte("abcdefghijklmnop"), 256))
	var buf bytes.Buffer
	for i := 0; i < 256; i++ {
		buf.WriteByte(byte(i))
	}
	f.Add(bytes.Repeat(buf.Bytes(), 64))
	f.Add(bigData(f))

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(zstd, "-z")