}
	for zb0007, zb0008 := range z {
		err = en.WriteString(zb0007)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		// map header, size 2
		// write "Bins"
		err = en.Append(0x82, 0xa4, 0x42, 0x69, 0x6e, 0x73)
		if err != nil {
			return
		}
		err = en.WriteArrayHeader(uint32(24))
		if err != nil {
			err = msgp.WrapError(err, zb0007, "Bins")
			return
		}

		sha1.Size,
		sha1.BlockSize,
	},
	{
		sha1.New,
		[]byte{
			0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
			0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
			0x40, 0x41, 0x42, 0x43,
		},
		[]byte("Sample #2"),
		"0922d3405faa3d194f82a45830737d5cc6c75d24",
		sha1.Size,
		sha1.BlockSize,
	},
	{
		sha1.New,
		[]byte{
			0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,

		0x92, 0xd7, 0x82, 0x41, 0x31, 0x9c, 0x3f, 0x07, 0x02, 0xee, 0xa1, 0xaa, 0xff, 0xff, 0x9f, 0xe1,
		0xd9, 0x56, 0x30, 0xf8, 0x0e, 0xe5, 0x03, 0x00, 0xa9, 0x42, 0x84, 0x3d, 0xdf, 0x8f, 0xa6, 0x8f,
		0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
	}))
	if err != nil {
		t.Fatalf("Decode: %v", err)
	}

	const hex = "0123456789abcdef"
	var got []byte
	bounds := m.Bounds()

float64 %.6e 5344436398034927p-169 7.142211e-36
float64 %.7e 8369123604277281p-853 1.3934574e-241
float64 %.8e 8995822108487663p-780 1.41463449e-219
float64 %.9e 8942832835564782p-383 4.539277920e-100
float64 %.10e 8942832835564782p-384 2.2696389598e-100
float64 %.11e 8942832835564782p-385 1.13481947988e-100
float64 %.12e 6965949469487146p-249 7.700366561890e-60
float64 %.13e 6965949469487146p-250 3.8501832809448e-60

type TestBigInt struct {
	X *big.Int
}

type TestSet struct {
	Ints []int `asn1:"set"`
}

var unmarshalTestData = []struct {
	in  []byte
	out any
}{
	{[]byte{0x02, 0x01, 0x42}, newInt(0x42)},
	{[]byte{0x05, 0x00}, &RawValue{0, 5, false, []byte{}, []byte{0x05, 0x00}}},
	{[]byte{0x30, 0x08, 0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d}, &TestObjectIdentifierStruct{[]int{1, 2, 840, 113549}}},

	var x340 uint64
	x339, x340 = bits.Add64(x323, uint64(0x0), uint64(p521Uint1(x338)))
	var x341 uint64
	var x342 uint64
	x341, x342 = bits.Add64(x325, uint64(0x0), uint64(p521Uint1(x340)))
	var x343 uint64
	var x344 uint64
	x343, x344 = bits.Add64(x327, uint64(0x0), uint64(p521Uint1(x342)))
	var x345 uint64
	var x346 uint64
	x345, x346 = bits.Add64(x329, uint64(0x0), uint64(p521Uint1(x344)))
	var x347 uint64

	x40, x41 = bits.Add64(x34, uint64(0x0), uint64(fiatScalarUint1(x39)))
	var x42 uint64
	_, x42 = bits.Mul64(x36, 0xd2b51da312547e1b)
	var x44 uint64
	var x45 uint64
	x45, x44 = bits.Mul64(x42, 0x1000000000000000)
	var x46 uint64
	var x47 uint64
	x47, x46 = bits.Mul64(x42, 0x14def9dea2f79cd6)
	var x48 uint64
	var x49 uint64
	x49, x48 = bits.Mul64(x42, 0x5812631a5cf5d3ed)
	var x50 uint64
	var x51 uint64

// When a T is deallocated, T[1] is certain to
// get clobbered (the runtime writes 0xdeaddeaddeaddead there).
type T [4]int

func f() (r, s *T) {
	r = &T{0x30, 0x31, 0x32, 0x33}
	runtime.GC()
	s = &T{0x40, 0x41, 0x42, 0x43}
	runtime.GC()
	return
}

func main() {
	r, s := f()
	if r[1] != 0x31 {
		fmt.Printf("bad r[1], want 0x31 got %x\n", r[1])
	}
	if s[1] != 0x41 {
		fmt.Printf("bad s[1], want 0x41 got %x\n", s[1])

0x3e, 0x3c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x3e, 0x3c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x63, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x3e, 0x35, 0x30, 0x3c, 0x2f, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x63, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x3e, 0x3c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x3e, 0x35, 0x30, 0x3c, 0x2f, 0x42, 0x79, 0x74, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x3e, 0x3c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x65, 0x74, 0x75, 0x72,...

	var x40 uint64
	var x41 uint64
	x41, x40 = bits.Mul64(x32, 0xffffffff)
	var x42 uint64
	var x43 uint64
	x43, x42 = bits.Mul64(x32, 0xffffffffffffffff)
	var x44 uint64
	var x45 uint64
	x44, x45 = bits.Add64(x43, x40, uint64(0x0))
	var x47 uint64
	_, x47 = bits.Add64(x32, x42, uint64(0x0))
	var x48 uint64
	var x49 uint64
	x48, x49 = bits.Add64(x34, x44, uint64(p256Uint1(x47)))