switch v.Kind() {
		case abi.Int:
			v.Set(ValueOf(int(132)))
		case abi.Int8:
			v.Set(ValueOf(int8(8)))
		case abi.Int16:
			v.Set(ValueOf(int16(16)))
		case abi.Int32:
			v.Set(ValueOf(int32(32)))
		case abi.Int64:
			v.Set(ValueOf(int64(64)))
		case abi.Uint:
			v.Set(ValueOf(uint(132)))
		case abi.Uint8:
			v.Set(ValueOf(uint8(8)))
		case abi.Uint16:
			v.Set(ValueOf(uint16(16)))

func cmp(a Index, b []byte) int {
	n := len(a)
	if len(b) < n {
		n = len(b)
	}
	for i, c := range b[:n] {
		switch {
		case a[i] > c:
			return 1
		case a[i] < c:
			return -1
		}
	}
	switch {
	case len(a) < len(b):
		return -1
	case len(a) > len(b):
		return 1
	}
	return 0
}

// Compare returns an integer comparing a and b lexicographically.

		0x8234508000000001, // from issue48807
		1<<56 + 1<<32 + 1,
	} {
		got := float32(i)
		dontwant := float32(float64(i))
		if got == dontwant {
			// The test cases above should be uint64s such that
			// this equality doesn't hold. These examples trigger
			// the case where using an intermediate float64 doesn't work.
			t.Errorf("direct float32 conversion doesn't work: arg=%x got=%x dontwant=%x", i, got, dontwant)
		}
	}

		PI4B = 3.77489470793079817668e-8  // 0x3e64442d00000000,
		PI4C = 2.69515142907905952645e-15 // 0x3ce8469898cc5170,
	)
	// special cases
	switch {
	case x == 0 || IsNaN(x):
		return x // return ±0 || NaN()
	case IsInf(x, 0):
		return NaN()
	}

	// make argument positive but save the sign
	sign := false
	if x < 0 {
		x = -x
		sign = true
	}
	var j uint64

		// case *MapType:
		// case *ChanType:

		// statements
		// case *EmptyStmt:
		// case *LabeledStmt:
		// case *BlockStmt:
		// case *ExprStmt:
		case *SendStmt:
			m = n.Chan
		// case *DeclStmt:
		case *AssignStmt:
			m = n.Lhs
		// case *BranchStmt:
		// case *CallStmt:
		// case *ReturnStmt:
		// case *IfStmt:
		// case *ForStmt:
		// case *SwitchStmt:
		// case *SelectStmt:

		// helper nodes

func TestReduceErrs(t *testing.T) {
	canceledErrs := make([]error, 0, 5)
	for i := 0; i < 5; i++ {
		canceledErrs = append(canceledErrs, fmt.Errorf("error %d: %w", i, context.Canceled))
	}
	// List all of all test cases to validate various cases of reduce errors.
	testCases := []struct {
		errs        []error
		ignoredErrs []error
		err         error
	}{
		// Validate if have reduced properly.
		{[]error{
			errDiskNotFound,

// If x and y are identical channels but for their direction
// and one of them is unrestricted, match returns the channel
// with the restricted direction.
// In all other cases, match returns nil.
func match(x, y Type) Type {
	// Common case: we don't have channels.
	if Identical(x, y) {
		return x
	}

	// We may have channels that differ in direction only.
	if x, _ := x.(*Chan); x != nil {

	for _, t := range x {
		switch t := t.(type) {
		case Plain:
			p.escape(out, string(t))
		case Italic:
			out.WriteString("*")
			p.escape(out, string(t))
			out.WriteString("*")
		case *Link:
			out.WriteString("[")
			p.rawText(out, t.Text)
			out.WriteString("](")
			out.WriteString(t.URL)
			out.WriteString(")")
		case *DocLink:
			url := p.docLinkURL(t)
			if url != "" {

	_ chan I3 // ERROR "interface contains type constraints"
	_ func(I1 /* ERRORx `interface is .* comparable` */ )
	_ func() I2 // ERROR "interface contains type constraints"
)

// Other cases.

var _ = [...]I3 /* ERROR "interface contains type constraints" */ {}

func _(x interface{}) {
	_ = x.(I3 /* ERROR "interface contains type constraints" */ )
}

type T1[_ any] struct{}

// encodings. These vectors lock in unspecified and spec-divergent behaviors in
// edge cases that are not security relevant in most contexts, but that can
// cause issues in consensus applications if changed.
//
// Our behavior matches the "classic" unwritten verification rules of the
// "ref10" reference implementation.
//
// Note that although we test for these edge cases, they are not covered by the