p = obj.Appendp(p, c.newprog)
		p.As = mov
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGCTXT
		p.To.Type = obj.TYPE_MEM
		p.To.Offset = -int64(c.ctxt.Arch.PtrSize)
		p.To.Reg = REGSP

		// ADD	$-8/$-16, SP
		p = obj.Appendp(p, c.newprog)
		p.As = add
		p.From.Type = obj.TYPE_CONST
		p.From.Offset = int64(-frameSize)
		p.To.Type = obj.TYPE_REG
		p.To.Reg = REGSP
		p.Spadj = int32(frameSize)

		case p.tok.IsLiteral():
			p.printTrace(s, p.lit)
		case p.tok.IsOperator(), p.tok.IsKeyword():
			p.printTrace("\"" + s + "\"")
		default:
			p.printTrace(s)
		}
	}

	for {
		p.pos, p.tok, p.lit = p.scanner.Scan()
		if p.tok == token.COMMENT {
			if p.top && strings.HasPrefix(p.lit, "//go:build") {
				if x, err := constraint.Parse(p.lit); err == nil {
					p.goVersion = constraint.GoVersion(x)
				}
			}

		*p.next.ptr() = memHdr{}
	} else {
		bp.next = p.next
	}
	if uintptr(unsafe.Pointer(p))+p.size == bpn {
		p.size += bp.size
		p.next = bp.next
		*bp = memHdr{}
	} else {
		p.next.set(bp)
	}
}

func memCheck() {
	if !memDebug {
		return
	}
	for p := memFreelist.ptr(); p != nil && p.next != 0; p = p.next.ptr() {
		if uintptr(unsafe.Pointer(p)) == uintptr(unsafe.Pointer(p.next)) {

		p.As = mov
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGLINK
		p.To.Type = obj.TYPE_MEM
		p.To.Offset = int64(-frameSize)
		p.To.Reg = REGSP

		// MOV	REGCTXT, -4/-8(SP)
		p = obj.Appendp(p, c.newprog)
		p.As = mov
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGCTXT
		p.To.Type = obj.TYPE_MEM
		p.To.Offset = -int64(c.ctxt.Arch.PtrSize)
		p.To.Reg = REGSP

		// ADD	$-8/$-16, SP

	}
	out, err := p.Runner.RunCmd("get pods -o yaml", p.IstioNamespace, p.KubeConfig, p.KubeContext, p.DryRun)
	return map[string]string{
		"pods": out,
	}, err
}

// GetEvents returns events for all namespaces.
func GetEvents(p *Params) (map[string]string, error) {
	out, err := p.Runner.RunCmd("get events --all-namespaces -o wide --sort-by=.metadata.creationTimestamp", "", p.KubeConfig, p.KubeContext, p.DryRun)

	for try := 0; try < 3; try++ {
		wg.Add(P)
		for p := 0; p < P; p++ {
			go func(p int) {
				data[p]++
				wg.Done()
			}(p)
		}
		done := make(chan bool)
		go func() {
			wg.Wait()
			for p := 0; p < P; p++ {
				data[p]++
			}
			done <- true
		}()
		wg.Wait()
		<-done
		for p := 0; p < P; p++ {
			data[p]++
		}
	}
}

func TestRaceWaitGroupReuse(t *testing.T) {

DATA ·IEEEConst+208(SB)/8,$0x00000001b5334592
DATA ·IEEEConst+216(SB)/8,$0x00000001f8cc6582

	/* x^246848 mod p(x), x^246784 mod p(x) */
DATA ·IEEEConst+224(SB)/8,$0x000000011f8ee1b4
DATA ·IEEEConst+232(SB)/8,$0x000000008631ddf0

	/* x^245824 mod p(x), x^245760 mod p(x) */
DATA ·IEEEConst+240(SB)/8,$0x000000006252e632
DATA ·IEEEConst+248(SB)/8,$0x000000007e5a76d0

	/* x^244800 mod p(x), x^244736 mod p(x) */

			// assemble into a single addi.
			is := p.From.Offset>>16 + (p.From.Offset>>15)&1
			i := int64(int16(p.From.Offset))
			p.As = AADDIS
			p.From.Offset = is
			q := obj.Appendp(p, c.newprog)
			q.As = AADD
			q.From.SetConst(i)
			q.Reg = p.To.Reg
			q.To = p.To
			p = q
		}
	case AOR:
		if p.From.Type == obj.TYPE_CONST && uint64(p.From.Offset)&0xFFFFFFFF0000FFFF == 0 && p.From.Offset != 0 {
			p.As = AORIS

	p = obj.Appendp(p, c.newprog)
	p.As = AADD
	p.From.Type = obj.TYPE_CONST
	p.From.Offset = -offset
	p.Reg = REGSP
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R4

	p = obj.Appendp(p, c.newprog)
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R3
	p.Reg = REG_R4
	p.As = ACMPUBGE
	p.To.Type = obj.TYPE_BRANCH

	return p, pPreempt, pCheck
}

	i := 0 // ERROR "moved to heap: i$"
	var p *int
	param2(&i, &p)
	_ = p
}

func caller2b() {
	i := 0 // ERROR "moved to heap: i$"
	var p *int
	param2(&i, &p)
	sink = p
}

func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
	p.pairs[0] = p.pairs[1] // ERROR "ignoring self-assignment in p.pairs\[0\] = p.pairs\[1\]"
}