00000010  bf 74 92 06 39 a6 9a 9b  80 71 7e 57 63 ab 31 74  |.t..9....q~Wc.1t|
00000020  d3 22 c1 e3 a6 c6 cf 6f  47 57 49 20 86 52 fb 0a  |.".....oGWI .R..|
00000030  fd aa 10 47 00 9a 5d ad  4c d8 90 f1 cf 13 10 73  |...G..].L......s|
00000040  31 f1 df 22 f3 42 58 b0  10 25 43 eb cc a8 00 01  |1..".BX..%C.....|
00000050  7e 00 12 01 69 01 67 00  75 00 a4 b9 09 90 b4 18  |~...i.g.u.......|

000000f0  bb 29 07 30 ff f6 84 af  c4 cf c2 ed 90 99 5f 58  |.).0.........._X|
00000100  cb 3b 74                                          |.;t|
>>> Flow 2 (server to client)
00000000  16 03 03 00 7a 02 00 00  76 03 03 b2 4d aa 76 5b  |....z...v...M.v[|
00000010  b7 38 95 18 e6 81 66 f8  27 82 26 2c b3 44 50 b0  |.8....f.'.&,.DP.|
00000020  f4 a8 f5 f2 87 f0 9d 85  4f ac 60 20 00 00 00 00  |........O.` ....|

		inferTypesForCmp(&a, &b)

		if a.Equals(b) {
			return true
		}

		// If elements, compare each.
		aA, aOK := a.ToArray()
		bA, bOK := b.ToArray()
		if aOK && bOK {
			if len(aA) != len(bA) {
				return false
			}
			for i := range aA {
				if !cmp(aA[i], bA[i]) {
					return false
				}
			}
			return true
		}
		// Try as numbers
		aF, aOK := a.ToFloat()

	for i := 0; i <= len(p)-BlockSize; i += BlockSize {
		// eliminate bounds checks on p
		q := p[i:]
		q = q[:BlockSize:BlockSize]

		// save current state
		aa, bb, cc, dd := a, b, c, d

		// load input block
		{{range $i := seq 16 -}}
			{{printf "x%x := byteorder.LeUint32(q[4*%#x:])" $i $i}}
		{{end}}

		// round 1
		{{range $i, $s := dup 4 .Shift1 -}}

		{"\n", -1},
		{"AAA=\n", -1},
		{"AAAA\n", -1},
		{"!!!!", 0},
		{"====", 0},
		{"x===", 1},
		{"=AAA", 0},
		{"A=AA", 1},
		{"AA=A", 2},
		{"AA==A", 4},
		{"AAA=AAAA", 4},
		{"AAAAA", 4},
		{"AAAAAA", 4},
		{"A=", 1},
		{"A==", 1},
		{"AA=", 3},
		{"AA==", -1},
		{"AAA=", -1},
		{"AAAA", -1},
		{"AAAAAA=", 7},
		{"YWJjZA=====", 8},
		{"A!\n", 1},
		{"A=\n", 1},
	}

go run check_file/main.go $GOCACHE/fuzz/FuzzCovMin ab

-- go.mod --
module test

-- covmin_test.go --
package covmin

import "testing"

func FuzzCovMin(f *testing.F) {
	f.Add([]byte("aa"))
	f.Fuzz(func(t *testing.T, data []byte) {
		if len(data) == 2 && data[0] == 'a' && data[1] == 'b' {
			return
		}
	})
}

-- check_file/main.go --
package main

import (
	"bytes"
	"fmt"

	(*reflect.StringHeader)(unsafe.Pointer(&bad2)).Data = uintptr(unsafe.Pointer(&b[1]))

	for _, test := range []struct {
		a, b interface{}
	}{
		{SI{s: bad1, i: 1}, SI{s: bad2, i: 2}},
		{SS{s: bad1, t: "a"}, SS{s: bad2, t: "aa"}},
		{SS{s: "a", t: bad1}, SS{s: "b", t: bad2}},
		// This one would panic because the length of both strings match, and we check
		// the body of the bad strings before the body of the good strings.

    t.pushRight(2).left == t
    t.pushRight(2).right == 2

    t.mapLeft { it + 1 }.left == 2
    t.mapLeft { it + 1 }.right == "a"
    t.mapRight { it * 2 }.left == 1
    t.mapRight { it * 2 }.right == "aa"

    t.nestLeft(2).mapLeft(unpackLeft()).left == 2
    t.nestLeft(2).mapLeft(unpackRight()).left == 1
    t.nestLeft(2).mapLeft(unpackLeft()).right == "a"
    t.nestLeft(2).mapLeft(unpackRight()).right == "a"

	}
}

var minInputLenTests = []struct {
	Regexp string
	min    int
}{
	{``, 0},
	{`a`, 1},
	{`aa`, 2},
	{`(aa)a`, 3},
	{`(?:aa)a`, 3},
	{`a?a`, 1},
	{`(aaa)|(aa)`, 2},
	{`(aa)+a`, 3},
	{`(aa)*a`, 1},
	{`(aa){3,5}`, 6},
	{`[a-z]`, 1},
	{`日`, 3},
}

func TestMinInputLen(t *testing.T) {
	for _, tt := range minInputLenTests {

00000180  32 7c b3 64 2f 1c 90 bc  ea 68 23 10 7e fe e3 25  |2|.d/....h#.~..%|
00000190  c0 48 3a 69 e0 28 6d d3  37 00 ef 04 62 dd 0d a0  |.H:i.(m.7...b...|
000001a0  9c 70 62 83 d8 81 d3 64  31 aa 9e 97 31 bd 96 b0  |.pb....d1...1...|
000001b0  68 c0 9b 23 de 76 64 3f  1a 5c 7f e9 12 0e 58 58  |h..#.vd?.\....XX|
000001c0  b6 5f 70 dd 9b d8 ea d5  d7 f5 d5 cc b9 b6 9f 30  |._p............0|