{"01234__5", 0, 0, ErrSyntax},
	{"012345_", 0, 0, ErrSyntax},

	{"0o_1_2_3_4_5", 0, 012345, nil}, // base 0 => 8 (0o377)
	{"_0o12345", 0, 0, ErrSyntax},
	{"0o__12345", 0, 0, ErrSyntax},
	{"0o1234__5", 0, 0, ErrSyntax},
	{"0o12345_", 0, 0, ErrSyntax},

	{"0_1_2_3_4_5", 8, 0, ErrSyntax}, // base 8
	{"_012345", 8, 0, ErrSyntax},
	{"0__12345", 8, 0, ErrSyntax},
	{"01234__5", 8, 0, ErrSyntax},

	4: linksTo(5),
	5: nil,
}

-- Profile_simple.Output --
Low:0.1 High:0.29 Score:14 Communities:[[0 1 2 3 4 5]] Q=0.9
Low:0.29 High:2.3 Score:12 Communities:[[0 1 2] [3 4 5]] Q=0.714
Low:2.3 High:3.5 Score:4 Communities:[[0 1] [2] [3] [4 5]] Q=-0.31
Low:3.5 High:10 Score:0 Communities:[[0] [1] [2] [3] [4] [5]] Q=-0.607

-- Profile_multiplex.Play --

package main

import (
	"fmt"
	"log"
	"sort"

	{"byte f", append([]byte{0, 1, 2}, 3, 4, 5), []byte{0, 1, 2, 3, 4, 5}},

	{"byte g", append([]byte{}, []byte{0}...), []byte{0}},
	{"byte h", append([]byte{}, []byte{0, 1, 2, 3}...), []byte{0, 1, 2, 3}},

	{"byte i", append([]byte{0, 1, 2}, []byte{3}...), []byte{0, 1, 2, 3}},
	{"byte j", append([]byte{0, 1, 2}, []byte{3, 4, 5}...), []byte{0, 1, 2, 3, 4, 5}},

	{"bytestr a", append([]byte{}, "0"...), []byte("0")},

				b := e.Values[0].([]byte)
				if len(b) < 3 {
					return nil
				}
				if bytes.Equal(b, []byte{0, 1, 2, 3, 4, 5}) || bytes.Equal(b, []byte{0, 4, 5}) {
					return fmt.Errorf("bad %v", e.Values[0])
				}
				return nil
			},
			input:    []any{[]byte{0, 1, 2, 3, 4, 5}},
			expected: []any{[]byte{0, 4, 5}},
		},
		{
			name: "non_ascii_bytes",
			fn: func(e CorpusEntry) error {

	}

	// Output:
	// Low:0.1 High:0.29 Score:14 Communities:[[0 1 2 3 4 5]] Q=0.9
	// Low:0.29 High:2.3 Score:12 Communities:[[0 1 2] [3 4 5]] Q=0.714
	// Low:2.3 High:3.5 Score:4 Communities:[[0 1] [2] [3] [4 5]] Q=-0.31
	// Low:3.5 High:10 Score:0 Communities:[[0] [1] [2] [3] [4] [5]] Q=-0.607
}

// intset is an integer set.
type intset map[int]struct{}

func linksTo(i ...int) intset {

	20: T{3, 4},
}

var _ = [][]int{
	{},
	{1, 2},
	{3, 4},
}

var _ = [][]int{
	([]int{}),
	([]int{1, 2}),
	{3, 4},
}

var _ = [][][]int{
	{},
	{
		{},
		{0, 1, 2, 3},
		{4, 5},
	},
}

var _ = map[string]T{
	"foo": {},
	"bar": {1, 2},
	"bal": {3, 4},
}

var _ = map[string]struct {
	x, y int
}{
	"foo": {},
	"bar": {1, 2},
	"bal": {3, 4},
}

	if i != expected {
		println("e3: got", i, "expected", expected)
		panic("fail")
	}
	i++
	return p
}

func main() {
	for i := range a {
		a[i] = ' '
	}

	// 0     1     2     3        4        5
	*f(), *f(), *f() = gbyte(), gbyte(), gbyte()

	// 6     7     8
	*f(), *f() = x()

	m := make(map[byte]byte)
	m[10] = 'A'
	var p1, p2 bool
	// 9           10
	*f(), p1 = m[gint()]

// CHECK-LABEL: fused_batch_norm_v3_bf16
func.func @fused_batch_norm_v3_bf16(%arg0: tensor<8x8x8x8xbf16>, %arg1: tensor<8xf32>, %arg2: tensor<8xf32>, %arg3: tensor<8xf32>, %arg4: tensor<8xf32>) -> tensor<8x8x8x8xbf16> {

		panic("s")
	}

	m := map[string]float64{"one": 1.0, "two": 2.0, "pi": 22. / 7.}
	if len(m) != 3 {
		panic("m")
	}

	eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)})
	eq([]*R{{0}, {1}, {2}, {3}, {4}, {5}})

	p1 := NewP(1, 2)
	p2 := NewP(1, 2)
	if p1 == p2 {
		panic("NewP")
	}

			randVals: []int{0, 2, 0, 2},
			input:    append(make([]byte, 0, 9), []byte{1, 2, 3, 4}...),
			expected: []byte{3, 2, 1, 4},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			r := &mockRand{values: []int{0, 1, 2, 3, 4, 5}}
			if tc.randVals != nil {
				r.values = tc.randVals
			}
			m := &mutator{r: r}
			b := tc.mutator(m, tc.input)
			if !bytes.Equal(b, tc.expected) {
				t.Errorf("got %x, want %x", b, tc.expected)