MOV	(0*8)(X20), X5
	MOV	(1*8)(X20), X6
	MOV	(2*8)(X20), X7
	MOV	(3*8)(X20), X8
	ADD	X5, X10		// H0 = a + H0
	ADD	X6, X11		// H1 = b + H1
	ADD	X7, X12		// H2 = c + H2
	ADD	X8, X13		// H3 = d + H3
	MOV	X10, (0*8)(X20)
	MOV	X11, (1*8)(X20)
	MOV	X12, (2*8)(X20)
	MOV	X13, (3*8)(X20)
	MOV	(4*8)(X20), X5
	MOV	(5*8)(X20), X6
	MOV	(6*8)(X20), X7
	MOV	(7*8)(X20), X8

nocgo:
	MOV	$0x800000, A0                     // stacksize = 8192KB
	MOV	$_rt0_riscv64_linux_lib_go(SB), A1
	MOV	A0, 8(X2)
	MOV	A1, 16(X2)
	MOV	$runtime·newosproc0(SB), T0
	JALR	RA, T0

restore:
	// Restore callee-save registers, along with X1 (LR).
	MOV	(8*3)(X2), X1
	MOV	(8*4)(X2), X8
	MOV	(8*5)(X2), X9
	MOV	(8*6)(X2), X18
	MOV	(8*7)(X2), X19
	MOV	(8*8)(X2), X20
	MOV	(8*9)(X2), X21
	MOV	(8*10)(X2), X22
	MOV	(8*11)(X2), X23

TEXT runtime·usleep(SB),NOSPLIT,$24-4
	MOVWU	usec+0(FP), A0
	MOV	$1000, A1
	MUL	A1, A0, A0
	MOV	$1000000000, A1
	DIV	A1, A0, A2
	MOV	A2, 8(X2)
	REM	A1, A0, A3
	MOV	A3, 16(X2)
	ADD	$8, X2, A0
	MOV	ZERO, A1
	MOV	$SYS_nanosleep, T0
	ECALL
	RET

// func thr_self() thread
TEXT runtime·thr_self(SB),NOSPLIT,$8-8
	MOV	$ptr-8(SP), A0	// arg 1 &8(SP)
	MOV	$SYS_thr_self, T0
	ECALL
	MOV	ptr-8(SP), A0

	 * 8(X2).
	 */
	ADD	$(-8*29), X2
	MOV	X10, (8*1)(X2) // fn unsafe.Pointer
	MOV	X11, (8*2)(X2) // a unsafe.Pointer
	MOV	X13, (8*3)(X2) // ctxt uintptr
	MOV	X8, (8*4)(X2)
	MOV	X9, (8*5)(X2)
	MOV	X18, (8*6)(X2)
	MOV	X19, (8*7)(X2)
	MOV	X20, (8*8)(X2)
	MOV	X21, (8*9)(X2)
	MOV	X22, (8*10)(X2)
	MOV	X23, (8*11)(X2)
	MOV	X24, (8*12)(X2)
	MOV	X25, (8*13)(X2)
	MOV	X26, (8*14)(X2)
	MOV	g, (8*15)(X2)
	MOV	X1, (8*16)(X2)

	MOV	$64, X9
	BLT	X11, X9, zero32
loop64:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	MOV	ZERO, 32(X10)
	MOV	ZERO, 40(X10)
	MOV	ZERO, 48(X10)
	MOV	ZERO, 56(X10)
	ADD	$64, X10
	SUB	$64, X11
	BGE	X11, X9, loop64
	BEQZ	X11, done

check32:
	MOV	$32, X9
	BLT	X11, X9, check16
zero32:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)

func cmovfloatmove(x, y int) float64 {
	a := 1.0
	if x <= y {
		a = 2.0
	}
	// amd64:-"CMOV"
	// arm64:-"CSEL"
	// ppc64x:-"ISEL"
	// wasm:-"Select"
	return a
}

// On amd64, the following patterns trigger comparison inversion.
// Test that we correctly invert the CMOV condition
var gsink int64
var gusink uint64

func cmovinvert1(x, y int64) int64 {
	if x < gsink {
		y = -y

	CALL	runtime·spillArgs(SB)
	MOV	CTXT, 32(SP) // save CTXT > args of moveMakeFuncArgPtrs < LOCAL_REGARGS
	MOV	CTXT, 8(SP)
	MOV	X25, 16(SP)
	CALL	·moveMakeFuncArgPtrs(SB)
	MOV	32(SP), CTXT // restore CTXT

	MOV	CTXT, 8(SP)
	MOV	$argframe+0(FP), T0
	MOV	T0, 16(SP)
	MOV	ZERO, LOCAL_RETVALID(SP)
	ADD	$LOCAL_RETVALID, SP, T1
	MOV	T1, 24(SP)
	ADD	$LOCAL_REGARGS, SP, T1
	MOV	T1, 32(SP)
	CALL	·callReflect(SB)

	AND	$0xff, X13, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10
	BNE	X12, X15, loop
	ADD	$1, X14
	JMP	loop

done:
	MOV	X14, X10
	RET

TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = s_base
	// X11 = s_len
	// X12 = byte to count
	AND	$0xff, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
	for i := 0; i < 128; i++ {
		fmt.Fprintln(w, "\tMOV\t(X24), X31")
		fmt.Fprintln(w, "\tADD\t$8, X24")
		fmt.Fprintln(w, "\tMOV\tX31, (X25)")
		fmt.Fprintln(w, "\tADD\t$8, X25")
		fmt.Fprintln(w)
	}
	fmt.Fprintln(w, "\tRET")

// func archMax(x, y float64) float64
TEXT ·archMax(SB),NOSPLIT,$0
	MOVD	x+0(FP), F0
	MOVD	y+8(FP), F1
	FCLASSD	F0, X5
	FCLASSD	F1, X6

	// +Inf special cases
	MOV	$PosInf, X7
	BEQ	X7, X5, isMaxX
	BEQ	X7, X6, isMaxY

	// NaN special cases
	MOV	$NaN, X7
	BEQ	X7, X5, isMaxX
	BEQ	X7, X6, isMaxY

	// normal case
	FMAXD	F0, F1, F0
	MOVD	F0, ret+16(FP)
	RET

isMaxX: // return x
	MOVD	F0, ret+16(FP)