CMPQ    AX, R8
	JEQ     isPosInf
	MOVQ    y+8(FP), R9
	CMPQ    AX, R9
	JEQ     isPosInf
	// NaN special cases
	MOVQ    $~(1<<63), DX // bit mask
	MOVQ    $PosInf, AX
	MOVQ    R8, BX
	ANDQ    DX, BX // x = |x|
	CMPQ    AX, BX
	JLT     isMaxNaN
	MOVQ    R9, CX
	ANDQ    DX, CX // y = |y|
	CMPQ    AX, CX
	JLT     isMaxNaN
	// ±0 special cases
	ORQ     CX, BX
	JEQ     isMaxZero

	MOVQ    R8, X0

	VBROADCASTF64X2 15(DX)(BX*1), K1, Z14              // 6272fd491ab41a0f000000
	VBROADCASTF64X2 -7(CX)(DX*2), K1, Z14              // 6272fd491ab451f9ffffff
	VBROADCASTF64X2 15(DX)(BX*1), K1, Z28              // 6262fd491aa41a0f000000
	VBROADCASTF64X2 -7(CX)(DX*2), K1, Z28              // 6262fd491aa451f9ffffff
	VBROADCASTI32X2 X14, K1, X19                       // 62c27d0959de

	MOVL	lo64+0(FP), CX
	MOVL	a_lo+4(FP), AX
	MULL	b+12(FP)
	MOVL	AX, 0(CX)
	MOVL	DX, BX
	MOVL	a_hi+8(FP), AX
	MULL	b+12(FP)
	ADDL	AX, BX
	ADCL	$0, DX
	MOVL	BX, 4(CX)
	MOVL	DX, AX
	MOVL	AX, hi32+16(FP)
	RET

TEXT runtime·_div64by32(SB), NOSPLIT, $0
	MOVL	r+12(FP), CX
	MOVL	a_lo+0(FP), AX
	MOVL	a_hi+4(FP), DX
	DIVL	b+8(FP)
	MOVL	DX, 0(CX)
	MOVL	AX, q+16(FP)

				{0, 239}, // AX CX DX BX BP SI DI
				{1, 239}, // AX CX DX BX BP SI DI
			},
			outputs: []outputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},
		},
	},
	{
		name:         "ADCLconst",
		auxType:      auxInt32,
		argLen:       2,
		resultInArg0: true,
		clobberFlags: true,
		asm:          x86.AADCL,
		reg: regInfo{
			inputs: []inputInfo{
				{0, 239}, // AX CX DX BX BP SI DI

	VPCLMULQDQ $97, 15(DX)(BX*8), Z26, Z24             // 62632d404484da0f00000061 or 6263ad404484da0f00000061
	VPCLMULQDQ $97, Z9, Z0, Z12                        // 62537d4844e161 or 6253fd4844e161
	VPCLMULQDQ $97, Z3, Z0, Z12                        // 62737d4844e361 or 6273fd4844e361
	VPCLMULQDQ $97, 7(SI)(DI*1), Z0, Z12               // 62737d4844a43e0700000061 or 6273fd4844a43e0700000061

	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

	tinycall()                // this forces l etc to stack
	dx := l.end.x - l.begin.x //gdb-dbg=(l.begin.x,l.end.y)//gdb-opt=(l,dx/O,dy/O)
	dy := l.end.y - l.begin.y //gdb-opt=(dx,dy/O)
	sink = dx + dy            //gdb-opt=(dx,dy)
	// For #21098
	hist := make([]int, 7)                                //gdb-opt=(dx/O,dy/O) // TODO sink is missing if this code is in 'test' instead of 'main'

	*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 {

	MOVL y+8(FP), BP
	LEAL (DI)(BX*4), DI
	LEAL (SI)(BX*4), SI
	NEGL BX			// i = -n
	MOVL $0, CX		// c = 0
	JMP E6

L6:	MOVL (SI)(BX*4), AX
	MULL BP
	ADDL CX, AX
	ADCL $0, DX
	ADDL AX, (DI)(BX*4)
	ADCL $0, DX
	MOVL DX, CX
	ADDL $1, BX		// i++

E6:	CMPL BX, $0		// i < 0
	JL L6

	MOVL CX, c+12(FP)

	V4FNMADDPS 99(R15)(R15*1), [Z1-Z4], K3, Z15        // 6212774baabc3f63000000
	V4FNMADDPS (DX), [Z1-Z4], K3, Z15                  // 6272774baa3a
	V4FNMADDPS 99(R15)(R15*1), [Z11-Z14], K3, Z15      // 6212274baabc3f63000000
	V4FNMADDPS (DX), [Z11-Z14], K3, Z15                // 6272274baa3a
	V4FNMADDPS 99(R15)(R15*1), [Z21-Z24], K3, Z15      // 62125743aabc3f63000000
	V4FNMADDPS (DX), [Z21-Z24], K3, Z15                // 62725743aa3a