{value: 0x812d, lo: 0xb1, hi: 0xb1},
	{value: 0x8132, lo: 0xb2, hi: 0xb3},
	{value: 0x812d, lo: 0xb4, hi: 0xb4},
	{value: 0x8132, lo: 0xb5, hi: 0xb6},
	{value: 0x812d, lo: 0xb7, hi: 0xb9},
	{value: 0x8132, lo: 0xba, hi: 0xba},
	{value: 0x812d, lo: 0xbb, hi: 0xbc},
	{value: 0x8132, lo: 0xbd, hi: 0xbd},
	{value: 0x812d, lo: 0xbe, hi: 0xbe},
	{value: 0x8132, lo: 0xbf, hi: 0xbf},

	{value: 0x812e, lo: 0xb1, hi: 0xb1},
	{value: 0x8133, lo: 0xb2, hi: 0xb3},
	{value: 0x812e, lo: 0xb4, hi: 0xb4},
	{value: 0x8133, lo: 0xb5, hi: 0xb6},
	{value: 0x812e, lo: 0xb7, hi: 0xb9},
	{value: 0x8133, lo: 0xba, hi: 0xba},
	{value: 0x812e, lo: 0xbb, hi: 0xbc},
	{value: 0x8133, lo: 0xbd, hi: 0xbd},
	{value: 0x812e, lo: 0xbe, hi: 0xbe},
	{value: 0x8133, lo: 0xbf, hi: 0xbf},

	{value: 0x812e, lo: 0xb1, hi: 0xb1},
	{value: 0x8133, lo: 0xb2, hi: 0xb3},
	{value: 0x812e, lo: 0xb4, hi: 0xb4},
	{value: 0x8133, lo: 0xb5, hi: 0xb6},
	{value: 0x812e, lo: 0xb7, hi: 0xb9},
	{value: 0x8133, lo: 0xba, hi: 0xba},
	{value: 0x812e, lo: 0xbb, hi: 0xbc},
	{value: 0x8133, lo: 0xbd, hi: 0xbd},
	{value: 0x812e, lo: 0xbe, hi: 0xbe},
	{value: 0x8133, lo: 0xbf, hi: 0xbf},

	{value: 0x812e, lo: 0xb1, hi: 0xb1},
	{value: 0x8133, lo: 0xb2, hi: 0xb3},
	{value: 0x812e, lo: 0xb4, hi: 0xb4},
	{value: 0x8133, lo: 0xb5, hi: 0xb6},
	{value: 0x812e, lo: 0xb7, hi: 0xb9},
	{value: 0x8133, lo: 0xba, hi: 0xba},
	{value: 0x812e, lo: 0xbb, hi: 0xbc},
	{value: 0x8133, lo: 0xbd, hi: 0xbd},
	{value: 0x812e, lo: 0xbe, hi: 0xbe},
	{value: 0x8133, lo: 0xbf, hi: 0xbf},

// Running the proof means constructing and returning the implied hash of that
// subtree.
func runRecordProof(p RecordProof, lo, hi, n int64, leafHash Hash) (Hash, error) {
	// We must have lo <= n < hi or else the code here has a bug.
	if !(lo <= n && n < hi) {
		panic("tlog: bad math in runRecordProof")
	}

	if lo+1 == hi { // m == lo
		// Reached the leaf node.

	{value: 0x8132, lo: 0xa4, hi: 0xa5},
	{value: 0x812d, lo: 0xa6, hi: 0xa6},
	{value: 0x8132, lo: 0xa7, hi: 0xa8},
	{value: 0x812d, lo: 0xa9, hi: 0xa9},
	{value: 0x8132, lo: 0xaa, hi: 0xac},
	{value: 0x812d, lo: 0xad, hi: 0xaf},
	{value: 0x8116, lo: 0xb0, hi: 0xb0},
	{value: 0x8117, lo: 0xb1, hi: 0xb1},
	{value: 0x8118, lo: 0xb2, hi: 0xb2},
	{value: 0x8132, lo: 0xb3, hi: 0xb5},

	XORQ(carry, carry) // zero out carry

	for i := 0; i < bits/64; i++ {
		Comment("Iteration " + strconv.Itoa(i))
		hi, lo := RDX, RAX // implicit MULQ inputs and outputs
		MOVQ(x.Offset(i*8), lo)
		MULQ(y)
		ADDQ(z.Offset(i*8), lo)
		ADCQ(Imm(0), hi)
		ADDQ(carry, lo)
		ADCQ(Imm(0), hi)
		MOVQ(hi, carry)
		MOVQ(lo, z.Offset(i*8))
	}

	Store(carry, ReturnIndex(0))
	RET()

	Label("adx")

	{value: 0x8132, lo: 0xa4, hi: 0xa5},
	{value: 0x812d, lo: 0xa6, hi: 0xa6},
	{value: 0x8132, lo: 0xa7, hi: 0xa8},
	{value: 0x812d, lo: 0xa9, hi: 0xa9},
	{value: 0x8132, lo: 0xaa, hi: 0xac},
	{value: 0x812d, lo: 0xad, hi: 0xaf},
	{value: 0x8116, lo: 0xb0, hi: 0xb0},
	{value: 0x8117, lo: 0xb1, hi: 0xb1},
	{value: 0x8118, lo: 0xb2, hi: 0xb2},
	{value: 0x8132, lo: 0xb3, hi: 0xb5},

// its eq alg's generated code.
func (u uint128) isZero() bool { return u.hi|u.lo == 0 }

// and returns the bitwise AND of u and m (u&m).
func (u uint128) and(m uint128) uint128 {
	return uint128{u.hi & m.hi, u.lo & m.lo}
}

// xor returns the bitwise XOR of u and m (u^m).
func (u uint128) xor(m uint128) uint128 {
	return uint128{u.hi ^ m.hi, u.lo ^ m.lo}
}

// or returns the bitwise OR of u and m (u|m).

	{value: 0x812e, lo: 0xb1, hi: 0xb1},
	{value: 0x8133, lo: 0xb2, hi: 0xb3},
	{value: 0x812e, lo: 0xb4, hi: 0xb4},
	{value: 0x8133, lo: 0xb5, hi: 0xb6},
	{value: 0x812e, lo: 0xb7, hi: 0xb9},
	{value: 0x8133, lo: 0xba, hi: 0xba},
	{value: 0x812e, lo: 0xbb, hi: 0xbc},
	{value: 0x8133, lo: 0xbd, hi: 0xbd},
	{value: 0x812e, lo: 0xbe, hi: 0xbe},
	{value: 0x8133, lo: 0xbf, hi: 0xbf},