benchmarkSwitchInterfaceType(b, true)
}
func BenchmarkSwitchInterfaceTypeUnpredictable(b *testing.B) {
	benchmarkSwitchInterfaceType(b, false)
}

type SI0 interface {
	si0()
}
type ST0 struct {
}

func (ST0) si0() {
}

type SI1 interface {
	si1()
}
type ST1 struct {
}

func (ST1) si1() {
}

type SI2 interface {
	si2()
}
type ST2 struct {

	i0 := (r.Min.X - dst.Rect.Min.X) * 4
	i1 := (r.Max.X - dst.Rect.Min.X) * 4
	si0 := (sp.X - src.Rect.Min.X) * 4
	yMax := r.Max.Y - dst.Rect.Min.Y

	y := r.Min.Y - dst.Rect.Min.Y
	sy := sp.Y - src.Rect.Min.Y
	for ; y != yMax; y, sy = y+1, sy+1 {
		dpix := dst.Pix[y*dst.Stride:]
		spix := src.Pix[sy*src.Stride:]

		for i, si := i0, si0; i < i1; i, si = i+4, si+4 {

	o1 := GenOpcodes[p.As-AXXSETACCZ]
	o1 |= uint32(p.To.Reg&0x1f) << 21                          // RT
	o1 |= uint32(p.From.Reg&0x1f) << 16                        // RA
	o0 |= uint32((p.RestArgs[0].Addr.Offset>>16)&0x3ffff) << 0 // si0
	o1 |= uint32(p.RestArgs[0].Addr.Offset&0xffff) << 0        // si1
	o0 |= uint32(p.RestArgs[1].Addr.Offset&0x1) << 20          // R
	out[1] = o1
	out[0] = o0
}

// pextd RA,RS,RB

//
// TF unsorted segment reduction op peforms the following calculation:
//
// Assume segment ids' shape is [SI0, SI1, ..., SIm] and data's  shape is
// [D0, D1, ..., Dn]. Note that segment ids' shape must be a prefix of data's
// shape, so we can have data's shape represented as [SI0, SI1, ..., SIm,
// Dm+1, ..., Dn]. Then
//   output[segment_ids[SI_i0, SI_i1, ..., SI_im], D_im+1, ..., D_in] =