tstf()
	fy = fx[2:10]
	tstf()
	fy = fx[2:]
	tstf()

	lb = 0
	hb = 8
	fy = fx[lb:hb]
	tstf()
	fy = fx[lb:8]
	tstf()
	fy = fx[:hb]
	tstf()
	fy = fx[0:hb]
	tstf()
	fy = fx[0:8]
	tstf()
	fy = fx[:8]
	tstf()

	lb = 2
	hb = 8
	fy = fx[lb:hb]
	tstf()
	fy = fx[lb:8]
	tstf()
	fy = fx[2:hb]
	tstf()
	fy = fx[2:8]
	tstf()
}

	fy = fx[lb:]
	tstf()
	fy = fx[:hb]
	tstf()
	fy = fx[0:hb]
	tstf()
	fy = fx[0:10]
	tstf()
	fy = fx[0:]
	tstf()
	fy = fx[:10]
	tstf()
	fy = fx[:]
	tstf()

	lb = 2
	hb = 10
	fy = fx[lb:hb]
	tstf()
	fy = fx[lb:10]
	tstf()
	fy = fx[lb:]
	tstf()
	fy = fx[2:hb]
	tstf()
	fy = fx[2:10]
	tstf()
	fy = fx[2:]
	tstf()

	lb = 0
	hb = 8
	fy = fx[lb:hb]

type Foo interface {
	Hi() string
}

func Test1() Foo { return make(tst1) }

type tst1 map[string]bool

func (r tst1) Hi() string { return "Hi!" }

func Test2() Foo { return make(tst2, 0) }

type tst2 []string

func (r tst2) Hi() string { return "Hi!" }

func Test3() Foo { return make(tst3) }

type tst3 chan string

// license that can be found in the LICENSE file.

// Issue 26438: arm64 backend may use 64-bit TST for
// "if uint32(a)&uint32(b) == 0", which should be
// 32-bit TSTW

package main

//go:noinline
func tstw(a, b uint64) uint64 {
	if uint32(a)&uint32(b) == 0 {
		return 100
	} else {
		return 200
	}
}

func main() {
	if tstw(0xff00000000, 0xaa00000000) == 200 {
		panic("impossible")
	}

		}
	}
}

func (tsts authzTests) Filter(keep func(authzTest) bool) authzTests {
	out := make(authzTests, 0, len(tsts))
	for _, tst := range tsts {
		if keep(tst) {
			out = append(out, tst)
		}
	}
	return out
}

func (tsts authzTests) RunAll(t framework.TestContext) {
	t.Helper()

	firstTest := tsts[0]
	if len(tsts) == 1 {

	bctrl

	addi	1, 1, 296
	bl	restoreregs
	ld	2, 40(1)
	ld	0, 16(1)
	mtlr	0
	blr

saveregs:
	// Save callee-save registers
	// O=-288; for R in {14..31}; do echo "\tstd\t$R, $O(1)"; ((O+=8)); done; for F in f{14..31}; do echo "\tstfd\t$F, $O(1)"; ((O+=8)); done
	std	14, -288(1)
	std	15, -280(1)
	std	16, -272(1)
	std	17, -264(1)
	std	18, -256(1)
	std	19, -248(1)
	std	20, -240(1)
	std	21, -232(1)

	// arm64:`ADD`,-`CMNW`
	// arm:`ADD`,-`CMN`
	c5 := b+d == 0
	// not optimized to single TSTW/TST due to further use of a&d
	// arm64:`AND`,-`TSTW`
	// arm:`AND`,-`TST`
	// 386:`ANDL`
	c6 := a&d >= 0
	// arm64:`TST\sR[0-9]+<<3,\sR[0-9]+`
	c7 := e&(f<<3) < 0
	// arm64:`CMN\sR[0-9]+<<3,\sR[0-9]+`
	c8 := e+(f<<3) < 0
	// arm64:`TST\sR[0-9],\sR[0-9]+`
	c9 := e&(-19) < 0
	if c0 {
		return 1
	} else if c1 {

  return TF_TString_GetType(str);
}

size_t TF_StringGetSize(const TF_TString *tstr) {
  return TF_TString_GetSize(tstr);
}

size_t TF_StringGetCapacity(const TF_TString *str) {
  return TF_TString_GetCapacity(str);
}

	for _, tst := range tsts {
		var expect []int
		switch tst.output.(type) {
		case cmplx:
			v := tst.output.(cmplx)
			expect = []int{v.pic, v.pic_dyn, v.dyn, v.nonpic}
		case int:
			expect = []int{tst.output.(int), tst.output.(int), tst.output.(int), tst.output.(int)}
		}
		for i := range ctxts {
			if output := ctxts[i].aclass(&tst.arg); output != expect[i] {

(ORconst  [c] x) && !isARM64bitcon(uint64(c))  => (OR  x (MOVDconst [c]))
(XORconst [c] x) && !isARM64bitcon(uint64(c))  => (XOR x (MOVDconst [c]))
(TSTconst [c] x) && !isARM64bitcon(uint64(c))  => (TST x (MOVDconst [c]))
(TSTWconst [c] x) && !isARM64bitcon(uint64(c)|uint64(c)<<32)  => (TSTW x (MOVDconst [int64(c)]))

(CMPconst [c] x) && !isARM64addcon(c)  => (CMP x (MOVDconst [c]))
(CMPWconst [c] x) && !isARM64addcon(int64(c))  => (CMPW x (MOVDconst [int64(c)]))