return nil, err
		}

		t3, err := fetchHuff(&rbr3)
		if err != nil {
			return nil, err
		}

		if use4 {
			t4, err := fetchHuff(&rbr4)
			if err != nil {
				return nil, err
			}
			outbuf[out4] = byte(t4 >> 8)
			out4++
			rbr4.cnt -= uint32(t4 & 0xff)
		}

		outbuf[out1] = byte(t1 >> 8)
		out1++
		rbr1.cnt -= uint32(t1 & 0xff)

		outbuf[out2] = byte(t2 >> 8)

		t.Errorf("sizeof(%#v)==%d, want 2", T3{}, unsafe.Sizeof(T3{}))
	}
	// make sure padding can double for both zerosize and alignment
	type T4 struct {
		a int32
		b int16
		c int8
		z struct{}
	}
	if unsafe.Sizeof(T4{}) != 8 {
		t.Errorf("sizeof(%#v)==%d, want 8", T4{}, unsafe.Sizeof(T4{}))
	}
	// make sure we don't pad a zero-sized thing
	type T5 struct {
	}
	if unsafe.Sizeof(T5{}) != 0 {

// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2,
          typename T3,
          typename T4>
AssertionResult AssertPred4Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  const char* e3,

	C4          = +123.456e+789
	C5          = 1234i
	C6          = "foo\n"
	C7          = `bar\n`
	C8          = 42
	C9  int     = 42
	C10 float64 = 42
)

type (
	T1  int
	T2  [10]int
	T3  []int
	T4  *int
	T5  chan int
	T6a chan<- int
	T6b chan (<-chan int)
	T6c chan<- (chan int)
	T7  <-chan *ast.File
	T8  struct{}
	T9  struct {
		a    int
		b, c float32
		d    []string `go:"tag"`
	}

			indexFields:   []string{"spec.nodeName"},
			watchTests: []*testWatchStruct{
				{baseNamespacedPod("t4-foo1", "t4-ns1"), true, watch.Added},
				{baseNamespacedPod("t4-foo2", "t4-ns1"), true, watch.Added},
				{baseNamespacedPodUpdated("t4-foo1", "t4-ns1"), true, watch.Modified},
				{baseNamespacedPodAssigned("t4-foo1", "t4-ns1", "t4-bar1"), true, watch.Deleted},
			},
		},

type <type 21 "A14" = <type 22 (? <type -11>, ? <type 1>) <type 23 chan <type 18>>>>;
type <type 18>;
type <type 24 "A3" = <type 25 "T3" <type 26 interface { .go.aliases.m () <type 19>; }>>>;
type <type 27 "A4" = <type 28 "T4" <type 29 (? <type -11>, ? <type 2>) <type 30 chan <type 19>>>>>;
type <type 31 "Ai" = <type -11>>;
type <type 32 "C0" <type 33 struct { .go.aliases.f1 <type 34 "C1" <type 35 *<type 32>>>; .go.aliases.f2 <type 36 "C2" = <type 34>>; }>>;

	}
}

type T4 struct {
	pre  [8]byte
	mid  [4]byte
	post [8]byte
}

//go:noinline
func t4copy_ssa(y, x *[4]byte) {
	*y = *x
}
func testCopy4(t *testing.T) {
	a := T4{[8]byte{201, 202, 203, 204, 205, 206, 207, 208}, [4]byte{0, 1, 2, 3}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}}
	x := [4]byte{100, 101, 102, 103}
	t4copy_ssa(&a.mid, &x)

func (v *Point) Equal(u *Point) int {
	checkInitialized(v, u)

	var t1, t2, t3, t4 field.Element
	t1.Multiply(&v.x, &u.z)
	t2.Multiply(&u.x, &v.z)
	t3.Multiply(&v.y, &u.z)
	t4.Multiply(&u.y, &v.z)

	return t1.Equal(&t2) & t3.Equal(&t4)
}

// Constant-time operations

// Select sets v to a if cond == 1 and to b if cond == 0.

func (c *sigctxt) s10() uint64 { return uint64(c.regs().sc_s[10]) }
func (c *sigctxt) s11() uint64 { return uint64(c.regs().sc_s[11]) }
func (c *sigctxt) t3() uint64  { return uint64(c.regs().sc_t[3]) }
func (c *sigctxt) t4() uint64  { return uint64(c.regs().sc_t[4]) }
func (c *sigctxt) t5() uint64  { return uint64(c.regs().sc_t[5]) }
func (c *sigctxt) t6() uint64  { return uint64(c.regs().sc_t[6]) }

//go:nosplit
//go:nowritebarrierrec

	a5  uint64
	a6  uint64
	a7  uint64
	s2  uint64
	s3  uint64
	s4  uint64
	s5  uint64
	s6  uint64
	s7  uint64
	s8  uint64
	s9  uint64
	s10 uint64
	s11 uint64
	t3  uint64
	t4  uint64
	t5  uint64
	t6  uint64
}

type user_fpregs_struct struct {
	f [528]byte
}

type usigset struct {
	us_x__val [16]uint64
}

type sigcontext struct {