VRCP28PS 15(DX)(BX*1), K3, Z28                     // 62627d4bcaa41a0f000000
	VRCP28PS -7(CX)(DX*2), K3, Z28                     // 62627d4bcaa451f9ffffff
	VRCP28PS Z13, K3, Z6                               // 62d27d4bcaf5
	VRCP28PS Z21, K3, Z6                               // 62b27d4bcaf5
	VRCP28PS 15(DX)(BX*1), K3, Z6                      // 62f27d4bcab41a0f000000

	MOVL	DX, nsec+8(FP)
	RET

TEXT runtime·nanotime1(SB),NOSPLIT,$32
	MOVQ	$CLOCK_MONOTONIC, DI	// arg 1 - clock_id
	LEAQ	8(SP), SI		// arg 2 - tp
	MOVL	$SYS___clock_gettime50, AX
	SYSCALL
	MOVQ	8(SP), AX		// sec
	MOVQ	16(SP), DX		// nsec

	// sec is in AX, nsec in DX
	// return nsec in AX
	IMULQ	$1000000000, AX
	ADDQ	DX, AX
	MOVQ	AX, ret+0(FP)
	RET

TEXT runtime·getcontext(SB),NOSPLIT,$-8

	// so this function is reentrant.
	MOVL	m_vdsoPC(SI), CX
	MOVL	m_vdsoSP(SI), DX
	MOVL	CX, 0(SP)
	MOVL	DX, 4(SP)

	LEAL	sec+0(FP), DX
	MOVL	-4(DX), CX
	MOVL	CX, m_vdsoPC(SI)
	MOVL	DX, m_vdsoSP(SI)

	CMPL	AX, m_curg(SI)	// Only switch if on curg.
	JNE	noswitch

	MOVL	m_g0(SI), DX
	MOVL	(g_sched+gobuf_sp)(DX), SP	// Set SP to g0 stack

noswitch:
	SUBL	$16, SP		// Space for results

	MOVL	((index-2)*4)(BP), AX; \
	MOVL	AX, CX; \
	RORL	$17, AX; \
	MOVL	CX, DX; \
	RORL	$19, CX; \
	SHRL	$10, DX; \
	MOVL	((index-15)*4)(BP), BX; \
	XORL	CX, AX; \
	MOVL	BX, CX; \
	XORL	DX, AX; \
	RORL	$7, BX; \
	MOVL	CX, DX; \
	SHRL	$3, DX; \
	RORL	$18, CX; \
	ADDL	((index-7)*4)(BP), AX; \
	XORL	CX, BX; \
	XORL	DX, BX; \
	ADDL	((index-16)*4)(BP), BX; \
	ADDL	BX, AX; \
	MOVL	AX, ((index)*4)(BP)

	LEAQ	8(SP), SI
	SYSCALL
	MOVQ	8(SP), AX	// sec
	MOVQ	16(SP), DX	// nsec

	// sec is in AX, nsec in DX
	// return nsec in AX
	IMULQ	$1000000000, AX
	ADDQ	DX, AX
	MOVQ	AX, ret+0(FP)
	RET

TEXT runtime·asmSigaction(SB),NOSPLIT,$0
	MOVQ	sig+0(FP), DI		// arg 1 sig
	MOVQ	new+8(FP), SI		// arg 2 act
	MOVQ	old+16(FP), DX		// arg 3 oact
	MOVL	$SYS_sigaction, AX
	SYSCALL
	JCC	2(PC)

	VGF2P8AFFINEINVQB $47, (DX), Z14, K2, Z28          // 62638d4acf222f
	VGF2P8AFFINEINVQB $47, Z3, Z28, K2, Z28            // 62639d42cfe32f
	VGF2P8AFFINEINVQB $47, Z12, Z28, K2, Z28           // 62439d42cfe42f
	VGF2P8AFFINEINVQB $47, 99(R15)(R15*1), Z28, K2, Z28 // 62039d42cfa43f630000002f
	VGF2P8AFFINEINVQB $47, (DX), Z28, K2, Z28          // 62639d42cf222f

	MOVL	4(BX), SI		// arg 2 cmd
	MOVL	8(BX), DX		// arg 3 arg
	XORL	AX, AX			// vararg: say "no float args"
	CALL	libc_fcntl(SB)
	XORL	DX, DX
	CMPL	AX, $-1
	JNE	noerr
	CALL	libc_errno(SB)
	MOVL	(AX), DX
	MOVL	$-1, AX
noerr:
	MOVL	AX, 12(BX)
	MOVL	DX, 16(BX)
	RET

TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
	MOVQ	8(DI), SI		// arg 2 new
	MOVQ	16(DI), DX		// arg 3 old
	MOVL	0(DI), DI		// arg 1 sig

	VAESDEC (DX), Y0, Y23                              // 62e27d28de3a or 62e2fd28de3a
	VAESDEC Z27, Z3, Z11                               // 62126548dedb or 6212e548dedb
	VAESDEC Z15, Z3, Z11                               // 62526548dedf or 6252e548dedf
	VAESDEC 99(R15)(R15*1), Z3, Z11                    // 62126548de9c3f63000000 or 6212e548de9c3f63000000

	*r = r.Intersect(src.Bounds().Add(orig.Sub(*sp)))
	if mask != nil {
		*r = r.Intersect(mask.Bounds().Add(orig.Sub(*mp)))
	}
	dx := r.Min.X - orig.X
	dy := r.Min.Y - orig.Y
	if dx == 0 && dy == 0 {
		return
	}
	sp.X += dx
	sp.Y += dy
	if mp != nil {
		mp.X += dx
		mp.Y += dy
	}
}

func processBackward(dst image.Image, r image.Rectangle, src image.Image, sp image.Point) bool {

	VPLZCNTD 15(DX)(BX*1), K3, X17                     // 62e27d0b448c1a0f000000
	VPLZCNTD -7(CX)(DX*2), K3, X17                     // 62e27d0b448c51f9ffffff
	VPLZCNTD X3, K3, X15                               // 62727d0b44fb
	VPLZCNTD X26, K3, X15                              // 62127d0b44fa
	VPLZCNTD X23, K3, X15                              // 62327d0b44ff