// But it should be unnecessary.
		if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_REG && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 && ctxt.Headtype != objabi.Hsolaris {
			obj.Nopout(p)
		}
		if p.From.Type == obj.TYPE_MEM && p.From.Index == REG_TLS && REG_AX <= p.From.Reg && p.From.Reg <= REG_R15 {
			p.From.Reg = REG_TLS
			p.From.Scale = 0
			p.From.Index = REG_NONE
		}

iptables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT
iptables -t raw -D OUTPUT -p udp -j ISTIO_OUTPUT
ip6tables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT
ip6tables -t raw -D OUTPUT -p udp -j ISTIO_OUTPUT
iptables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j RETURN
ip6tables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j RETURN
iptables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 4 -j RETURN

	p.rotationTicker = time.NewTicker(rotationInterval)
	for {
		select {
		case <-p.rotationTicker.C:
			p.rotate()
		case <-p.closing:
			if p.rotationTicker != nil {
				p.rotationTicker.Stop()
			}
			return
		}
	}
}

func (p *GCEPlugin) rotate() {
	if p.shouldRotate(time.Now()) {
		if _, err := p.GetPlatformCredential(); err != nil {

)

func _[P int8 | uint8]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 255 overflows int8 (in P)" */ <<8 - 1)
}

func _[P int16 | uint16]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 65535 overflows int16 (in P)" */ <<16 - 1)
}

func _[P int32 | uint32]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 4294967295 overflows int32 (in P)" */ <<32 - 1)
}

func _[P int64 | uint64]() {
	_ = P(0)

		p(b, "	}\n")
		p(b, "	o.log(`L%ssel bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`L%ssw bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`L%sfor bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`done%s`)\n", s)
		p(b, "goto L%sb; L%sb: o.log(`L%sb`)\n", s, s, s)
	}
	return code
}

var testCode = `
func %s() {
	all := %#v
	for i := 0; i < len(all); i++ {
		c := all[i]
		outFunc := run(%s, c)

func memequal64(p, q unsafe.Pointer) bool {
	return *(*int64)(p) == *(*int64)(q)
}
func memequal128(p, q unsafe.Pointer) bool {
	return *(*[2]int64)(p) == *(*[2]int64)(q)
}
func f32equal(p, q unsafe.Pointer) bool {
	return *(*float32)(p) == *(*float32)(q)
}
func f64equal(p, q unsafe.Pointer) bool {
	return *(*float64)(p) == *(*float64)(q)
}
func c64equal(p, q unsafe.Pointer) bool {
	return *(*complex64)(p) == *(*complex64)(q)

		p.pos = p.i
		p.i++
		p.tok = p.s[p.pos:p.i]
		return

	case '&', '|':
		if p.i+1 >= len(p.s) || p.s[p.i+1] != p.s[p.i] {
			panic(&SyntaxError{Offset: p.i, Err: "invalid syntax at " + string(rune(p.s[p.i]))})
		}
		p.pos = p.i
		p.i += 2
		p.tok = p.s[p.pos:p.i]
		return
	}

	tag := p.s[p.i:]
	for i, c := range tag {

	{"type t func(int)", "t", "type p.t func(int)", false},
	{"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}", false},
	{"type t[P any] struct{f P}", "t.P", "type parameter P any", false},
	{"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C", false},

	{"type t = struct{f int}", "t", "type p.t = struct{f int}", false},
	{"type t = func(int)", "t", "type p.t = func(int)", false},

		p.To.Reg = REGSP
		p.Spadj = frameSize

		// Save FP.
		p = obj.Appendp(p, c.newprog)
		p.As = AMOVD
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGFP
		p.To.Type = obj.TYPE_MEM
		p.To.Reg = REGSP
		p.To.Offset = -8

		p = obj.Appendp(p, c.newprog)
		p.As = ASUB
		p.From.Type = obj.TYPE_CONST
		p.From.Offset = 8
		p.Reg = REGSP
		p.To.Type = obj.TYPE_REG
		p.To.Reg = REGFP

		// this point, and [N]∞ = ∞.
		if i != 0 {
			p.Double(p)
			p.Double(p)
			p.Double(p)
			p.Double(p)
		}

		windowValue := byte >> 4
		table.Select(t, windowValue)
		p.Add(p, t)

		p.Double(p)
		p.Double(p)
		p.Double(p)
		p.Double(p)

		windowValue = byte & 0b1111
		table.Select(t, windowValue)
		p.Add(p, t)
	}