m[0][3]*m[1][2]*m[2][0]*m[3][1] +
		m[0][3]*m[1][2]*m[2][1]*m[3][0]
}

type A []A

// A sequence of constant indexings.
func IndexChain1(s A) A {
	return s[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0]
}

// A sequence of non-constant indexings.
func IndexChain2(s A, i int) A {
	return s[i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i]
}

// Another sequence of indexings.

	b.Run(" XXXXX0|000000 ", func(b *testing.B) { benchmarkErasureEncode(6, 6, 5, 0, size, b) })
}

func BenchmarkErasureEncode_16_40MB(b *testing.B) {
	const size = 40 * 1024 * 1024
	b.Run(" 00000000|00000000 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 0, 0, size, b) })
	b.Run(" 00000000|X0000000 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 0, 1, size, b) })

# CHECK:       quantization: {
# CHECK:         scale: [ 0.027216, 0.00038, 0.000413, 0.000426, 0.001607,
# CHECK:         zero_point: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# CHECK:       }
# CHECK:     }, {
# CHECK:       shape: [ 186, 1, 1, 256 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 4,

	b.Run(" XXXXXX|000000 ", func(b *testing.B) { benchmarkErasureDecode(6, 6, 6, 0, size, b) })
}

func BenchmarkErasureDecode_16_40MB(b *testing.B) {
	const size = 40 * 1024 * 1024
	b.Run(" 00000000|00000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 0, 0, size, b) })
	b.Run(" 00000000|X0000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 0, 1, size, b) })

// Constants
DATA ·pow_x001a<> + 0(SB)/8, $0x1a000000000000
GLOBL ·pow_x001a<> + 0(SB), RODATA, $8
DATA ·pow_xinf<> + 0(SB)/8, $0x7ff0000000000000      //+Inf
GLOBL ·pow_xinf<> + 0(SB), RODATA, $8
DATA ·pow_xnan<> + 0(SB)/8, $0x7ff8000000000000      //NaN
GLOBL ·pow_xnan<> + 0(SB), RODATA, $8
DATA ·pow_x434<> + 0(SB)/8, $0x4340000000000000
GLOBL ·pow_x434<> + 0(SB), RODATA, $8

	initfunc, addmoduledata := ld.PrepareAddmoduledata(ctxt)
	if initfunc == nil {
		return
	}

	o := func(op ...uint8) {
		for _, op1 := range op {
			initfunc.AddUint8(op1)
		}
	}

	// 0000000000000000 <local.dso_init>:
	//    0:	48 8d 3d 00 00 00 00 	lea    0x0(%rip),%rdi        # 7 <local.dso_init+0x7>
	// 			3: R_X86_64_PC32	runtime.firstmoduledata-0x4
	o(0x48, 0x8d, 0x3d)

					z := complex(y, 0)
					z += complex128(complex(x, 1) * 3)
					return z
				}(t.x, t.y),
				t.res)
		}
	}
}

const (
	aa = 0x1000000000000000
	ab = 0x100000000000000
	ac = 0x10000000000000
	ad = 0x1000000000000
	ba = 0x100000000000
	bb = 0x10000000000
	bc = 0x1000000000
	bd = 0x100000000
	ca = 0x10000000
	cb = 0x1000000
	cc = 0x100000
	cd = 0x10000
	da = 0x1000

func gentext(ctxt *ld.Link, ldr *loader.Loader) {
	initfunc, addmoduledata := ld.PrepareAddmoduledata(ctxt)
	if initfunc == nil {
		return
	}

	o := func(op uint32) {
		initfunc.AddUint32(ctxt.Arch, op)
	}
	// 0000000000000000 <local.dso_init>:
	// 0:	90000000 	adrp	x0, 0 <runtime.firstmoduledata>
	// 	0: R_AARCH64_ADR_PREL_PG_HI21	local.moduledata
	// 4:	91000000 	add	x0, x0, #0x0
	// 	4: R_AARCH64_ADD_ABS_LO12_NC	local.moduledata

func p521ToMontgomery(out1 *p521MontgomeryDomainFieldElement, arg1 *p521NonMontgomeryDomainFieldElement) {
	var x1 uint64
	var x2 uint64
	x2, x1 = bits.Mul64(arg1[0], 0x400000000000)
	var x3 uint64
	var x4 uint64
	x4, x3 = bits.Mul64(arg1[1], 0x400000000000)
	var x5 uint64
	var x6 uint64
	x5, x6 = bits.Add64(x2, x3, uint64(0x0))
	var x7 uint64
	var x8 uint64
	x8, x7 = bits.Mul64(x1, 0x1ff)
	var x9 uint64

    <magic priority="50">
      <match value="0x7431" type="string" offset="0">
        <match value="[\x72|\x33|\x36|\x35]" type="regex" offset="3">
          <match value="0x00000000000000" offset="5"/>
        </match>
      </match>
    </magic>
    <!-- do we want to use this for such a rare format?   <glob pattern="*.rpy"/> -->
  </mime-type>