// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R3

	// Ask signaller to setgid
	MOVW	$1, R12
	DBAR
	MOVW	R12, ·Baton(SB)
	DBAR

	// Wait for setgid completion
loop:
	DBAR
	MOVW	·Baton(SB), R12
	OR	R13, R13, R13	// hint that we're in a spin loop
	BNE	R12, loop
	DBAR

	// Restore stack
	ADDV	$(-1024*8), R3

	// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R29

	// Ask signaller to setgid
	MOVW	$1, R1
	SYNC
	MOVW	R1, ·Baton(SB)
	SYNC

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R1
	OR	R2, R2, R2	// hint that we're in a spin loop
	BNE	R1, loop
	SYNC

	// Restore stack
	ADDV	$(-1024*8), R29

	BNE	R0, R15, byte_loop

	PCALIGN	$16
chunk16_loop:
	BEQ	R0, R14, byte_loop
	MOVV	(R4), R8
	MOVV	(R6), R9
	BNE	R8, R9, byte_loop
	MOVV	8(R4), R16
	MOVV	8(R6), R17
	ADDV	$16, R4
	ADDV	$16, R6
	SUBVU	$1, R14
	BEQ	R16, R17, chunk16_loop
	SUBV	$8, R4
	SUBV	$8, R6

byte_loop:
	BEQ	R4, R12, samebytes
	MOVBU	(R4), R8
	ADDVU	$1, R4
	MOVBU	(R6), R9
	ADDVU	$1, R6
	BEQ	R8, R9, byte_loop

byte_cmp:

	BNE	R0, R11, byte_loop

chunk16_loop:
	BEQ	R0, R10, byte_loop
	MOVV	(R3), R6
	MOVV	(R4), R7
	BNE	R6, R7, byte_loop
	MOVV	8(R3), R13
	MOVV	8(R4), R14
	ADDV	$16, R3
	ADDV	$16, R4
	SUBVU	$1, R10
	BEQ	R13, R14, chunk16_loop
	SUBV	$8, R3
	SUBV	$8, R4

byte_loop:
	BEQ	R3, R8, samebytes
	MOVBU	(R3), R6
	ADDVU	$1, R3
	MOVBU	(R4), R7
	ADDVU	$1, R4
	BEQ	R6, R7, byte_loop

byte_cmp:

	fmt.Fprintln(buf, "BNE R5, label23")

	for i := 0; i <= genSize1; i++ {
		fmt.Fprintln(buf, "ADDV $0, R0, R0")
	}

	fmt.Fprintln(buf, "label18:")
	for i := 0; i <= (genSize2 - genSize1); i++ {
		fmt.Fprintln(buf, "ADDV $0, R0, R0")
	}

	fmt.Fprintln(buf, "label23:")
	fmt.Fprintln(buf, "ADDV $0, R0, R0")
	fmt.Fprintln(buf, "RET")

	 *  push 3 args for fn (R4, R5, R7), skipping R6.
	 * Also note that at procedure entry in gc world, 8(R29) will be the
	 *  first arg.
	 */
#ifndef GOMIPS64_softfloat
	ADDV	$(-8*23), R29
#else
	ADDV	$(-8*15), R29
#endif
	MOVV	R4, (8*1)(R29) // fn unsafe.Pointer
	MOVV	R5, (8*2)(R29) // a unsafe.Pointer
	MOVV	R7, (8*3)(R29) // ctxt uintptr
	MOVV	R16, (8*4)(R29)
	MOVV	R17, (8*5)(R29)

// No arg size here, runtime pulls arg map out of the func value.
TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
	NO_LOCAL_POINTERS
	MOVV	REGCTXT, 8(R29)
	MOVV	$argframe+0(FP), R1
	MOVV	R1, 16(R29)
	MOVB	R0, 40(R29)
	ADDV	$40, R29, R1
	MOVV	R1, 24(R29)
	MOVV	R0, 32(R29)
	JAL	·callReflect(SB)
	RET

// methodValueCall is the code half of the function returned by makeMethodValue.

	ADD $-256, R4

	// rearrange vectors
	SHUFFLE(X0, X1, X2, X3, M0, M1, M2, M3)
	ADDV(J0, X0, X1, X2, X3)
	SHUFFLE(X4, X5, X6, X7, M0, M1, M2, M3)
	ADDV(KEY0, X4, X5, X6, X7)
	SHUFFLE(X8, X9, X10, X11, M0, M1, M2, M3)
	ADDV(KEY1, X8, X9, X10, X11)
	VAF CTR, X12, X12
	SHUFFLE(X12, X13, X14, X15, M0, M1, M2, M3)
	ADDV(NONCE, X12, X13, X14, X15)

	// increment counters
	VAF INC, CTR, CTR

	ADD	$4097, R4  			// 3e000014de07800384781000
	ADDV	$74565, R4			// 5e020014de178d0384f81000
	ADDV	$4097, R4 			// 3e000014de07800384f81000
	AND	$74565, R4			// 5e020014de178d0384f81400
	AND	$4097, R4 		 	// 3e000014de07800384f81400
	ADD	$74565, R4, R5			// 5e020014de178d0385781000
	ADD	$4097, R4, R5  			// 3e000014de07800385781000
	ADDV	$74565, R4, R5			// 5e020014de178d0385f81000
	ADDV	$4097, R4, R5 			// 3e000014de07800385f81000

	/*
	 * We still need to save all callee save register as before, and then
	 * push 3 args for fn (R4, R5, R7), skipping R6.
	 * Also note that at procedure entry in gc world, 8(R29) will be the
	 *  first arg.
	 */

	ADDV	$(-23*8), R3
	MOVV	R4, (1*8)(R3) // fn unsafe.Pointer
	MOVV	R5, (2*8)(R3) // a unsafe.Pointer
	MOVV	R7, (3*8)(R3) // ctxt uintptr

	SAVE_R22_TO_R31((4*8))
	SAVE_F24_TO_F31((14*8))
	MOVV	R1, (22*8)(R3)