fsd	f23, 160(sp)
	fsd	f24, 168(sp)
	fsd	f25, 176(sp)
	fsd	f26, 184(sp)
	fsd	f27, 192(sp)

	// a0 = *fn, a1 = *setg_gcc, a2 = *g
	mv	s1, a0
	mv	s0, a1
	mv	a0, a2
	jalr	ra, s0	// call setg_gcc (clobbers x30 aka g)
	jalr	ra, s1	// call fn

	ld	x1, 0(sp)
	ld	x8, 8(sp)
	ld	x9, 16(sp)
	ld	x18, 24(sp)
	ld	x19, 32(sp)
	ld	x20, 40(sp)
	ld	x21, 48(sp)
	ld	x22, 56(sp)
	ld	x23, 64(sp)
	ld	x24, 72(sp)

	VCVTQQ2PD X13, K3, X30                             // 6241fe0be6f5
	VCVTQQ2PD X6, K3, X30                              // 6261fe0be6f6
	VCVTQQ2PD X12, K3, X30                             // 6241fe0be6f4
	VCVTQQ2PD 17(SP)(BP*1), K3, X30                    // 6261fe0be6b42c11000000
	VCVTQQ2PD -7(CX)(DX*8), K3, X30                    // 6261fe0be6b4d1f9ffffff

				{2, 1073741808},          // X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30
				{0, 9223372037928517618}, // SP X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 SB
			},
			outputs: []outputInfo{
				{0, 1006632944}, // X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30
			},
		},
	},

	if err == nil {
		t.Errorf("invalid UTF8 string was accepted")
	}
}

func TestMarshalOID(t *testing.T) {
	var marshalTestsOID = []marshalTest{
		{[]byte("\x06\x01\x30"), "0403060130"}, // bytes format returns a byte sequence \x04
		// {ObjectIdentifier([]int{0}), "060100"}, // returns an error as OID 0.0 has the same encoding

	VPSHRDQ $42, X8, X14, K3, X30                      // 62438d0b73f02a
	VPSHRDQ $42, -7(DI)(R8*1), X14, K3, X30            // 62238d0b73b407f9ffffff2a
	VPSHRDQ $42, (SP), X14, K3, X30                    // 62638d0b7334242a
	VPSHRDQ $42, X14, X11, K3, X30                     // 6243a50b73f62a
	VPSHRDQ $42, X19, X11, K3, X30                     // 6223a50b73f32a

	var x21 [10<<20]byte
	var x22 [10<<20]byte
	var x23 [10<<20]byte
	var x24 [10<<20]byte
	var x25 [10<<20]byte
	var x26 [10<<20]byte
	var x27 [10<<20]byte
	var x28 [10<<20]byte
	var x29 [10<<20]byte
	var x30 [10<<20]byte
	var x31 [10<<20]byte
	var x32 [10<<20]byte
	var x33 [10<<20]byte
	var x34 [10<<20]byte
	var x35 [10<<20]byte
	var x36 [10<<20]byte
	var x37 [10<<20]byte
	var x38 [10<<20]byte
	var x39 [10<<20]byte

	"X12",
	"X13",
	"X14",
	"X15",
	"X16",
	"X17",
	"X18",
	"X19",
	"X20",
	"X21",
	"X22",
	"X23",
	"X24",
	"X25",
	"X26",
	"X27",
	"X28",
	"X29",
	"X30",
	"X31",
	"Y0",
	"Y1",
	"Y2",
	"Y3",
	"Y4",
	"Y5",
	"Y6",
	"Y7",
	"Y8",
	"Y9",
	"Y10",
	"Y11",
	"Y12",
	"Y13",
	"Y14",
	"Y15",
	"Y16",
	"Y17",

	exc uint32 // number of arm exception taken
}

type regs64 struct {
	x     [29]uint64 // registers x0 to x28
	fp    uint64     // frame register, x29
	lr    uint64     // link register, x30
	sp    uint64     // stack pointer, x31
	pc    uint64     // program counter
	cpsr  uint32     // current program status register
	__pad uint32
}

type neonstate64 struct {

	VSCALEFSD X6, X13, K7, X30                         // 6262950f2df6 or 6262952f2df6 or 6262954f2df6
	VSCALEFSD -17(BP)(SI*8), X13, K7, X30              // 6262950f2db4f5efffffff or 6262952f2db4f5efffffff or 6262954f2db4f5efffffff
	VSCALEFSD (R15), X13, K7, X30                      // 6242950f2d37 or 6242952f2d37 or 6242954f2d37
	VSCALEFSS X30, X23, K7, X12                        // 621245072de6

	var x28 uint64
	x27, x28 = bits.Sub64(x9, 0xffffffffffffffff, uint64(p521Uint1(x26)))
	var x29 uint64
	var x30 uint64
	x29, x30 = bits.Sub64(x11, 0xffffffffffffffff, uint64(p521Uint1(x28)))
	var x31 uint64
	var x32 uint64
	x31, x32 = bits.Sub64(x13, 0xffffffffffffffff, uint64(p521Uint1(x30)))
	var x33 uint64
	var x34 uint64
	x33, x34 = bits.Sub64(x15, 0xffffffffffffffff, uint64(p521Uint1(x32)))