github.com/mitranim/gg@v0.1.17/grepr/grepr_test.go

package grepr_test

import (
	"fmt"
	"math"
	r "reflect"
	"testing"
	"unicode/utf8"

	"github.com/mitranim/gg"
	"github.com/mitranim/gg/grepr"
	"github.com/mitranim/gg/gtest"
)

type (
	Bool       bool
	Byte       uint8
	Uint16     uint16
	Uint32     uint32
	Uint64     uint64
	Uint       uint
	Int8       int8
	Int16      int16
	Int32      int32
	Int64      int64
	Int        int
	Float32    float32
	Float64    float64
	Complex64  complex64
	Complex128 complex128
	Str        string
)

type Struct0 struct{}

type Struct1 struct{ A int }

type Struct2 struct {
	A int
	B int
}

type Struct1Any struct{ Val any }

type Outer struct {
	OuterId   int
	OuterName string
	Embed
	Inner *Inner
}

type Embed struct {
	EmbedId   int
	EmbedName string
}

type Inner struct {
	InnerId   *int
	InnerName *string
}

type Cyclic struct {
	Id     int
	Cyclic *Cyclic
}

type GoStringer struct{}

func (GoStringer) GoString() string { return `MakeGoStringer()` }

var testInner = Inner{
	InnerId:   gg.Ptr(30),
	InnerName: gg.Ptr(`inner`),
}

var testEmbed = Embed{EmbedId: 20}

var testOuter = Outer{
	OuterName: `outer`,
	Embed:     testEmbed,
	Inner:     &testInner,
}

var testOuterStringZero = "grepr_test.Outer{OuterName: `outer`, Embed: grepr_test.Embed{EmbedId: 20}, Inner: &grepr_test.Inner{InnerId: gg.Ptr(30), InnerName: gg.Ptr(`inner`)}}"

var testOuterStringDef = `grepr_test.Outer{
    OuterName: ` + "`outer`" + `,
    Embed: grepr_test.Embed{EmbedId: 20},
    Inner: &grepr_test.Inner{
        InnerId: gg.Ptr(30),
        InnerName: gg.Ptr(` + "`inner`" + `),
    },
}`

var testOuterStringDefPkgStrip = `Outer{
    OuterName: ` + "`outer`" + `,
    Embed: Embed{EmbedId: 20},
    Inner: &Inner{
        InnerId: gg.Ptr(30),
        InnerName: gg.Ptr(` + "`inner`" + `),
    },
}`

/*
Replacement for `gtest.Eq` just for this test. `gtest` uses `grepr` to print
values. Since we're testing `grepr`, we can't trust it.
*/
func strEq(act, exp string) {
	if act != exp {
		panic(gtest.ErrAt(1, gg.JoinLinesOpt(
			`unexpected difference`,
			gtest.Msg(`actual:`, act),
			gtest.Msg(`expected:`, exp),
		)))
	}
}

func testReprZero[A any](src A, exp string) {
	testReprC(grepr.Conf{}, src, exp)
}

func testReprDef[A any](src A, exp string) {
	strEq(grepr.String(src), exp)
}

func testReprC[A any](conf grepr.Conf, src A, exp string) {
	strEq(grepr.StringC(conf, src), exp)
}

func Test_nil_top(t *testing.T) {
	defer gtest.Catch(t)

	testReprZero[any](nil, `nil`)
	testReprZero[*any](nil, `nil`)
	testReprZero[fmt.Stringer](nil, `nil`)
	testReprZero[func()](nil, `nil`)
	testReprZero[[]byte](nil, `nil`)
	testReprZero[*string](nil, `nil`)
	testReprZero[map[int]bool](nil, `nil`)
}

func Test_nil_inner(t *testing.T) {
	defer gtest.Catch(t)

	testReprZero([]any{nil}, `[]any{nil}`)
	testReprZero([]any{(*any)(nil)}, `[]any{(*any)(nil)}`)
	testReprZero([]any{(*string)(nil)}, `[]any{(*string)(nil)}`)
	testReprZero([]any{(func())(nil)}, `[]any{(func())(nil)}`)
	testReprZero([]any{[]byte(nil)}, `[]any{[]byte(nil)}`)
	testReprZero([]any{map[int]bool(nil)}, `[]any{map[int]bool(nil)}`)
	testReprZero([]fmt.Stringer{nil}, `[]fmt.Stringer{nil}`)
	testReprZero([]fmt.Stringer{(*gg.ErrStr)(nil)}, `[]fmt.Stringer{(*gg.ErrStr)(nil)}`)
	testReprZero([]func(){nil}, `[]func(){nil}`)
	testReprZero([][]byte{nil}, `[][]byte{nil}`)
}

func Test_primitives(t *testing.T) {
	defer gtest.Catch(t)

	{
		testBoolTop[bool]()
		testBoolTop[Bool]()

		// `bool` is default type for boolean literals.
		testReprZero([1]any{false}, `[1]any{false}`)
		testReprZero([1]any{true}, `[1]any{true}`)

		testReprZero([1]any{Bool(false)}, `[1]any{grepr_test.Bool(false)}`)
		testReprZero([1]any{Bool(true)}, `[1]any{grepr_test.Bool(true)}`)
	}

	testByte[uint8](`byte`)
	testByte[Byte](`grepr_test.Byte`)

	testUint[uint16]()
	testUint[Uint16]()
	testUint[uint32]()
	testUint[Uint32]()
	testUint[uint64]()
	testUint[Uint64]()
	testUint[uint]()
	testUint[Uint]()

	testSint[int16]()
	testSint[Int16]()
	testSint[int32]()
	testSint[Int32]()
	testSint[int64]()
	testSint[Int64]()

	{
		testSintTop[int]()
		testSintTop[Int]()
		testSignedInner[Int]()

		// `int` is default type for integer literals.
		testReprZero([1]any{0}, `[1]any{0}`)
		testReprZero([1]any{127}, `[1]any{127}`)
		testReprZero([1]any{-128}, `[1]any{-128}`)
	}

	testFloat[float32]()
	testFloat[Float32]()
	testFloat[float64]()
	testFloat[Float64]()

	testComplex[complex64]()
	testComplex[Complex64]()

	{
		testComplexTop[complex128]()
		testComplex[Complex128]()

		// `complex128` is default type for complex literals.
		testReprZero([1]any{0i}, `[1]any{(0i)}`)
		testReprZero([1]any{10i + 20}, `[1]any{(20+10i)}`)
	}

	{
		testStringTop[string]()
		testStringTop[Str]()

		// `string` is default type for string literals.
		testReprZero([1]any{``}, "[1]any{``}")
		testReprZero([1]any{`str`}, "[1]any{`str`}")

		testReprZero([1]any{Str(``)}, "[1]any{grepr_test.Str(``)}")
		testReprZero([1]any{Str(`str`)}, "[1]any{grepr_test.Str(`str`)}")
	}
}

func testBoolTop[A ~bool]() {
	testReprZero[A](false, `false`)
	testReprZero[A](true, `true`)
}

func testByte[A ~byte](name string) {
	testByteTop[A]()
	testByteInner[A](name)
}

func testByteTop[A ~byte]() {
	testReprZero[A](0, `0x00`)
	testReprZero[A](10, `0x0a`)
	testReprZero[A](15, `0x0f`)
	testReprZero[A](16, `0x10`)
	testReprZero[A](17, `0x11`)
	testReprZero[A](255, `0xff`)
}

func testByteInner[A ~byte](name string) {
	testReprZero([1]any{A(0)}, `[1]any{`+name+`(0x00)}`)
	testReprZero([1]any{A(255)}, `[1]any{`+name+`(0xff)}`)
}

func testUint[A gg.Uint]() {
	testUintTop[A]()
	testUintInner[A]()
}

func testUintTop[A gg.Uint]() {
	testReprZero[A](0, `0`)
	testReprZero[A](10, `10`)
	testReprZero[A](16, `16`)
	testReprZero[A](255, `255`)
}

func testUintInner[A gg.Uint]() {
	name := gg.Type[A]().String()

	testReprZero([1]any{A(0)}, `[1]any{`+name+`(0)}`)
	testReprZero([1]any{A(255)}, `[1]any{`+name+`(255)}`)
}

func testSint[A gg.Sint]() {
	testSintTop[A]()
	testSignedInner[A]()
}

func testSintTop[A gg.Sint]() {
	testReprZero[A](0, `0`)
	testReprZero[A](10, `10`)
	testReprZero[A](16, `16`)
	testReprZero[A](127, `127`)
	testReprZero[A](-10, `-10`)
	testReprZero[A](-16, `-16`)
	testReprZero[A](-128, `-128`)
}

func testSignedInner[A gg.Signed]() {
	name := gg.Type[A]().String()

	testReprZero([1]any{A(0)}, `[1]any{`+name+`(0)}`)
	testReprZero([1]any{A(127)}, `[1]any{`+name+`(127)}`)
	testReprZero([1]any{A(-128)}, `[1]any{`+name+`(-128)}`)
}

func testFloat[A gg.Float]() {
	testFloatTop[A]()
	testSignedInner[A]()
}

func testFloatTop[A gg.Float]() {
	testReprZero[A](0, `0`)
	testReprZero[A](-10, `-10`)
	testReprZero[A](-10.5, `-10.5`)
	testReprZero[A](10, `10`)
	testReprZero[A](10.5, `10.5`)
	testReprZero[A](A(math.NaN()), `math.NaN()`)
	testReprZero[A](A(math.Inf(0)), `math.Inf(0)`)
	testReprZero[A](A(math.Inf(1)), `math.Inf(0)`)
	testReprZero[A](A(math.Inf(-1)), `math.Inf(-1)`)
}

func testComplex[A gg.Complex]() {
	testComplexTop[A]()
	testComplexInner[A]()
}

func testComplexTop[A gg.Complex]() {
	testReprZero[A](10i, `(10i)`)
	testReprZero[A](-10i, `(-10i)`)
	testReprZero[A](10i+20, `(20+10i)`)
	testReprZero[A](-10i+20, `(20-10i)`)
	testReprZero[A](10i-20, `(-20+10i)`)
	testReprZero[A](-10i-20, `(-20-10i)`)
	testReprZero[A](10+20i, `(10+20i)`)
	testReprZero[A](-10+20i, `(-10+20i)`)
	testReprZero[A](10-20i, `(10-20i)`)
	testReprZero[A](-10-20i, `(-10-20i)`)
}

func testComplexInner[A gg.Complex]() {
	name := gg.Type[A]().String()

	testReprZero([1]any{A(0i)}, `[1]any{`+name+`(0i)}`)
	testReprZero([1]any{A(10i + 20)}, `[1]any{`+name+`(20+10i)}`)
}

func testStringTop[A ~string]() {
	testReprZero[A](``, "``")
	testReprDef[A](``, "``")
	testString(testReprZero[A], testReprDef[A])
}

func testString[A gg.Text](testZero, testDef func(A, string)) {
	testStringPrintable(testZero, testDef)
	testStringNewlines(testZero, testDef)
}

func testStringPrintable[A gg.Text](testZero, testDef func(A, string)) {
	testZero(A(`one`), "`one`")
	testDef(A(`one`), "`one`")

	testZero(A(`one`), "`one`")
	testDef(A(`one`), "`one`")

	testZero(A(`"one"`), "`\"one\"`")
	testDef(A(`"one"`), "`\"one\"`")

	testZero(A("`one`"), "\"`one`\"")
	testDef(A("`one`"), "\"`one`\"")
}

func testStringNewlines[A gg.Text](testZero, testDef func(A, string)) {
	testZero(A("\n"), `"\n"`)
	testDef(A("\n"), "`\n`")

	testZero(A("\r"), `"\r"`)
	testDef(A("\r"), `"\r"`)

	testZero(A("\r\n"), `"\r\n"`)
	testDef(A("\r\n"), `"\r\n"`)

	testZero(A("one\ntwo"), `"one\ntwo"`)
	testDef(A("one\ntwo"), "`one\ntwo`")

	testZero(A("one\rtwo"), `"one\rtwo"`)
	testDef(A("one\rtwo"), `"one\rtwo"`)

	testZero(A("one\r\ntwo"), `"one\r\ntwo"`)
	testDef(A("one\r\ntwo"), `"one\r\ntwo"`)
}

func Test_bytes(t *testing.T) {
	defer gtest.Catch(t)

	t.Run(`empty`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero([]byte(nil), `nil`)
		testReprZero([]byte{}, `[]byte{}`)
	})

	t.Run(`text`, func(t *testing.T) {
		defer gtest.Catch(t)

		testZero := func(src []byte, exp string) { testReprZero(src, `[]byte(`+exp+`)`) }
		testDef := func(src []byte, exp string) { testReprDef(src, `[]byte(`+exp+`)`) }
		testString(testZero, testDef)
	})

	t.Run(`unprintable`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero(
			[]byte(`printable `+"\xff"),
			`[]byte{0x70, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0xff}`,
		)

		testReprZero(
			[]byte(`printable `+"\ufeff"),
			`[]byte{0x70, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0xef, 0xbb, 0xbf}`,
		)

		testReprZero(
			[]byte(`printable `+string(utf8.RuneError)),
			`[]byte{0x70, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0xef, 0xbf, 0xbd}`,
		)
	})

	t.Run(`typedef`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero(gg.Buf(nil), `nil`)
		testReprZero(gg.Buf{}, `gg.Buf{}`)
		testReprZero(gg.Buf(`str`), "gg.Buf(`str`)")
	})
}

func Benchmark_bytes_hex(b *testing.B) {
	defer gtest.Catch(b)

	src := []byte{0xf5, 0x92, 0x93, 0xec, 0x38, 0x8f, 0x21, 0xd3, 0x52, 0x5a, 0x09, 0x40, 0xb0, 0x72, 0x97, 0x90, 0x38, 0x4d, 0x1f, 0x52, 0x90, 0x4a, 0xe5, 0x33, 0x06, 0xf2, 0x8b, 0xb1, 0xbd, 0x94, 0xfc, 0x42, 0xf0, 0xdd, 0xcb, 0x77, 0xc5, 0x4f, 0xc9, 0x27, 0x84, 0xca, 0x1b, 0xad, 0xd3, 0x40, 0x3f, 0xf5, 0xcd, 0x0e, 0x6f, 0x43, 0x71, 0x9e, 0xb2, 0x66, 0x2f, 0x8e, 0x0c, 0x00, 0xe3, 0xdc, 0x47, 0x83, 0x65, 0x0f, 0x68, 0xbf, 0xb7, 0x0f, 0x5f, 0x01, 0x25, 0x35, 0x1b, 0xfd, 0xa6, 0xdc, 0x75, 0x63, 0xbf, 0xed, 0xc9, 0x52, 0x6e, 0x4e, 0x0b, 0xb1, 0xa3, 0xb0, 0x89, 0x38, 0xd5, 0x3e, 0xc8, 0xe9, 0x6f, 0x07, 0xf0, 0x11, 0x6e, 0x4a, 0x3a, 0x1f, 0xb7, 0x75, 0xcb, 0x64, 0xb9, 0x2f, 0xc2, 0x23, 0xbe, 0x09, 0x12, 0x67, 0xaf, 0xfa, 0xbb, 0xae, 0x8b, 0x25, 0x6e, 0x4a, 0x53, 0xb4, 0x9e, 0x08, 0xa0, 0x0c, 0x41, 0xfc, 0x7e, 0x8f, 0x57, 0x44, 0xbd, 0x93, 0x04, 0xa3, 0x36, 0xa3, 0x16, 0xf8, 0x9a, 0x1c, 0xd2, 0x01, 0x5b, 0x16, 0x0f, 0x11, 0x82, 0xc8, 0xc0, 0x25, 0xe5, 0x32, 0x3b, 0x63, 0xc0, 0x02, 0x30, 0x10, 0xf5, 0x35, 0x51, 0x80, 0x87, 0x39, 0x7d, 0x73, 0xbe, 0xca, 0xc0, 0x84, 0xcc, 0x69, 0x95, 0x1d, 0xcf, 0x59, 0x53, 0x3d, 0xf4, 0x60, 0x79, 0x44, 0xd2, 0xb4, 0x95, 0x82, 0x81, 0x3e, 0xe6, 0x11, 0xc1, 0xba, 0x85, 0xeb, 0x90, 0xb6, 0x78, 0x7f, 0xd1, 0x56, 0x99, 0xbe, 0xa1, 0xe9, 0x9c, 0xb8, 0x56, 0xc0, 0xd4, 0xcc, 0x16, 0x5a, 0x7e, 0xf2, 0x90, 0xc0, 0x26, 0x05, 0x49, 0x47, 0xf5, 0x49, 0x19, 0x68, 0x96, 0x6e, 0xe9, 0xe1, 0x60, 0x3d, 0x28, 0x18, 0x47, 0xc8, 0x90, 0x95, 0x19, 0xf2, 0xa8, 0xcf, 0x8b, 0x66, 0x51, 0xbe, 0xeb, 0xe7, 0x04, 0x61, 0x71, 0xd8, 0xa3, 0x6c, 0x59, 0x2e, 0xcc, 0x4c, 0xcc, 0xbf, 0xfd, 0x99, 0x26, 0x41, 0x28, 0x15, 0xb6, 0x76, 0x33, 0xad, 0x9f, 0x9d, 0xbc, 0x65, 0xef, 0x1f, 0x2d, 0x92, 0x07, 0xb5, 0x02, 0x52, 0x07, 0xd5, 0x2d, 0x98, 0x86, 0x22, 0x25, 0xd9, 0xae, 0x35, 0x91, 0xae, 0x59, 0x7c, 0xf8, 0xb4, 0xaa, 0xb2, 0xfa, 0xc2, 0xa1, 0x7d, 0x00, 0xea, 0x5d, 0x76, 0xff, 0xb2, 0xa8, 0xa2, 0x93, 0xa0, 0x24, 0xc3, 0xa9, 0x68, 0x84, 0x18, 0xc3, 0x5b, 0x85, 0xd5, 0x57, 0x73, 0xe0, 0xb0, 0xa1, 0xaa, 0xfd, 0xda, 0xb4, 0x5d, 0xb1, 0x3f, 0x0c, 0x3f, 0x8a, 0x80, 0x1c, 0xfe, 0x76, 0x89, 0x6e, 0xa1, 0x7e, 0xa7, 0x94, 0x69, 0x34, 0x54, 0x5a, 0x6f, 0x7a, 0x57, 0x89, 0x72, 0x76, 0x42, 0xc2, 0xa8, 0x1a, 0xda, 0xb9, 0xfc, 0x87, 0xe9, 0x14, 0x3e, 0xda, 0xf0, 0x73, 0x0e, 0xf5, 0xb0, 0x56, 0xf3, 0xd8, 0x89, 0x62, 0x63, 0x50, 0x48, 0x8f, 0xc5, 0x9c, 0x9f, 0x25, 0x92, 0x53, 0xca, 0x6d, 0x14, 0x7c, 0xfc, 0x32, 0x0c, 0x7a, 0x2b, 0x67, 0xd1, 0x0f, 0xc2, 0xcf, 0x97, 0x18, 0xd1, 0xe5, 0x1e, 0x7c, 0xf6, 0xe6, 0x52, 0x33, 0x50, 0xb2, 0xdf, 0xc4, 0x81, 0xcc, 0x3b, 0x20, 0xf7, 0x8b, 0x87, 0xa7, 0x9d, 0x18, 0xf9, 0xa4, 0x6c, 0x4e, 0xab, 0x20, 0xc5, 0x6d, 0x40, 0x22, 0xd9, 0x0a, 0x84, 0xec, 0x70, 0x38, 0x8a, 0x9a, 0x73, 0x95, 0xed, 0xb6, 0xef, 0x85, 0x47, 0x3d, 0x18, 0x9a, 0x3f, 0xab, 0x96, 0x45, 0x86, 0x2b, 0xe7, 0xc4, 0x14, 0x40, 0x92, 0x51, 0x67, 0x2a, 0x9d, 0x87, 0xda, 0x0b, 0x4b, 0xfc, 0x84, 0xfc, 0xe0, 0xb1, 0x3b, 0xb4, 0xf0, 0xbc, 0x67, 0xc3, 0xf1, 0x57, 0x4d, 0xb0, 0xf6, 0xe5, 0x10, 0xa7, 0x10, 0xa0, 0x1e, 0x55, 0xcd, 0x1d, 0x08, 0x3f, 0xe1, 0x19, 0x47, 0xa6, 0x84, 0x1e, 0x4a, 0xec, 0x03, 0xf5, 0x63, 0x59, 0xd8, 0x77, 0xaa, 0x26, 0x54, 0x05, 0xce, 0x50, 0x7d, 0x09, 0x7f, 0x7d, 0xe8, 0xa2, 0xe6, 0xb2, 0x84, 0xaa, 0x59, 0xbe, 0x57, 0x8a, 0xea, 0xd4, 0x97, 0x78, 0xf7, 0xfd, 0x26, 0x17, 0x41, 0x0c, 0x78, 0xae, 0xa2, 0x14, 0x6f, 0xe6, 0x09, 0x36, 0xc8, 0xe4, 0xdf, 0x45, 0x5a, 0x7e, 0x41, 0x82, 0x95, 0x47, 0x9e, 0xb4, 0x38, 0x8f, 0xcb, 0x09, 0xbc, 0xd4, 0x85, 0x96, 0x3c, 0xd3, 0xc0, 0x4f, 0xc5, 0xf1, 0x9c, 0x13, 0xfb, 0x23, 0x39, 0x23, 0x34, 0x40, 0x98, 0x21, 0x22, 0x48, 0x74, 0x7f, 0xb5, 0x4f, 0x41, 0x14, 0x76, 0xfb, 0x81, 0x75, 0x13, 0xcb, 0x3d, 0xfa, 0x8e, 0x7d, 0xa1, 0x36, 0x6a, 0x3f, 0x6b, 0xf2, 0xc8, 0xeb, 0x97, 0x29, 0x0b, 0xa9, 0x8d, 0x06, 0xa8, 0xad, 0x91, 0x66, 0x4a, 0x6d, 0x7a, 0x45, 0x92, 0x1c, 0x07, 0x8a, 0xe2, 0x16, 0x7d, 0xbb, 0xce, 0xec, 0x87, 0xf9, 0x42, 0xa6, 0xf1, 0xce, 0xa7, 0x80, 0xd7, 0x1e, 0xc4, 0x83, 0x14, 0x8f, 0xb3, 0xe7, 0x40, 0x04, 0x26, 0x7c, 0xec, 0x8a, 0x36, 0xad, 0x7b, 0x23, 0x4b, 0xdf, 0x8c, 0xd8, 0x45, 0xcd, 0x07, 0x39, 0x35, 0xf7, 0x2b, 0x98, 0xb2, 0xf9, 0xcc, 0xda, 0x60, 0xb3, 0x86, 0xa8, 0xee, 0xda, 0xbd, 0x5a, 0xc0, 0x50, 0x5a, 0x92, 0xf1, 0x9d, 0xc2, 0x6b, 0x85, 0xa6, 0x65, 0xe5, 0x25, 0xb8, 0xcb, 0xca, 0x72, 0x6a, 0x1a, 0x33, 0x1d, 0x2b, 0x73, 0xf2, 0xe9, 0xa9, 0x20, 0x85, 0x16, 0x46, 0xe2, 0x21, 0x9c, 0xe2, 0x2d, 0x77, 0xec, 0x98, 0x51, 0x9d, 0x91, 0x9d, 0xf9, 0x0a, 0xb0, 0xd4, 0x76, 0xd2, 0xb4, 0xa2, 0x26, 0x34, 0x6f, 0x40, 0xad, 0xd9, 0x23, 0xb8, 0x2d, 0xa9, 0x12, 0x00, 0xfe, 0x37, 0x2b, 0xc4, 0x78, 0x81, 0xa8, 0xfe, 0x0e, 0x0d, 0xe5, 0x00, 0x9b, 0xc0, 0x71, 0x46, 0x24, 0xe4, 0xc8, 0x39, 0x28, 0xad, 0x9c, 0xeb, 0x84, 0xb4, 0x47, 0x56, 0xe9, 0xa5, 0x9b, 0x60, 0x02, 0xb9, 0x90, 0x45, 0x70, 0x49, 0x18, 0x8c, 0x38, 0xce, 0xc7, 0x0b, 0xb5, 0xf3, 0xc5, 0xcb, 0xba, 0x8f, 0xe6, 0xb2, 0xb7, 0xb5, 0xc1, 0x53, 0x3d, 0x9c, 0x51, 0x10, 0x7e, 0xc5, 0xd7, 0x3a, 0x8e, 0x2a, 0xad, 0xbb, 0x4a, 0x8f, 0x76, 0x80, 0x7c, 0x9d, 0x5c, 0x94, 0x54, 0xf9, 0x6c, 0x4c, 0xbb, 0x25, 0x29, 0x3c, 0x85, 0xc6, 0x6f, 0xc7, 0x5e, 0xb0, 0x77, 0x22, 0x94, 0xc8, 0x91, 0x56, 0xdd, 0x04, 0x31, 0x90, 0x68, 0xdc, 0x20, 0x5a, 0xd8, 0xc1, 0xf3, 0x19, 0x88, 0xd9, 0x44, 0x27, 0x82, 0xd3, 0xe5, 0x5b, 0xd2, 0x0c, 0x06, 0x6c, 0xc4, 0xdd, 0xd5, 0x65, 0xd1, 0x22, 0xa1, 0x03, 0x51, 0x1c, 0x9a, 0xf1, 0x41, 0x2c, 0x3a, 0x30, 0x03, 0x8e, 0x57, 0x5d, 0x37, 0x9f, 0x56, 0x0d, 0xc0, 0xbf, 0xd5, 0x18, 0xe1, 0xef, 0xae, 0xa6, 0xf8, 0x3c, 0x92, 0xc3, 0x7d, 0x47, 0xa5, 0x45, 0x9f, 0xf2, 0x02, 0xda, 0xa4, 0xfe, 0xdc, 0x59, 0x2c, 0x15, 0xdc, 0x06, 0x3c, 0xbf, 0x01, 0x82, 0x72, 0x45, 0xc2, 0xa6, 0x26, 0x8a, 0xa0, 0xea, 0xe5, 0xf2, 0x5c, 0xd9, 0xac, 0xb0, 0x60, 0x66, 0x60, 0x25, 0xad, 0xc5, 0x75, 0x05, 0x9a, 0x85, 0x34, 0x0e, 0xac, 0x2e, 0xd2, 0x0f, 0xcb, 0xea, 0x35, 0x4f, 0xe8, 0x13, 0x0b, 0x0d, 0xfe, 0x48, 0x44, 0x48, 0x25, 0xea, 0x31, 0x56, 0x2d, 0x16, 0x4d, 0x2d, 0xc8, 0xd6, 0x8e, 0xeb, 0xb8, 0x74, 0x9e, 0x6d, 0x5f, 0x0a, 0x10, 0x70, 0x72, 0xb9, 0xec, 0x6e, 0x58, 0xc9, 0x43, 0xde, 0x5c, 0xa6, 0xf0, 0x1f, 0x78, 0x23, 0x3e, 0x3f, 0xe5, 0xbd, 0xf0, 0xb2, 0x6d, 0xa5, 0x1f, 0x90, 0x9a, 0x77, 0x48, 0x58, 0xa3, 0x8b, 0x34, 0x61, 0x75, 0x67, 0x52, 0x9f, 0x36, 0x1e, 0xa8, 0x52, 0x77, 0xbb, 0x05, 0x1c, 0xe9, 0xd1, 0xf7, 0x75, 0xae, 0xd5, 0xd2, 0xf7, 0x32, 0x5a, 0xa7, 0xa5, 0x8b, 0xc7, 0xda, 0x50, 0x8c, 0x33, 0x07, 0x80, 0xb5, 0xeb, 0xb3, 0xed, 0x17, 0xe2, 0x44, 0x65, 0x2a, 0x5c, 0x20, 0xe8, 0x45, 0xfd, 0x03, 0x06, 0xd8, 0xd9, 0x98, 0xc8, 0x04, 0x1a, 0xcb, 0x25, 0x8e, 0xa6, 0xb5, 0x0b, 0xa8, 0xcb, 0x2b, 0x56, 0xea, 0x08, 0x86, 0xf2, 0x4c, 0x60, 0xc9, 0x90, 0x9d, 0x2f, 0x31, 0x54, 0x87, 0xe6, 0xfb, 0x20, 0x8e, 0x3c, 0x4e, 0x46, 0x8a, 0xdd, 0x2e, 0xe3, 0x75, 0xad, 0x79, 0x43, 0x6e, 0x23, 0xc0, 0xde, 0x0e, 0x98, 0xab, 0x5e, 0x5a, 0x28, 0xd1, 0x16, 0x72, 0xb6, 0xfd, 0x91, 0xf0, 0x76, 0x50, 0xbc, 0x44, 0xbb, 0x63, 0x5d, 0xb5, 0x43, 0x21, 0xe5, 0x1f, 0xd8, 0x0f, 0x75, 0x48, 0x4a, 0xd8, 0xeb, 0x6b, 0xec, 0x6c, 0xa8, 0xa6, 0xb7, 0x32, 0x65, 0x61, 0xd6, 0xa1, 0xc0, 0x4e, 0x26, 0x4a, 0xf5, 0x44, 0x78, 0x5b, 0xeb, 0xc6, 0xc3, 0xb6, 0x80, 0x6e, 0x4a, 0x9c, 0x76, 0x10, 0x76, 0x1d, 0xf7, 0xfc, 0x24, 0x2f, 0x77, 0x91, 0xd0, 0xc7, 0xaa, 0xda, 0x10, 0xa2, 0xdf, 0x50, 0x75, 0x8e, 0x7d, 0x6b, 0xe4, 0x75, 0xf4, 0x9c, 0x7f, 0x71, 0x1f, 0x39, 0x19, 0x6a, 0x13, 0x8d, 0x1b, 0xcd, 0xc9, 0xb2, 0xac, 0x83, 0xfd, 0x80, 0xc8, 0xfa, 0x62, 0xa0, 0x17, 0xe2, 0x42, 0x91, 0xfe, 0x0d, 0x42, 0x8c, 0x46, 0x04, 0x33, 0x0c, 0xa2, 0x76, 0x92, 0x8d, 0xf7, 0xb6, 0xd9, 0x1c, 0xba, 0x94, 0xa2, 0xe5, 0xea, 0x51, 0x57, 0xd7, 0xef, 0x1b, 0xbf, 0xf7, 0x5b, 0x4c, 0x5b, 0xb4, 0x00, 0x49, 0x73, 0x48, 0x4f, 0xd2, 0x20, 0xc4, 0xd6, 0xe8, 0x81, 0xad, 0xfa, 0x9d, 0x43, 0x86, 0x91, 0xb8, 0xc2, 0xf2, 0xd4, 0x1a, 0x0c, 0xf5, 0x98, 0x73, 0x8b, 0x40, 0x8a, 0xe5, 0xdf, 0xea, 0x81, 0xfb, 0x89, 0xf8, 0xae, 0xbe, 0xd5, 0xc4, 0xf3, 0xb1, 0x90, 0x85, 0x68, 0x6c, 0xbb, 0xf7, 0xcd, 0x42, 0xd5, 0x60, 0x39, 0x53, 0xa7, 0xb4, 0xc6, 0x27, 0x19, 0x5b, 0xeb, 0x0e, 0x7f, 0xc0, 0xfd, 0xbf, 0xc8, 0x9a, 0x89, 0x28, 0x79, 0xd8, 0xea, 0xff, 0x2c, 0x83, 0x64, 0xbb, 0x8d, 0x35, 0x7b, 0xb9, 0xf6, 0xe7, 0x84, 0x5f, 0x3c, 0x24, 0xdc, 0x15, 0x1e, 0x1b, 0xc6, 0x11, 0x23, 0x0c, 0x0e, 0x6e, 0x40, 0x53, 0x20, 0xd2, 0xe7, 0x45, 0x9c, 0x6e, 0x68, 0xd1, 0x18, 0xd1, 0x2c, 0xc0, 0xd6, 0xbf, 0x06, 0x62, 0xad, 0x19, 0x89, 0x87, 0x2c, 0xf1, 0xad, 0x90, 0xcb, 0x07, 0x9f, 0xe1, 0x5a, 0x60, 0x77, 0x49, 0xac, 0x39, 0x07, 0x2d, 0x27, 0x26, 0xc6, 0x3e, 0x9b, 0x4c, 0x82, 0xa4, 0xeb, 0x4f, 0x62, 0x6d, 0xff, 0xa3, 0xe1, 0x26, 0xe0, 0x0f, 0xb9, 0xd6, 0x3c, 0x8e, 0xd8, 0x60, 0xc4, 0x7a, 0xc5, 0x06, 0xa8, 0x53, 0x49, 0x0d, 0x3b, 0xf8, 0xf6, 0xbe, 0xba, 0x9a, 0xbc, 0x7e, 0x86, 0x60, 0x81, 0xc1, 0x1c, 0xd2, 0xb9, 0xce, 0xa2, 0x08, 0x41, 0x5c, 0xcd, 0xdd, 0xa4, 0x89, 0x61, 0x1d, 0x27, 0x45, 0xd8, 0x27, 0x13, 0xfe, 0x9a, 0x93, 0xf4, 0xfb, 0x4b, 0x31, 0xb5, 0x39, 0x71, 0x17, 0x9d, 0xe9, 0x5c, 0x5d, 0x17, 0x8f, 0x86, 0x99, 0x2e, 0xbf, 0x97, 0xda, 0xff, 0xb6, 0xd3, 0x27, 0xbe, 0x3e, 0x79, 0xf0, 0xe1, 0xb7, 0x75, 0xc3, 0xa6, 0x8c, 0x0c, 0xfb, 0x38, 0x88, 0x21, 0x97, 0xdd, 0x3f, 0x48, 0x96, 0xb0, 0xcc, 0x37, 0xad, 0x43, 0x30, 0x40, 0x43, 0x37, 0xb8, 0x0d, 0x7d, 0xfa, 0xd1, 0x5d, 0x80, 0xc1, 0x77, 0xc1, 0xdb, 0x0e, 0x00, 0xa0, 0xe8, 0x3f, 0x09, 0x96, 0xa9, 0xc2, 0xd3, 0x2f, 0x02, 0xf7, 0x89, 0x2e, 0x0a, 0x50, 0x51, 0xc1, 0xba, 0x70, 0x14, 0x9f, 0xba, 0xec, 0x97, 0x11, 0x30, 0xe1, 0xb8, 0x9b, 0x2c, 0x3c, 0x59, 0x1b, 0x25, 0xf1, 0x73, 0xea, 0x43, 0x53, 0x44, 0x04, 0x4b, 0x7b, 0x87, 0x62, 0xe3, 0x95, 0xfe, 0x57, 0x5c, 0xaf, 0xf2, 0xfd, 0x49, 0x05, 0xdf, 0xa6, 0x7c, 0x44, 0xf7, 0x00, 0xf6, 0xf5, 0x35, 0x34, 0x26, 0x70, 0xe4, 0x4a, 0xf4, 0x85, 0x4d, 0x76, 0x58, 0xb9, 0x2d, 0x3c, 0x2f, 0x30, 0xe5, 0x9f, 0xd5, 0xca, 0xfe, 0x17, 0xae, 0x09, 0x7f, 0x4d, 0x37, 0xab, 0x35, 0xa8, 0xbc, 0x80, 0x73, 0x8b, 0x25, 0x24, 0x75, 0xc4, 0x2e, 0x41, 0x2a, 0xc0, 0xa0, 0x67, 0x1e, 0xcb, 0x6e, 0x0a, 0x4e, 0xfc, 0xc5, 0xe7, 0x2f, 0xf8, 0x90, 0xfb, 0x0b, 0xd6, 0xce, 0xf1, 0xa2, 0xd1, 0xb5, 0x47, 0x0e, 0x47, 0xdd, 0x5c, 0x84, 0x50, 0x28, 0x07, 0xf8, 0x5c, 0x91, 0xc9, 0x5c, 0xe4, 0xf4, 0xa8, 0x2e, 0x7a, 0x2a, 0x88, 0xfb, 0xd0, 0xfa, 0x51, 0x5f, 0xb6, 0x82, 0x65, 0x6d, 0x11, 0xce, 0xc9, 0xa2, 0x4b, 0x1b, 0xdd, 0xa8, 0xc7, 0x31, 0x2c, 0xad, 0x95, 0x31, 0xb2, 0xdb, 0xc0, 0x98, 0x6b, 0xc4, 0xf1, 0x73, 0xba, 0x51, 0x9f, 0xa9, 0xd2, 0x39, 0xed, 0xd6, 0xa1, 0xc6, 0x97, 0x7f, 0x57, 0xa5, 0xf4, 0x54, 0x49, 0xd8, 0xd9, 0x85, 0x76, 0x4c, 0x89, 0xea, 0xb0, 0x8a, 0xd1, 0x06, 0x90, 0x7c, 0xb1, 0xa4, 0x2b, 0xe0, 0x85, 0xb2, 0x53, 0x4e, 0x56, 0x5b, 0x42, 0x0e, 0x85, 0x3d, 0xe7, 0x5b, 0x58, 0x06, 0x1f, 0x4f, 0xaa, 0x45, 0xf5, 0x58, 0xef, 0xba, 0x14, 0x87, 0xda, 0x2d, 0xf5, 0xc8, 0x74, 0x24, 0x82, 0xa4, 0x5d, 0xe4, 0x12, 0x0a, 0x0e, 0x1f, 0x24, 0x37, 0xf5, 0x60, 0xe8, 0x70, 0x6e, 0xd0, 0xad, 0x69, 0x23, 0xd8, 0x79, 0xbd, 0xb2, 0x3e, 0xbe, 0x4d, 0x20, 0x32, 0x63, 0x2f, 0x6a, 0x2a, 0x93, 0xc4, 0x26, 0x4c, 0xd6, 0xf0, 0x6a, 0x08, 0x47, 0x84, 0x34, 0xff, 0xb9, 0x80, 0x32, 0xb1, 0xf8, 0x0e, 0x8b, 0x9f, 0x43, 0x87, 0x0e, 0x48, 0x4f, 0x89, 0x47, 0x71, 0x5c, 0x6f, 0x78, 0xd4, 0x5c, 0xc9, 0x0a, 0xf6, 0x58, 0x3a, 0xdb, 0x4f, 0xc1, 0x34, 0xe9, 0xce, 0x1c, 0x26, 0x16, 0xdb, 0x42, 0x23, 0x37, 0x12, 0x4f, 0xf6, 0x7c, 0x4b, 0x23, 0x65, 0xbb, 0x0f, 0x6f, 0x6d, 0x2c, 0x57, 0x61, 0xfc, 0x27, 0x78, 0x8d, 0xba, 0xc3, 0xba, 0x81, 0x79, 0xfe, 0xb0, 0x4b, 0x1a, 0x27, 0x48, 0xaa, 0x54, 0x23, 0x81, 0xd2, 0x63, 0x64, 0xfe, 0x0b, 0x88, 0xe5, 0x3a, 0x84, 0x50, 0xbd, 0x28, 0x31, 0x18, 0x93, 0x9a, 0xef, 0xc7, 0xad, 0x5c, 0x2d, 0x83, 0x39, 0x3b, 0x26, 0x03, 0x71, 0x31, 0x0b, 0x0c, 0xda, 0x57, 0x22, 0x02, 0x2c, 0x97, 0x8c, 0x16, 0xe4, 0x17, 0x87, 0x29, 0x11, 0xa4, 0xa3, 0x67, 0x15, 0xf5, 0xee, 0x05, 0xcb, 0x13, 0x33, 0x90, 0xc1, 0x36, 0xea, 0xd4, 0xe8, 0x08, 0x82, 0xa3, 0xb1, 0x8d, 0xe5, 0x48, 0x4e, 0x24, 0xe6, 0x3b, 0x52, 0x81, 0x78, 0x7d, 0xd0, 0x1c, 0xae, 0xb5, 0xa6, 0xa9, 0x3b, 0x28, 0x55, 0x2f, 0x75, 0x5b, 0x7c, 0xd8, 0x56, 0x9c, 0x66, 0xc2, 0x33, 0x2d, 0xe9, 0x49, 0x51, 0x06, 0x62, 0x73, 0xda, 0xde, 0x69, 0x97, 0xc7, 0x8d, 0x8f, 0x87, 0x3a, 0x2f, 0xae, 0xb0, 0xe8, 0xb9, 0x2a, 0x9f, 0x12, 0x24, 0xb5, 0x4d, 0x80, 0xc3, 0x43, 0xf6, 0xb9, 0x9f, 0xb1, 0x67, 0xc5, 0xb2, 0x74, 0x09, 0x9b, 0x4b, 0x95, 0xe9, 0x46, 0xb1, 0x48, 0xa9, 0x3b, 0xd5, 0xb7, 0xc8, 0x13, 0xf8, 0xac, 0x65, 0x4a, 0xe9, 0xc0, 0x30, 0x80, 0x5e, 0x30, 0x2e, 0xda, 0xc8, 0x69, 0x71, 0xd0, 0x28, 0x98, 0xcc, 0x9f, 0xb6, 0x0a, 0xcb, 0x80, 0x5a, 0x62, 0x13, 0x9e, 0xa0, 0x54, 0x1b, 0x15, 0xc3, 0xea, 0x74, 0xd7, 0x2b, 0xbc, 0xd6, 0x7d, 0x7b, 0x8e, 0xd7, 0x19, 0x7b, 0x8a, 0xf9, 0x46, 0x1c, 0xf6, 0x04, 0x76, 0xed, 0x7f, 0xa6, 0xe9, 0xbc, 0xfd, 0x07, 0x7d, 0x06, 0x7c, 0x4a, 0x26, 0xb4, 0xa5, 0x36, 0xee, 0x18, 0x24, 0x93, 0x56, 0x0f, 0x6d, 0xb8, 0xb1, 0x08, 0x0c, 0x6b, 0xb4, 0x60, 0x80, 0xea, 0x73, 0xee, 0x47, 0x0f, 0x08, 0x52, 0xf4, 0x83, 0x44, 0x22, 0x30, 0x8d, 0x5c, 0x1e, 0xf1, 0x2b, 0x3e, 0xbd, 0xb4, 0xda, 0x37, 0xed, 0x0a, 0xf9, 0xb1, 0x01, 0x81, 0xfe, 0x52, 0x49, 0x49, 0x4f, 0x20, 0x7c, 0x73, 0x02, 0x93, 0x94, 0x3d, 0x1f, 0x5d, 0xa4, 0x85, 0xb9, 0xcd, 0x19, 0xe5, 0x84, 0x1d, 0xc4, 0x4d, 0x7a, 0x9c, 0x09, 0x8c, 0xf0, 0x12, 0xdc, 0xfa, 0xee, 0xb9, 0x5a, 0x2e, 0x60, 0x67, 0x84, 0x14, 0xc8, 0xdf, 0x34, 0x3c, 0x35, 0x0b, 0x42, 0x18, 0x24, 0x9a, 0xdc, 0x99, 0x76, 0x15, 0xf9, 0xd0, 0x12, 0x3b, 0x97, 0xa8, 0x31, 0xda, 0x5f, 0xbc, 0xb0, 0xca, 0x32, 0xfc, 0x5b, 0x67, 0x5e, 0xd0, 0xd5, 0xba, 0xed, 0x2e, 0x9c, 0x35, 0x1e, 0x2e, 0x22, 0x83, 0xb7, 0x72, 0xab, 0x1c, 0x2c, 0x2d, 0x23, 0x4f, 0x3a, 0xd8, 0xe1, 0x28, 0xbd, 0x28, 0xf1, 0x04, 0x14, 0x34, 0x54, 0x5c, 0xcc, 0xf0, 0xed, 0xe3, 0x0f, 0x9f, 0x11, 0x60, 0x0f, 0x5b, 0xfd, 0x4b, 0x39, 0xd6, 0xcd, 0x2f, 0x42, 0x82, 0xa9, 0xb5, 0x0a, 0x02, 0x22, 0xe8, 0x07, 0x55, 0xed, 0x1c, 0x31, 0x35, 0xc6, 0x60, 0x4d, 0xb6, 0xac, 0x42, 0x30, 0x0c, 0xc5, 0x97, 0x21, 0xee, 0xa2, 0xb2, 0x5d, 0x8a, 0x7b, 0xc3, 0xd6, 0x90, 0xd4, 0xd1, 0x25, 0x50, 0xeb, 0x32, 0x82, 0xe8, 0xcc, 0xa0, 0x31, 0xef, 0x7e, 0x19, 0xdc, 0x25, 0x72, 0xd6, 0xec, 0x0a, 0x94, 0xab, 0xd2, 0x10, 0x60, 0xe3, 0x1f, 0xbd, 0xc7, 0x94, 0x6a, 0xfa, 0x82, 0x0c, 0xff, 0x27, 0xdd, 0x59, 0x70, 0x12, 0xa0, 0x5e, 0x9e, 0xe1, 0x9c, 0xc7, 0xc8, 0x4b, 0x10, 0xf2, 0x3a, 0x20, 0xd2, 0x9c, 0x66, 0xa5, 0xf1, 0x3d, 0x48, 0x26, 0x7b, 0xa2, 0xd1, 0xbc, 0x24, 0x73, 0x0b, 0x02, 0x36, 0xd6, 0x8d, 0xe0, 0x0f, 0x69, 0x6f, 0x8d, 0xef, 0x48, 0x31, 0xf7, 0x35, 0x14, 0xa2, 0x47, 0x0b, 0x1e, 0x8f, 0x5e, 0xe1, 0x3a, 0x21, 0xd1, 0x64, 0x85, 0x2b, 0xa2, 0x62, 0x2d, 0x6e, 0xc1, 0x14, 0x5c, 0x0f, 0x0f, 0xed, 0x84, 0xa6, 0x25, 0x72, 0xb8, 0x9f, 0x5a, 0xcb, 0x58, 0x9f, 0xd9, 0xdd, 0x4a, 0xb2, 0xda, 0xf1, 0x45, 0x4d, 0x1d, 0xc0, 0x52, 0x75, 0xc6, 0x73, 0xd9, 0x87, 0x80, 0xc4, 0x6f, 0xfc, 0x61, 0xb7, 0xa1, 0x93, 0x91, 0x15, 0xb8, 0x00, 0x65, 0x5f, 0x5c, 0xa5, 0x3d, 0x9f, 0x27, 0xe3, 0x37, 0x2c, 0x94, 0x51, 0xdd, 0x08, 0x74, 0x8d, 0x3d, 0x12, 0x05, 0xcd, 0xa6, 0x26, 0x46, 0x20, 0xcd, 0x84, 0xe3, 0x64, 0x07, 0x7a, 0x04, 0x5e, 0xc4, 0x33, 0xb1, 0xd0, 0x62, 0xa6, 0x67, 0x3a, 0x18, 0x1f, 0x3a, 0xf5, 0x0d, 0xc5, 0x6b, 0x51, 0xa0, 0x33, 0x19, 0x88, 0x91, 0x1e, 0xf2, 0x63, 0x07, 0x8c, 0x96, 0xa6, 0xbd, 0xc7, 0xd3, 0x18, 0x64, 0xa7, 0x8b, 0x19, 0x11, 0xbc, 0xb0, 0x06, 0x56, 0x98, 0xf0, 0x58, 0xdc, 0x85, 0xc8, 0xed, 0x4e, 0x19, 0x3b, 0x01, 0xb1, 0xf5, 0xad, 0x3d, 0x54, 0xcd, 0xde, 0xd1, 0x1a, 0x30, 0x60, 0x34, 0xd5, 0xa4, 0xab, 0x43, 0x61, 0x74, 0x02, 0xf9, 0xe9, 0x16, 0x42, 0x54, 0xd7, 0x50, 0x84, 0xd0, 0xdc, 0xe2, 0x45, 0xe3, 0xc6, 0xac, 0xe6, 0x7b, 0x93, 0x7e, 0x66, 0x84, 0x9a, 0x72, 0xa7, 0xf6, 0x86, 0xae, 0x42, 0xb1, 0xa5, 0xeb, 0xb9, 0xa2, 0xb8, 0x3f, 0xd3, 0xfd, 0x50, 0xe3, 0xc8, 0x1a, 0xe4, 0x66, 0x67, 0xec, 0xa1, 0x05, 0xa6, 0x71, 0x9e, 0xf6, 0x93, 0xff, 0xfe, 0x4f, 0x8e, 0x08, 0xe5, 0x0a, 0x90, 0x8e, 0x39, 0xa8, 0xaf, 0x06, 0x46, 0xdb, 0x85, 0xa9, 0xe4, 0xef, 0x28, 0x8d, 0x6a, 0x81, 0x8c, 0xa5, 0x17, 0x8c, 0xcf, 0xa2, 0xda, 0x5a, 0x8d, 0xbd, 0xeb, 0x76, 0x9f, 0x78, 0x5f, 0x07, 0xd0, 0x68, 0xf3, 0x2c, 0x92, 0x92, 0x09, 0x95, 0xb0, 0xf0, 0x5f, 0xc4, 0x59, 0xe5, 0xd9, 0x37, 0x56, 0x22, 0xdb, 0x9d, 0xd5, 0xfa, 0x26, 0x77, 0x58, 0x9c, 0x2f, 0xc6, 0xb1, 0x1a, 0x7d, 0xc5, 0x6f, 0x28, 0x7b, 0xad, 0xd9, 0x81, 0x99, 0x61, 0x6a, 0xb7, 0x3f, 0xe4, 0x84, 0x50, 0xcb, 0x3e, 0x9c, 0x79, 0xbb, 0x22, 0x01, 0xfa, 0x39, 0xc3, 0x8c, 0x61, 0x3c, 0x1d, 0xa7, 0x4c, 0x6a, 0xbf, 0x7f, 0x8b, 0x7b, 0x8d, 0x4c, 0xa9, 0x5b, 0x3a, 0x24, 0x50, 0x44, 0x19, 0x86, 0x42, 0x48, 0x4d, 0xf6, 0x47, 0x10, 0x68, 0x39, 0x42, 0x46, 0x68, 0xff, 0x12, 0x0f, 0x9d, 0xe3, 0xde, 0x1e, 0x9f, 0x5f, 0xa1, 0x16, 0x7e, 0x09, 0xff, 0xc9, 0x68, 0x8f, 0xaf, 0x30, 0xc3, 0x89, 0xb5, 0xdf, 0x45, 0x94, 0xf9, 0x32, 0x5c, 0x51, 0x41, 0x88, 0x78, 0xe1, 0x02, 0x1b, 0xac, 0xde, 0xbb, 0xa6, 0x32, 0x86, 0xc1, 0xd5, 0xf6, 0x5b, 0xef, 0x7a, 0x6e, 0x26, 0x56, 0xe0, 0x0f, 0x2b, 0x01, 0x10, 0x99, 0xb7, 0x77, 0x7d, 0xe9, 0x49, 0x13, 0x40, 0x96, 0x82, 0xec, 0x30, 0x9c, 0xa2, 0xff, 0x2c, 0x60, 0xa8, 0xb8, 0x46, 0x84, 0xe0, 0xa3, 0xd2, 0x5e, 0x8f, 0xf0, 0x8a, 0x44, 0x4f, 0x98, 0xdf, 0x60, 0x0a, 0x3a, 0xc2, 0x2c, 0xab, 0x6e, 0xc8, 0x32, 0xb8, 0x80, 0xdd, 0xc9, 0x96, 0xe1, 0x4c, 0x68, 0xd9, 0xbd, 0x15, 0xcf, 0xae, 0xd3, 0xaf, 0xac, 0x92, 0x1c, 0x33, 0xe8, 0xab, 0x87, 0x27, 0x6b, 0x39, 0x20, 0x69, 0x39, 0xf8, 0x35, 0xb1, 0xde, 0x1a, 0xbf, 0x10, 0x8e, 0x6f, 0x50, 0x1f, 0x85, 0x5d, 0x5a, 0x78, 0xd8, 0x17, 0x17, 0x40, 0xda, 0x54, 0xa2, 0xb4, 0xb2, 0xdc, 0xe8, 0x84, 0x62, 0xba, 0x7f, 0xb6, 0x3f, 0x17, 0x52, 0x1d, 0xce, 0x15, 0x66, 0x98, 0xd0, 0x95, 0xc6, 0x19, 0x51, 0x10, 0xbd, 0xa7, 0x66, 0x94, 0x1a, 0xa0, 0xa3, 0x62, 0x19, 0xa6, 0xb2, 0xba, 0xff, 0x06, 0xd6, 0x7e, 0x5a, 0x35, 0xbe, 0x67, 0x34, 0xfb, 0xdf, 0xda, 0x7c, 0x93, 0xfa, 0x80, 0x99, 0xdd, 0x24, 0x8f, 0xf5, 0xaa, 0xa6, 0xa5, 0x72, 0x1b, 0xb1, 0xa1, 0xf2, 0x34, 0xb0, 0x30, 0x14, 0x9d, 0x1b, 0xad, 0x57, 0xff, 0xce, 0x63, 0x28, 0x0e, 0xb8, 0xf8, 0xb5, 0x36, 0xda, 0x8e, 0xd3, 0x64, 0x77, 0x83, 0x8b, 0xe4, 0x42, 0xb8, 0x30, 0x4f, 0x52, 0x4e, 0x2e, 0x74, 0x3c, 0xdc, 0xbd, 0x3b, 0x22, 0x2d, 0xe4, 0x3a, 0xee, 0xfe, 0x9c, 0x40, 0xf2, 0xe6, 0xcb, 0xd6, 0x6b, 0xf9, 0x2e, 0x28, 0x87, 0x85, 0xb8, 0x88, 0x55, 0x63, 0x3e, 0x56, 0x0d, 0x4d, 0x4a, 0xcc, 0xf1, 0x41, 0xe1, 0xa8, 0x10, 0xe8, 0x0a, 0xdc, 0x33, 0xe1, 0xff, 0xc3, 0x59, 0xfb, 0x8a, 0x1e, 0x22, 0x3e, 0x76, 0xa9, 0xe8, 0x46, 0x7d, 0xf0, 0x0f, 0x3c, 0x1d, 0xa3, 0x58, 0x7d, 0xfb, 0x3d, 0xd8, 0x46, 0xdb, 0xcc, 0xab, 0xac, 0xd0, 0xd2, 0xd6, 0x13, 0x0f, 0x50, 0x18, 0xa4, 0x48, 0xd0, 0xc9, 0x47, 0xda, 0x77, 0x11, 0x63, 0x80, 0x22, 0x1d, 0xfd, 0x8a, 0x2e, 0x5b, 0x31, 0x1d, 0xec, 0xcb, 0xc4, 0x11, 0x93, 0xae, 0x32, 0x53, 0x0c, 0x4e, 0xad, 0x99, 0xbc, 0xb0, 0x74, 0x4b, 0xd9, 0xe6, 0xdd, 0x25, 0x56, 0x39, 0xdb, 0x93, 0x0f, 0x71, 0x32, 0xb9, 0xd3, 0x41, 0x45, 0xdc, 0xc7, 0x72, 0x8d, 0x6a, 0x1e, 0xab, 0x3e, 0x02, 0x95, 0x8d, 0xa4, 0x81, 0x73, 0x6f, 0x65, 0x19, 0x23, 0xd8, 0xf1, 0xc5, 0xba, 0x28, 0x11, 0xb3, 0xfe, 0x12, 0xad, 0x88, 0xfe, 0xa4, 0xfa, 0x0d, 0x95, 0xd2, 0x4d, 0x09, 0x7b, 0x95, 0x71, 0x36, 0xff, 0x7d, 0x32, 0x89, 0xf1, 0xc3, 0x86, 0x79, 0x6e, 0xef, 0x0b, 0x46, 0x5f, 0x32, 0x4b, 0x23, 0x7d, 0x0e, 0xf0, 0x1f, 0x55, 0x35, 0x87, 0x01, 0x03, 0x4f, 0x65, 0xcc, 0x49, 0x9b, 0x11, 0xe6, 0x59, 0x03, 0x6d, 0xbc, 0x8f, 0x8f, 0x1f, 0xa0, 0x25, 0x14, 0x6c, 0x7d, 0x75, 0xbe, 0xd4, 0x75, 0xdb, 0x74, 0xa3, 0x0c, 0xd9, 0x8f, 0x5c, 0x29, 0xa5, 0xd4, 0x05, 0xd0, 0x28, 0xba, 0x21, 0xf9, 0x60, 0x08, 0x28, 0xd1, 0xd5, 0x57, 0x16, 0x4d, 0xae, 0xa6, 0xfe, 0xe5, 0x61, 0x60, 0x72, 0xfc, 0xc2, 0x7b, 0xe9, 0xf0, 0x50, 0xab, 0x62, 0xbe, 0x4e, 0xfb, 0xdf, 0xf6, 0x82, 0x09, 0x4b, 0xb4, 0xc7, 0xb5, 0x2b, 0x6e, 0x8a, 0x31, 0xa1, 0xce, 0xc5, 0x1a, 0x81, 0x9e, 0xd0, 0x04, 0x2c, 0x52, 0x21, 0xc2, 0xde, 0xbf, 0xeb, 0xfb, 0x91, 0xa9, 0xff, 0x41, 0xd5, 0x4e, 0xb3, 0xf1, 0xc7, 0xb5, 0xf9, 0x00, 0x9c, 0x68, 0x61, 0xfc, 0xc5, 0x4f, 0x1c, 0x0e, 0xd1, 0xe8, 0xcb, 0x68, 0xec, 0x38, 0x66, 0x3c, 0x2f, 0x14, 0xc1, 0xa5, 0x5d, 0xe2, 0xe8, 0x3f, 0xe5, 0xe2, 0xef, 0x17, 0xf1, 0x18, 0x45, 0x6a, 0xe4, 0xea, 0xaa, 0x92, 0x86, 0x2b, 0x92, 0x8c, 0x63, 0x94, 0xf8, 0x5f, 0x58, 0x84, 0x5c, 0xf3, 0xc4, 0x31, 0xd2, 0x77, 0xa4, 0xaa, 0x63, 0xb5, 0x60, 0xde, 0x52, 0xa8, 0x39, 0x99, 0x08, 0x59, 0x6b, 0x09, 0xbc, 0x1b, 0x51, 0xc7, 0x4d, 0xf5, 0x1b, 0xe5, 0x84, 0xa1, 0xc1, 0x4c, 0xc4, 0xba, 0xbc, 0x75, 0x4a, 0x13, 0xef, 0x3f, 0x5f, 0x65, 0x56, 0x33, 0x4b, 0x24, 0x5c, 0x91, 0xb5, 0xb6, 0x69, 0x0c, 0x4c, 0x9d, 0xd2, 0xa4, 0xd8, 0x29, 0xf9, 0x7e, 0x84, 0xec, 0x07, 0xe0, 0x92, 0xae, 0x61, 0x1d, 0xd4, 0xe0, 0x9f, 0xd7, 0xc6, 0x96, 0x8d, 0x37, 0x7d, 0xe8, 0x64, 0x11, 0x30, 0x0f, 0x50, 0x16, 0x9e, 0xcd, 0x62, 0xbe, 0x93, 0x03, 0xdb, 0x1b, 0xd0, 0xba, 0xd3, 0x77, 0x91, 0x8b, 0x35, 0x70, 0xa1, 0x46, 0xd1, 0x2a, 0x68, 0x82, 0x7e, 0x19, 0x3d, 0xa8, 0x42, 0xf8, 0x9b, 0x72, 0xf7, 0x7d, 0xa2, 0xcb, 0xe8, 0x9a, 0x7b, 0x87, 0x14, 0xe7, 0x18, 0x2b, 0xc3, 0xba, 0x47, 0xad, 0xdb, 0xa6, 0x1a, 0x00, 0x0b, 0x73, 0x67, 0x32, 0x8c, 0x28, 0x94, 0x66, 0x71, 0xed, 0x57, 0x27, 0x59, 0xf8, 0xac, 0x67, 0x91, 0x25, 0x02, 0xfe, 0xe9, 0x37, 0xc0, 0x1e, 0x14, 0xee, 0x8b, 0x4d, 0x7f, 0x97, 0xfe, 0x5a, 0x1f, 0x80, 0x44, 0xde, 0x21, 0x8a, 0x20, 0xb3, 0xa1, 0x81, 0x53, 0x73, 0xa2, 0x2a, 0xad, 0x3e, 0x31, 0x50, 0x82, 0xcd, 0xb5, 0x78, 0x5d, 0xf6, 0xf9, 0x97, 0xd6, 0x51, 0xd2, 0x14, 0x6d, 0xc8, 0xcf, 0xca, 0x2a, 0x85, 0xd9, 0x35, 0x19, 0xe4, 0x6b, 0x70, 0xef, 0x76, 0xf8, 0xaa, 0x92, 0xa1, 0xe2, 0x74, 0x52, 0x71, 0x75, 0x10, 0xf1, 0xca, 0x72, 0x0a, 0xbf, 0x52, 0x30, 0x44, 0xf2, 0x1b, 0xee, 0x53, 0x7c, 0x34, 0x43, 0xb9, 0xfb, 0x06, 0x96, 0x5e, 0xe6, 0x79, 0x10, 0xea, 0xd5, 0x2a, 0xe4, 0x90, 0x24, 0x20, 0x53, 0x32, 0xb2, 0x19, 0xe8, 0x58, 0x0a, 0xd1, 0x8a, 0x7a, 0xac, 0x09, 0xb1, 0x8e, 0x50, 0xc9, 0xa9, 0x28, 0x97, 0x88, 0x25, 0x18, 0x73, 0x55, 0x1c, 0xb3, 0xdb, 0x40, 0x01, 0xe5, 0x24, 0x9d, 0x85, 0xa3, 0xb3, 0xac, 0x3d, 0x44, 0x50, 0xe5, 0x0d, 0xa3, 0xfd, 0x2f, 0x5f, 0x59, 0x25, 0x2c, 0x03, 0x57, 0x35, 0x02, 0x28, 0x4d, 0xa0, 0x99, 0xb3, 0xeb, 0x6f, 0x4c, 0x4d, 0x87, 0x87, 0x9a, 0x18, 0x8a, 0xaf, 0xcc, 0x85, 0x73, 0x05, 0xa6, 0x70, 0x25, 0x51, 0x4b, 0xd1, 0xa0, 0x18, 0x44, 0x02, 0xaa, 0xc4, 0x78, 0xf0, 0x56, 0x8e, 0x16, 0x3a, 0x06, 0xd7, 0x80, 0xda, 0x62, 0x57, 0xfe, 0xd5, 0x2b, 0xb4, 0xbb, 0x53, 0xfd, 0x20, 0x49, 0xcb, 0xd6, 0x2a, 0xd6, 0xe7, 0x13, 0xc4, 0xe4, 0x6b, 0x72, 0x74, 0xa5, 0xf2, 0xdd, 0x16, 0x71, 0xb3, 0xe7, 0xf6, 0x9a, 0x8e, 0x50, 0xa7, 0x40, 0x9b, 0xff, 0x8f, 0x31, 0x15, 0xf4, 0x0b, 0xb0, 0x99, 0x80, 0xb5, 0x98, 0xff, 0x17, 0xc4, 0x1f, 0x4b, 0xc9, 0xc9, 0xb8, 0xfd, 0xe6, 0xd5, 0x7d, 0xc2, 0x9b, 0x8b, 0x7d, 0x1e, 0x42, 0xdd, 0x81, 0x77, 0xbf, 0xa8, 0x56, 0x30, 0x27, 0x2a, 0xdb, 0x5a, 0x1a, 0x20, 0x03, 0x10, 0xae, 0x83, 0x72, 0xe2, 0xe0, 0xf3, 0xa9, 0x2b, 0x16, 0x82, 0x0b, 0x93, 0x7a, 0x68, 0xf1, 0xcd, 0xd5, 0xc8, 0x7b, 0xff, 0x13, 0x72, 0xa5, 0xc4, 0xb5, 0x0c, 0x52, 0x1a, 0xc6, 0xfc, 0xf1, 0x55, 0x9d, 0xb4, 0x19, 0x2e, 0xcb, 0x24, 0xe5, 0xf4, 0x76, 0x25, 0xa1, 0xe3, 0x22, 0xfb, 0xc8, 0x3b, 0xb8, 0x65, 0x07, 0xf7, 0x68, 0x03, 0x40, 0x02, 0xfe, 0x2f, 0x34, 0xad, 0x02, 0xbf, 0x60, 0xfb, 0x6b, 0xa7, 0xa3, 0xd0, 0x9e, 0x56, 0x24, 0xa3, 0xdc, 0xca, 0xf5, 0x75, 0xf3, 0xd6, 0x49, 0xd1, 0xed, 0x3a, 0x7c, 0x6e, 0x44, 0x80, 0x0c, 0xba, 0xef, 0x77, 0x0c, 0x53, 0x58, 0xba, 0x0d, 0xf2, 0xe2, 0x64, 0x8c, 0x0c, 0x2b, 0x49, 0xbb, 0x70, 0x9e, 0x5f, 0x6f, 0xcc, 0x74, 0x78, 0x32, 0xda, 0x78, 0x82, 0x82, 0x34, 0x18, 0x38, 0x2e, 0xd0, 0xc4, 0x58, 0x80, 0x6e, 0x8a, 0x57, 0x57, 0xd2, 0x3f, 0xb5, 0xc9, 0xea, 0xcc, 0xab, 0xca, 0x68, 0xc9, 0x6e, 0xb9, 0x42, 0xc4, 0x87, 0x4f, 0x49, 0x0c, 0x3e, 0xb5, 0x35, 0x85, 0xce, 0xcb, 0xe3, 0xa2, 0xae, 0x1e, 0xa5, 0x78, 0xbd, 0x1e, 0xdd, 0x34, 0x50, 0x59, 0x86, 0xb1, 0x93, 0x05, 0x5a, 0x84, 0x68, 0x24, 0xb2, 0x90, 0xe6, 0x66, 0xef, 0x78, 0xef, 0x83, 0x79, 0x34, 0xf6, 0x2e, 0x26, 0x8d, 0x3c, 0x00, 0xef, 0x60, 0x6f, 0x34, 0x93, 0x0a, 0xd4, 0x4a, 0x8d, 0x92, 0x4b, 0x81, 0x14, 0x34, 0x76, 0xc8, 0x87, 0x53, 0x3f, 0x06, 0xa7, 0xe5, 0xfe, 0x46, 0x59, 0xf4, 0x6a, 0xd3, 0x5a, 0x52, 0x5a, 0xf4, 0xe8, 0x6f, 0xf4, 0x57, 0x41, 0x0d, 0x8d, 0xec, 0x21, 0x5a, 0xd5, 0x7d, 0xae, 0x85, 0xc3, 0xa1, 0x2c, 0x47, 0x7d, 0xf4, 0x92, 0xe6, 0x2a, 0x86, 0xd9, 0x82, 0x5f, 0xe8, 0xfb, 0xa0, 0xf7, 0xf2, 0x20, 0x71, 0xcd, 0x47, 0x1c, 0xa7, 0xb0, 0x47, 0x59, 0x20, 0x5c, 0x35, 0x0d, 0x42, 0x2c, 0xb4, 0xce, 0x81, 0xc0, 0xf5, 0x67, 0x14, 0xe7, 0xcf, 0x87, 0xf6, 0xea, 0xdd, 0x14, 0xf2, 0x6b, 0xdc, 0xc1, 0x9c, 0x3e, 0x6f, 0xff, 0xd1, 0x84, 0x45, 0x38, 0xf6, 0x5d, 0x54, 0xda, 0xc8, 0xd1, 0xfe, 0x6a, 0x4d, 0xa1, 0x5f, 0xec, 0xaf, 0x24, 0xef, 0x89, 0x98, 0x70, 0xae, 0x38, 0x04, 0x8b, 0x16, 0x93, 0xa2, 0x73, 0xe2, 0x33, 0x5e, 0x4c, 0x94, 0x9e, 0x32, 0x57, 0xab, 0x19, 0xea, 0x1d, 0x83, 0xb2, 0xa8, 0x8f, 0x41, 0xd9, 0xc0, 0xc9, 0x20, 0x00, 0x2e, 0xf9, 0x7a, 0x1a, 0x01, 0xa6, 0xd9, 0xa7, 0x5f, 0x41, 0xf9, 0xdc, 0x42, 0x0c, 0x3a, 0x0e, 0x92, 0xf0, 0xe9, 0xdd, 0x5a, 0x60, 0xfd, 0xe9, 0x81}
	var conf grepr.Conf

	for ind := 0; ind < b.N; ind++ {
		grepr.StringC(conf, src)
	}
}

func Test_slices(t *testing.T) {
	defer gtest.Catch(t)

	testReprZero([]int(nil), `nil`)
	testReprZero([]int{}, `[]int{}`)
	testReprZero([]int{10, 20, 30}, `[]int{10, 20, 30}`)

	testReprDef([]int(nil), `nil`)
	testReprDef([]int{}, `[]int{}`)
	testReprDef([]int{10, 20, 30}, `[]int{
    10,
    20,
    30,
}`)

	testReprZero([]any(nil), `nil`)
	testReprZero([]any{}, `[]any{}`)
	testReprZero([]any{true, 10}, `[]any{true, 10}`)
	testReprZero([]any{Bool(true), Int(10)}, `[]any{grepr_test.Bool(true), grepr_test.Int(10)}`)

	testReprDef([]any(nil), `nil`)
	testReprDef([]any{}, `[]any{}`)
	testReprDef([]any{true, 10}, `[]any{
    true,
    10,
}`)
	testReprDef([]any{Bool(true), Int(10)}, `[]any{
    grepr_test.Bool(true),
    grepr_test.Int(10),
}`)

	testReprZero([]string(nil), `nil`)
	testReprDef([]string(nil), `nil`)

	testReprZero([]string{}, `[]string{}`)
	testReprDef([]string{}, `[]string{}`)

	testReprZero([]string{`one`}, "[]string{`one`}")
	testReprDef([]string{`one`}, `[]string{
    `+"`one`"+`,
}`)

	testReprZero([]string{`one`, `two`}, "[]string{`one`, `two`}")
	testReprDef([]string{`one`, `two`}, `[]string{
    `+"`one`"+`,
    `+"`two`"+`,
}`)
}

func Test_slice_type_elision(t *testing.T) {
	defer gtest.Catch(t)

	t.Run(`in_slice_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero(
			[][]int{nil, {}, {10, 20}, {30, 40, 50}},
			`[][]int{nil, {}, {10, 20}, {30, 40, 50}}`,
		)

		testReprDef(
			[][]int{nil, {}, {10, 20}, {30, 40, 50}},
			`[][]int{
    nil,
    {},
    {
        10,
        20,
    },
    {
        30,
        40,
        50,
    },
}`)

		testReprZero(
			[][][]int{nil, {nil}, {{10, 20}}, {{30, 40, 50}}},
			`[][][]int{nil, {nil}, {{10, 20}}, {{30, 40, 50}}}`,
		)
	})

	t.Run(`in_map_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero(map[int][]int{10: {20, 30}}, `map[int][]int{10: {20, 30}}`)

		testReprDef(
			map[int][]int{10: {20, 30}},
			`map[int][]int{
    10: {
        20,
        30,
    },
}`)

		t.Run(`interface_values`, func(t *testing.T) {
			defer gtest.Catch(t)
			testReprZero(map[int]any{10: []int{20, 30}}, `map[int]any{10: []int{20, 30}}`)

			testReprDef(
				map[int][]int{10: {20, 30}},
				`map[int][]int{
    10: {
        20,
        30,
    },
}`)
		})

	})

	t.Run(`in_struct_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		type Tar struct{ Val []int }

		testReprZero(Tar{[]int{10, 20, 30}}, `grepr_test.Tar{[]int{10, 20, 30}}`)
	})
}

func Test_arrays(t *testing.T) {
	defer gtest.Catch(t)

	testReprZero([0]any{}, `[0]any{}`)
	testReprZero([1]any{nil}, `[1]any{}`)
	testReprZero([2]any{nil, nil}, `[2]any{}`)
	testReprZero([2]any{10, 20}, `[2]any{10, 20}`)

	testReprZero([0]func(){}, `[0]func(){}`)
	testReprZero([1]func(){nil}, `[1]func(){}`)
	testReprZero([2]func(){nil, nil}, `[2]func(){}`)

	testReprZero([3]int{}, `[3]int{}`)
	testReprZero([3]int{10, 20, 30}, `[3]int{10, 20, 30}`)
}

func Test_structs(t *testing.T) {
	defer gtest.Catch(t)

	testReprDef(Struct0{}, `grepr_test.Struct0{}`)

	testReprDef(Struct1{}, `grepr_test.Struct1{}`)
	testReprDef(Struct1{10}, `grepr_test.Struct1{10}`)

	testReprDef(Struct2{}, `grepr_test.Struct2{}`)
	testReprDef(Struct2{A: 10}, `grepr_test.Struct2{A: 10}`)
	testReprDef(Struct2{B: 20}, `grepr_test.Struct2{B: 20}`)
	testReprDef(Struct2{A: 10, B: 20}, `grepr_test.Struct2{
    A: 10,
    B: 20,
}`)

	testReprDef(testOuter, testOuterStringDef)
	testReprZero(testOuter, testOuterStringZero)

	testReprDef(Struct1Any{}, `grepr_test.Struct1Any{}`)

	testReprDef(Struct1Any{true}, `grepr_test.Struct1Any{true}`)
	testReprDef(Struct1Any{Bool(true)}, `grepr_test.Struct1Any{grepr_test.Bool(true)}`)

	testReprDef(Struct1Any{10}, `grepr_test.Struct1Any{10}`)
	testReprDef(Struct1Any{gg.TimeMicro(10)}, `grepr_test.Struct1Any{gg.TimeMicro(10)}`)

	testReprDef(Struct1Any{`one`}, `grepr_test.Struct1Any{`+"`one`"+`}`)
	testReprDef(Struct1Any{gg.ErrStr(`one`)}, `grepr_test.Struct1Any{gg.ErrStr(`+"`one`"+`)}`)
}

func Test_structs_embed_GoStringer(t *testing.T) {
	t.Skip(`not yet implemented`)

	defer gtest.Catch(t)

	type Tar1 struct{ GoStringer }

	fmt.Println(`gg.Type[Tar1]().Implements(gg.Type[fmt.GoStringer]()):`, gg.Type[Tar1]().Implements(gg.Type[fmt.GoStringer]()))

	testReprZero(Tar1{}, `grepr_test.Tar1{MakeGoStringer()}`)
	testReprDef(Tar1{}, `grepr_test.Tar1{MakeGoStringer()}`)

	type Tar2 struct {
		GoStringer
		Id int
	}

	testReprZero(Tar2{}, `grepr_test.Tar2{GoStringer: MakeGoStringer()}`)

	testReprDef(Tar2{}, `grepr_test.Tar2{
    GoStringer: MakeGoStringer(),
}`)

	testReprZero(Tar2{Id: 10}, `grepr_test.Tar2{GoStringer: MakeGoStringer(), Id: 10}`)

	testReprDef(Tar2{Id: 10}, `grepr_test.Tar2{
    GoStringer: MakeGoStringer(),
    Id: 10,
}`)
}

/*
This test is limited because Go iterates maps in random order, and our
pretty-printer doesn't bother to sort keys.
*/
func Test_maps(t *testing.T) {
	defer gtest.Catch(t)

	testReprZero(map[int]bool(nil), `nil`)
	testReprDef(map[int]bool(nil), `nil`)

	testReprZero(map[int]bool{}, `map[int]bool{}`)
	testReprDef(map[int]bool{}, `map[int]bool{}`)

	testReprZero(map[int]bool{10: true}, `map[int]bool{10: true}`)
	testReprZero(map[int]bool{10: false}, `map[int]bool{10: false}`)

	testReprDef(
		map[int]bool{10: true},
		`map[int]bool{
    10: true,
}`,
	)
}

func Test_map_type_elision(t *testing.T) {
	defer gtest.Catch(t)

	t.Run(`in_slice_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero([]map[int]bool{{10: true}}, `[]map[int]bool{{10: true}}`)

		testReprDef([]map[int]bool{{10: true}, {20: false}}, `[]map[int]bool{
    {
        10: true,
    },
    {
        20: false,
    },
}`)
	})

	t.Run(`in_map_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		testReprZero(
			map[int]map[int]bool{10: {20: true}},
			`map[int]map[int]bool{10: {20: true}}`,
		)

		testReprDef(
			map[int]map[int]bool{10: {20: true}},
			`map[int]map[int]bool{
    10: {
        20: true,
    },
}`)
	})

	t.Run(`in_struct_literals`, func(t *testing.T) {
		defer gtest.Catch(t)

		type Tar struct{ Val map[int]bool }

		testReprZero(
			Tar{map[int]bool{10: true}},
			`grepr_test.Tar{map[int]bool{10: true}}`,
		)
	})
}

func Test_interfaces(t *testing.T) {
	defer gtest.Catch(t)

	testReprDef(any(10), `10`)

	testReprDef(any(`str`), "`str`")

	testReprDef([]any{10, 20}, `[]any{
    10,
    20,
}`)

	testReprDef(
		[]any{gg.TimeMilli(10), gg.TimeMicro(20)},
		`[]any{
    gg.TimeMilli(10),
    gg.TimeMicro(20),
}`,
	)

	testReprDef([]any{true, false}, `[]any{
    true,
    false,
}`)

	testReprDef(
		[]any{Bool(true), Bool(false)},
		`[]any{
    grepr_test.Bool(true),
    grepr_test.Bool(false),
}`,
	)

	testReprDef([]any{`one`, `two`}, `[]any{
    `+"`one`"+`,
    `+"`two`"+`,
}`)

	testReprDef(
		[]any{gg.ErrStr(`one`), Str(`two`)},
		`[]any{
    gg.ErrStr(`+"`one`"+`),
    grepr_test.Str(`+"`two`"+`),
}`,
	)

	testReprDef([]any{Struct1{10}, Struct2{20, 30}}, `[]any{
    grepr_test.Struct1{10},
    grepr_test.Struct2{
        A: 20,
        B: 30,
    },
}`)

	testReprZero[r.Type](nil, `nil`)
	testReprZero[r.Type](gg.Type[int](), `gg.Type[int]()`)
	testReprZero[r.Type](gg.Type[string](), `gg.Type[string]()`)
}

func Test_pkg_names(t *testing.T) {
	defer gtest.Catch(t)

	{
		type Tar []gg.Buf

		testReprDef(
			Tar{gg.Buf(`one`), gg.Buf(`two`), gg.Buf(`three`)},
			`grepr_test.Tar{
    gg.Buf(`+"`one`"+`),
    gg.Buf(`+"`two`"+`),
    gg.Buf(`+"`three`"+`),
}`,
		)
	}

	{
		type Tar []any

		testReprDef(
			Tar{gg.TimeMilli(10), gg.TimeMicro(20)},
			`grepr_test.Tar{
    gg.TimeMilli(10),
    gg.TimeMicro(20),
}`,
		)
	}
}

func TestConf_pkg_names_strip(t *testing.T) {
	defer gtest.Catch(t)

	{
		conf := grepr.ConfDefault
		conf.Pkg = `grepr_test`

		testReprC(conf, testOuter, testOuterStringDefPkgStrip)

		testReprC(
			conf,
			Struct1Any{gg.TimeMicro(10)},
			`Struct1Any{gg.TimeMicro(10)}`,
		)
	}

	{
		conf := grepr.ConfDefault
		conf.Pkg = `gg`

		testReprC(conf, testOuter, `grepr_test.Outer{
    OuterName: `+"`outer`"+`,
    Embed: grepr_test.Embed{EmbedId: 20},
    Inner: &grepr_test.Inner{
        InnerId: Ptr(30),
        InnerName: Ptr(`+"`inner`"+`),
    },
}`)

		testReprC(
			conf,
			Struct1Any{gg.TimeMicro(10)},
			`grepr_test.Struct1Any{TimeMicro(10)}`,
		)
	}

	// Not fully implemented.
	// TODO either implement properly, or drop `Conf.Pkg`.
	//
	// {
	// 	var conf grepr.Conf
	// 	testReprC(conf, []Struct0{{}}, `[]grepr_test.Struct0{{}}`)
	// 	conf.Pkg = `grepr_test`
	// 	testReprC(conf, []Struct0{{}}, `[]Struct0{{}}`)
	// }
}

func ExampleString() {
	fmt.Println(grepr.String(testOuter))
	// Output:
	// grepr_test.Outer{
	//     OuterName: `outer`,
	//     Embed: grepr_test.Embed{EmbedId: 20},
	//     Inner: &grepr_test.Inner{
	//         InnerId: gg.Ptr(30),
	//         InnerName: gg.Ptr(`inner`),
	//     },
	// }
}

func BenchmarkString_num(b *testing.B) {
	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(10))
	}
}

func BenchmarkString_str(b *testing.B) {
	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(`str`))
	}
}

func BenchmarkString_struct_flat(b *testing.B) {
	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(testEmbed))
	}
}

func BenchmarkString_struct_nested_fmt(b *testing.B) {
	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(gg.GoString(testOuter))
	}
}

func BenchmarkString_struct_nested_grepr(b *testing.B) {
	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(testOuter))
	}
}

func BenchmarkString_struct_nested_grepr_elide_pkg(b *testing.B) {
	conf := grepr.ConfDefault
	conf.Pkg = `grepr_test`

	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.StringC(conf, testOuter))
	}
}

func BenchmarkString_fmt_GoStringer(b *testing.B) {
	src := gg.Set[int]{}
	gg.Nop1(fmt.GoStringer(src))
	strEq(grepr.String(src), `gg.Set[int]{}`)

	b.ResetTimer()

	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(src))
	}
}

func Test_cyclic_1(t *testing.T) {
	defer gtest.Catch(t)

	cyclic := Cyclic{Id: 10}
	cyclic.Cyclic = &cyclic

	gtest.Is(&cyclic, cyclic.Cyclic)
	testCyclic(&cyclic)
}

func Test_cyclic_2(t *testing.T) {
	defer gtest.Catch(t)

	cyclic0 := Cyclic{Id: 10}
	cyclic1 := Cyclic{Id: 20}

	cyclic0.Cyclic = &cyclic1
	cyclic1.Cyclic = &cyclic0

	gtest.Is(&cyclic0, cyclic1.Cyclic)
	gtest.Is(&cyclic1, cyclic0.Cyclic)

	testCyclic(&cyclic0)
}

/*
For now, this verifies the following:

	* We eventually terminate.
	* We mark visited references.

TODO verify the exact output structure. It can be broken by unsafe hacks such as
`gg.AnyNoEscUnsafe`.
*/
func testCyclic[A any](src A) {
	gtest.TextHas(grepr.String(src), `/* visited */ (*`)
}

func BenchmarkString_cyclic(b *testing.B) {
	cyclic0 := Cyclic{Id: 10}
	cyclic1 := Cyclic{Id: 20}

	cyclic0.Cyclic = &cyclic1
	cyclic1.Cyclic = &cyclic0

	for ind := 0; ind < b.N; ind++ {
		gg.Nop1(grepr.String(&cyclic0))
	}
}