#define s1(off)    (32*11 + off)(SP)
#define s2(off)    (32*12 + off)(SP)
#define z1sqr(off) (32*13 + off)(SP)
#define z2sqr(off) (32*14 + off)(SP)
#define h(off)     (32*15 + off)(SP)
#define r(off)     (32*16 + off)(SP)
#define hsqr(off)  (32*17 + off)(SP)
#define rsqr(off)  (32*18 + off)(SP)
#define hcub(off)  (32*19 + off)(SP)
#define rptr       (32*20)(SP)
#define points_eq  (32*20+8)(SP)

	fmt.Fprintf(w, "} else {\n")
	if a.typ[0] == '*' {
		fmt.Fprintf(w, "s = v.(%s)\n", a.typ)
	} else {
		fmt.Fprintf(w, "sp := v.(*%s)\n", a.typ)
		fmt.Fprintf(w, "s = *sp\n")
		fmt.Fprintf(w, "*sp = nil\n")
		fmt.Fprintf(w, "c.hdr%s = append(c.hdr%s, sp)\n", a.name, a.name)
	}
	fmt.Fprintf(w, "}\n")
	if a.resize != "" {
		fmt.Fprintf(w, "s = %s\n", fmt.Sprintf(a.resize, "s", "n"))
	}

	// s390x uses old_mmap, so the arguments need to be placed into
	// a struct and a pointer to the struct passed to mmap.
	MOVD	R2, addr-48(SP)
	MOVD	R3, n-40(SP)
	MOVD	R4, prot-32(SP)
	MOVD	R5, flags-24(SP)
	MOVD	R6, fd-16(SP)
	MOVD	R7, off-8(SP)

	MOVD	$addr-48(SP), R2
	MOVW	$SYS_mmap, R1
	SYSCALL
	MOVD	$-4095, R3
	CMPUBLT	R2, R3, ok
	NEG	R2
	MOVD	$0, p+32(FP)
	MOVD	R2, err+40(FP)
	RET

		gp21a0      = regInfo{inputs: []regMask{gp, gp | sp | sb}, outputs: []regMask{gp}}
		gp21cxer    = regInfo{inputs: []regMask{gp | sp | sb, gp | sp | sb}, outputs: []regMask{gp}, clobbers: xer}
		gp21xer     = regInfo{inputs: []regMask{gp | sp | sb, gp | sp | sb}, outputs: []regMask{gp, xer}, clobbers: xer}

	ptyp := c.config.Types.BytePtr
	fun := c.Fun("entry",
		Bloc("entry",
			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
			Valu("SP", OpSP, c.config.Types.Uintptr, 0, nil),
			Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"),
			Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"),
			Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"),
			Valu("c", OpConst64, c.config.Types.UInt64, amount, nil),

//
//go:nosplit
func libcCall(fn, arg unsafe.Pointer) int32 {
	// Leave caller's PC/SP/G around for traceback.
	gp := getg()
	var mp *m
	if gp != nil {
		mp = gp.m
	}
	if mp != nil && mp.libcallsp == 0 {
		mp.libcallg.set(gp)
		mp.libcallpc = getcallerpc()
		// sp must be the last, because once async cpu profiler finds
		// all three values to be non-zero, it will use them

        assertOrder(X_EQ_Y, "1.final", "1.Final");
        assertOrder(X_EQ_Y, "1.release", "1.RELEASE");
        assertOrder(X_EQ_Y, "1.release", "1.Release");

        assertOrder(X_EQ_Y, "1.sp", "1.SP");
        assertOrder(X_EQ_Y, "1.sp", "1.Sp");

        assertOrder(X_EQ_Y, "1.unknown", "1.UNKNOWN");
        assertOrder(X_EQ_Y, "1.unknown", "1.Unknown");
    }

    @Test

	// Save current m->g0->sched.sp on stack and then set it to SP.
	// Save current sp in m->g0->sched.sp in preparation for
	// switch back to m->curg stack.
	// NOTE: unwindm knows that the saved g->sched.sp is at 8(R29) aka savedsp-16(SP).
	MOVV	m_g0(R12), R19
	MOVV	(g_sched+gobuf_sp)(R19), R13
	MOVV	R13, savedsp-24(SP) // must match frame size
	MOVV	R3, (g_sched+gobuf_sp)(R19)

	// Switch to m->curg stack and call runtime.cgocallbackg.

	VPCMPUB $13, 17(SP)(BP*8), Y26, K2, K1             // 62f32d223e8cec110000000d
	VPCMPUB $13, 17(SP)(BP*4), Y26, K2, K1             // 62f32d223e8cac110000000d
	VPCMPUB $13, Y7, Y26, K2, K3                       // 62f32d223edf0d
	VPCMPUB $13, 17(SP)(BP*8), Y26, K2, K3             // 62f32d223e9cec110000000d
	VPCMPUB $13, 17(SP)(BP*4), Y26, K2, K3             // 62f32d223e9cac110000000d

	return nil
}

func (sp *subpath) PrepareSafeSubpath(subPath Subpath) (newHostPath string, cleanupAction func(), err error) {
	return subPath.Path, nil, errUnsupported
}

func (sp *subpath) CleanSubPaths(podDir string, volumeName string) error {
	return errUnsupported
}

func (sp *subpath) SafeMakeDir(pathname string, base string, perm os.FileMode) error {