JNE     10(PC)       // jump if F0 = 0
	FXCHD   F0, F1       // F0=q (smaller), F1=p (larger)
	FDIVD   F1, F0       // F0=q(=q/p), F1=p
	FMULD   F0, F0       // F0=q*q, F1=p
	FLD1                 // F0=1, F1=q*q, F2=p
	FADDDP  F0, F1       // F0=1+q*q, F1=p
	FSQRT                // F0=sqrt(1+q*q), F1=p
	FMULDP  F0, F1       // F0=p*sqrt(1+q*q)
	FMOVDP  F0, ret+16(FP)
	RET
	FMOVDP  F0, F1       // F0=0
	FMOVDP  F0, ret+16(FP)
	RET

// CHECK-DAG: [[cst_0:%.*]] = "tf.Const"() <{value = dense<2> : tensor<i32>}>
// CHECK: [[r0:%.*]] = "tf.AddV2"([[x]], [[cst]])
// CHECK: [[r1:%.*]] = "tf.AddV2"([[y]], [[r0]])
// CHECK: [[r2:%.*]] = "tf.AddV2"([[x]], [[cst_0]])
// CHECK: [[r3:%.*]] = "tf.AddV2"([[y]], [[r2]])
// CHECK: return [[r0]], [[r1]], [[r3]]

// CHECK-LABEL: func @merge_stateless

	fail64("/", div64_ssa, a, b, 0.75)
	fail64("neg", neg64_ssa, a, b, -7)

	fail32("+", add32_ssa, c, d, 7.0)
	fail32("*", mul32_ssa, c, d, 12.0)
	fail32("-", sub32_ssa, c, d, -1.0)
	fail32("/", div32_ssa, c, d, 0.75)
	fail32("neg", neg32_ssa, c, d, -7)

	// denorm-squared should underflow to zero.
	fail32("*", mul32_ssa, tiny, tiny, 0)

func parseIndVar(ind *Value) (min, inc, nxt *Value) {
	if ind.Op != OpPhi {
		return
	}

	if n := ind.Args[0]; (n.Op == OpAdd64 || n.Op == OpAdd32 || n.Op == OpAdd16 || n.Op == OpAdd8) && (n.Args[0] == ind || n.Args[1] == ind) {
		min, nxt = ind.Args[1], n
	} else if n := ind.Args[1]; (n.Op == OpAdd64 || n.Op == OpAdd32 || n.Op == OpAdd16 || n.Op == OpAdd8) && (n.Args[0] == ind || n.Args[1] == ind) {
		min, nxt = ind.Args[0], n
	} else {

    border-radius: 4px;
}
.alreadyRendered > a {
    border: solid 1px #EEEEEE;
    background-color: #EEEEEE !IMPORTANT;
}
.hasConflict > a {
    font-weight: bold !IMPORTANT;
    color: #FAA732 !IMPORTANT;
}
.unresolvable > a {
    border: solid 1px #DD514C;
    background-color: #DD514C !IMPORTANT;
    color: white !IMPORTANT;
}
.leaf a {
    font-style: italic !IMPORTANT;
}
.configuration h3 {

	lock(&globalRand.lock)
	if !globalRand.init {
		fatal("randinit missed")
	}
	globalRand.state.Reseed()
	unlock(&globalRand.lock)
}

// rand32 is uint32(rand()), called from compiler-generated code.
//
//go:nosplit
func rand32() uint32 {
	return uint32(rand())
}

// rand returns a random uint64 from the per-m chacha8 state.
// Do not change signature: used via linkname from other packages.

		addr1 := v1.UnsafeAddr()
		addr2 := v2.UnsafeAddr()
		if addr1 > addr2 {
			// Canonicalize order to reduce number of entries in visited.
			addr1, addr2 = addr2, addr1
		}

		// Short circuit if references are identical ...
		if addr1 == addr2 {
			return true
		}

		// ... or already seen
		typ := v1.Type()
		v := visit{addr1, addr2, typ}
		if visited[v] {
			return true
		}

	// FADD <Sd>, <Sn>, <Sm>
	{0xffe0fc00, 0x1e202800, FADD, instArgs{arg_Sd, arg_Sn, arg_Sm}, nil},
	// FADD <Dd>, <Dn>, <Dm>
	{0xffe0fc00, 0x1e602800, FADD, instArgs{arg_Dd, arg_Dn, arg_Dm}, nil},
	// FADD <Vd>.<t>, <Vn>.<t>, <Vm>.<t>

func Add(x, y, carry uint) (sum, carryOut uint) {
	if UintSize == 32 {
		s32, c32 := Add32(uint32(x), uint32(y), uint32(carry))
		return uint(s32), uint(c32)
	}
	s64, c64 := Add64(uint64(x), uint64(y), uint64(carry))
	return uint(s64), uint(c64)
}

// Add32 returns the sum with carry of x, y and carry: sum = x + y + carry.
// The carry input must be 0 or 1; otherwise the behavior is undefined.

		// bit
		OpCtz8, OpCtz16, OpCtz32, OpCtz64,
		// mask
		OpSlicemask,
		// safety check
		OpIsNonNil,
		// not
		OpNot:
		return true
	case
		// add
		OpAdd64, OpAdd32, OpAdd16, OpAdd8,
		OpAdd32F, OpAdd64F,
		// sub
		OpSub64, OpSub32, OpSub16, OpSub8,
		OpSub32F, OpSub64F,
		// mul
		OpMul64, OpMul32, OpMul16, OpMul8,
		OpMul32F, OpMul64F,
		// div