} else if gp != nil {
			nstk += gcallers(gp, skip, pcBuf[1:])
		}
	} else {
		// Fast path: Unwind using frame pointers.
		pcBuf[0] = uintptr(skip)
		if getg() == gp {
			nstk += fpTracebackPCs(unsafe.Pointer(getfp()), pcBuf[1:])
		} else if gp != nil {
			// Three cases:
			//
			// (1) We're called on the g0 stack through mcall(fn) or systemstack(fn). To
			// behave like gcallers above, we start unwinding from sched.bp, which

// getcallerfp returns the frame pointer of the caller of the caller
// of this function.
//
//go:nosplit
//go:noinline
func getcallerfp() uintptr {
	fp := getfp() // This frame's FP.
	if fp != 0 {
		fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's FP.
		fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's caller's FP.
	}
	return fp

// FPCallers works like Callers and uses frame pointer unwinding to populate
// pcBuf with the return addresses of the physical frames on the stack.
func FPCallers(pcBuf []uintptr) int {
	return fpTracebackPCs(unsafe.Pointer(getfp()), pcBuf)
}

const FramePointerEnabled = framepointer_enabled

var (
	IsPinned      = isPinned
	GetPinCounter = pinnerGetPinCounter
)

func SetPinnerLeakPanic(f func()) {

	JMP	runtime·goPanicSlice3CU<ABIInternal>(SB)
TEXT runtime·panicSliceConvert<ABIInternal>(SB),NOSPLIT,$0-16
	MOVD	R2, R0
	MOVD	R3, R1
	JMP	runtime·goPanicSliceConvert<ABIInternal>(SB)

TEXT ·getfp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
	MOVD R29, R0

							const args = loadSliceOfValues(sp + 32);
							const result = Reflect.apply(m, v, args);
							sp = this._inst.exports.getsp() >>> 0; // see comment above
							storeValue(sp + 56, result);
							this.mem.setUint8(sp + 64, 1);
						} catch (err) {
							sp = this._inst.exports.getsp() >>> 0; // see comment above
							storeValue(sp + 56, err);
							this.mem.setUint8(sp + 64, 0);
						}
					},

		}
		return true, nil
	}
	if err := wait.PollImmediate(10*time.Millisecond, time.Second, getFn); err != nil {
		t.Errorf("unexpected error: %v", err)
	}

	// Eventually we should observer secret deletion.
	fakeWatch.Delete(secret)
	getFn = func() (bool, error) {
		_, err := store.Get("ns", "name")
		if err != nil {
			if apierrors.IsNotFound(err) {
				return true, nil

	if err != nil {
		return nil, err
	}
	if filter != nil && !filter.Contains(uid) {
		return nil, nil
	}

	netns, err := proc.Open(netnsName)
	if err != nil {
		return nil, err
	}
	fd, err := GetFd(netns)
	if err != nil {
		netns.Close()
		return nil, err
	}
	netnsObserved[inode] = struct{}{}
	log.Debugf("found pod to netns: %s %d", uid, inode)

	return &PodNetnsEntry{
		uid:     uid,

                @OutputFile File outputFile = new File(temporaryDir, "output.txt")
                @Input String run = project.findProperty("run") ?: ""
                @javax.inject.Inject abstract FileSystemOperations getFs()
                @TaskAction
                void generate() {
                    logger.warn("Run " + run)
                    fs.copy {
                        from("output.txt")

        loc, qparams_op.getScale().getType(), scale_op.getOutput());
    auto zp_cast = rewriter.create<CastOp>(loc, qparams_op.getZp().getType(),
                                           zp_op.getOutput());

    qparams_op.getScale().replaceAllUsesWith(scale_cast.getOut());
    qparams_op.getZp().replaceAllUsesWith(zp_cast.getOut());
    return success();
  }
};

                @OutputFile
                File output = project.file("build/output.txt")

                @Inject
                abstract FileSystemOperations getFs()

                @TaskAction void doSomething() {
                    output.text = inputFile.text
                    fs.delete { delete(missing) }
                }
            }