VBROADCASTF32X4 -7(DI), K2, Z16                    // 62e27d4a1a87f9ffffff
	VBROADCASTF64X4 15(R8)(R14*1), K1, Z3              // 6292fd491b9c300f000000
	VBROADCASTF64X4 15(R8)(R14*2), K1, Z3              // 6292fd491b9c700f000000
	VBROADCASTF64X4 15(R8)(R14*1), K1, Z12             // 6212fd491ba4300f000000
	VBROADCASTF64X4 15(R8)(R14*2), K1, Z12             // 6212fd491ba4700f000000

		if i > 48 {
			seed1 := seed
			seed2 := seed
			for ; i > 48; i -= 48 {
				seed = mix(r8(p)^m2, r8(p[8:])^seed)
				seed1 = mix(r8(p[16:])^m3, r8(p[24:])^seed1)
				seed2 = mix(r8(p[32:])^m4, r8(p[40:])^seed2)
				p = p[48:]
			}
			seed ^= seed1 ^ seed2
		}
		for ; i > 16; i -= 16 {
			seed = mix(r8(p)^m2, r8(p[8:])^seed)
			p = p[16:]
		}
	}
	switch {
	case i == 0:
		return seed
	case i < 4:

	MOVQ b_base+0(FP), SI
	MOVQ b_len+8(FP), BX
	MOVB c+24(FP), AL
	LEAQ ret+32(FP), R8
	JMP  indexbytebody<>(SB)

TEXT	·IndexByteString(SB), NOSPLIT, $0-32
	MOVQ s_base+0(FP), SI
	MOVQ s_len+8(FP), BX
	MOVB c+16(FP), AL
	LEAQ ret+24(FP), R8
	JMP  indexbytebody<>(SB)

// input:
//   SI: data
//   BX: data len
//   AL: byte sought
//   R8: address to put result
TEXT	indexbytebody<>(SB), NOSPLIT, $0

	MOVD $·Pipe2(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_FlockAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Flock(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_GetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Getxattr(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_NanosleepAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Nanosleep(SB), R8
	MOVD R8, ret+0(FP)
	RET

	VGF2P8AFFINEQB $82, -7(DI)(R8*4), X21, K1, X15     // 6233d501cebc87f9ffffff52
	VGF2P8AFFINEQB $82, X22, X0, K1, X15               // 6233fd09cefe52
	VGF2P8AFFINEQB $82, X7, X0, K1, X15                // 6273fd09ceff52
	VGF2P8AFFINEQB $82, X19, X0, K1, X15               // 6233fd09cefb52
	VGF2P8AFFINEQB $82, 17(SP)(BP*2), X0, K1, X15      // 6273fd09cebc6c1100000052
	VGF2P8AFFINEQB $82, -7(DI)(R8*4), X0, K1, X15      // 6233fd09cebc87f9ffffff52

	MOVD	m_g0(R0), g
	MOVD	R0, g_m(g)
	BL	emptyfunc<>(SB)	 // fault if stack check is wrong
	BL	runtime·mstart(SB)

	MOVD	$2, R8	// crash (not reached)
	MOVD	R8, (R8)
	RET

// func exit(code int32)
TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
	MOVW	code+0(FP), R0
	MOVD	$SYS_exit, R8
	SVC
	MOVD	$0, R0
	MOVD	R0, (R0)

// func exitThread(wait *atomic.Uint32)
TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8

	ADDV	R4, R5, R6

	// if less than 8 bytes, do one byte at a time
	SGTU	$8, R5, R8
	BNE	R8, out

	// do one byte at a time until 8-aligned
	AND	$7, R4, R8
	BEQ	R8, words
	MOVB	R0, (R4)
	ADDV	$1, R4
	JMP	-4(PC)

words:
	// do 8 bytes at a time if there is room
	ADDV	$-7, R6, R5

	PCALIGN	$16
	SGTU	R5, R4, R8
	BEQ	R8, out
	MOVV	R0, (R4)
	ADDV	$8, R4
	JMP	-4(PC)

out:
	BEQ	R4, R6, done

	MOVD    R4, ret+16(FP)
	RET
isMaxZero:
	MOVD    $(1<<63), R4 // -0.0
	CMPUBEQ R4, R8, +3(PC)
	MOVD    R8, ret+16(FP) // return 0
	RET
	MOVD    R9, ret+16(FP) // return other 0
	RET

// func archMin(x, y float64) float64
TEXT ·archMin(SB),NOSPLIT,$0
	// -Inf special cases
	MOVD    $NegInf, R4
	MOVD    x+0(FP), R8
	CMPUBEQ R4, R8, isNegInf
	MOVD    y+8(FP), R9
	CMPUBEQ R4, R9, isNegInf
	// NaN special cases

	CBNZ	R6, use_aligned_loads
	MOVD	R0, R7
	MOVD	R5, R8
	B	backward_check
use_aligned_loads:
	MOVD	R1, R7
	MOVD	R4, R8
	// R7 and R8 are used here for the realignment calculation. In
	// the use_aligned_loads case, R7 is the src pointer and R8 is
	// srcend pointer, which is used in the backward copy case.
	// When doing aligned stores, R7 is the dst pointer and R8 is
	// the dstend pointer.

backward_check:

	MOVHU.P	-0x24(R9), R8        // MOVHU.P -36(R9), R8       // b48259e0
	MOVH	-0x24(R9), R8        // MOVH -36(R9), R8          // f48259e1
	MOVH.W	-0x24(R9), R8        // MOVH.W -36(R9), R8        // f48279e1
	MOVH.P	-0x24(R9), R8        // MOVH.P -36(R9), R8        // f48259e0
	MOVHS	-0x24(R9), R8        // MOVHS -36(R9), R8         // f48259e1