* Y3 = Y3-T2 << store-out Y3 result reg

 	// X=Z1; Y=Z1; MUL; T-   // T1 = Z1*Z1
	// X-  ; Y=T ; MUL; R=T  // R  = Z1*T1
	// X=X2; Y-  ; MUL; H=T  // H  = X2*T1
	// X=Z2; Y=Z2; MUL; T-   // T2 = Z2*Z2
	// X-  ; Y=T ; MUL; S1=T // S1 = Z2*T2
	// X=X1; Y-  ; MUL; U1=T // U1 = X1*T2
	// SUB(H<H-T)            // H  = H-U1
	// X=Z1; Y=Z2; MUL; T-   // Z3 = Z1*Z2

package y

-- y2-pre/go.mod --
module example.net/y

go 1.16
-- y2-pre/README.txt --
Package y has been removed.

-- z1/go.mod --
module example.net/z

go 1.16

require (
	example.net/x v0.2.0-pre
	example.net/y v0.2.0-pre
)
-- z1/z.go --
package z

-- z2-pre/go.mod --
module example.net/z

go 1.16
-- z2-pre/README.txt --

	z0 := zero / zero
	// amd64:"MULSD"
	z1 := zero * inf
	// amd64:"SQRTSD"
	z2 := math.Sqrt(negone)
	return z0 + z1 + z2
}

func nanGenerate32() float32 {
	zero := float32(0.0)
	// amd64:-"DIVSS"
	inf := 1 / zero // +inf. We can constant propagate this one.

	// amd64:"DIVSS"
	z0 := zero / zero
	// amd64:"MULSS"
	z1 := zero * inf
	return z0 + z1

	VPERMI2W Z28, Z12, K3, Z1                          // 62929d4b75cc
	VPERMI2W Z13, Z12, K3, Z1                          // 62d29d4b75cd
	VPERMI2W 99(R15)(R15*8), Z12, K3, Z1               // 62929d4b758cff63000000
	VPERMI2W 7(AX)(CX*8), Z12, K3, Z1                  // 62f29d4b758cc807000000
	VPERMI2W Z28, Z16, K3, Z1                          // 6292fd4375cc
	VPERMI2W Z13, Z16, K3, Z1                          // 62d2fd4375cd

    %1 = stablehlo.constant dense<2.000000e-01> : tensor<1x1x1xf32>  // Input 1 inverse scale (1 / s1).
    %2 = stablehlo.constant dense<-128> : tensor<1x1x1xi8>  // Input 1 zero point (z1).
    %3 = stablehlo.constant dense<-128> : tensor<1x1x1xi32>  // Input 1 zero point (z1) (upcast & folded into i32).
    %4 = stablehlo.constant dense<4.000000e-01> : tensor<1x1x1xf32>  // Input 2 inverse scale (1 / s2).

	case string:
		_ = func() string {
			return t
		}
	}

	switch t := t; t /* ERROR "declared and not used" */ := t.(type) {}

	var z1 /* ERROR "declared and not used" */ int
	var z2 int
	_ = func(a, b, c int) (u, v, w int) {
		z1 = a
		(z1) = b
		a = z2
		return
	}

	var s []int
	var i /* ERROR "declared and not used" */ , j int
	for i, j = range s {
		_ = j
	}

// Elementary operations on words
//
// These operations are used by the vector operations below.

// z1<<_W + z0 = x*y
func mulWW(x, y Word) (z1, z0 Word) {
	hi, lo := bits.Mul(uint(x), uint(y))
	return Word(hi), Word(lo)
}

// z1<<_W + z0 = x*y + c
func mulAddWWW_g(x, y, c Word) (z1, z0 Word) {
	hi, lo := bits.Mul(uint(x), uint(y))
	var cc uint
	lo, cc = bits.Add(lo, uint(c), 0)

func BenchmarkAdd64multiple(b *testing.B) {
	var z0 = uint64(Input)
	var z1 = uint64(Input)
	var z2 = uint64(Input)
	var z3 = uint64(Input)
	for i := 0; i < b.N; i++ {
		var c uint64
		z0, c = Add64(z0, uint64(i), c)
		z1, c = Add64(z1, uint64(i), c)
		z2, c = Add64(z2, uint64(i), c)
		z3, _ = Add64(z3, uint64(i), c)
	}
	Output = int(z0 + z1 + z2 + z3)
}

func BenchmarkSub(b *testing.B) {

			},
			nodes: []*v1.Node{
				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: map[string]string{"region": "r1", "zone": "z1", "hostname": "nodeA"}}},
				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: map[string]string{"region": "r1", "zone": "z1", "hostname": "nodeB"}}},
			},
			wantPreFilterStatus: framework.NewStatus(framework.Skip),
			wantFilterStatuses:  []*framework.Status{nil, nil},

	VPOPCNTQ 7(AX)(CX*1), K2, Y19                      // 62e2fd2a559c0807000000
	VPOPCNTQ Z1, K2, Z20                               // 62e2fd4a55e1
	VPOPCNTQ Z3, K2, Z20                               // 62e2fd4a55e3
	VPOPCNTQ 17(SP), K2, Z20                           // 62e2fd4a55a42411000000
	VPOPCNTQ -17(BP)(SI*4), K2, Z20                    // 62e2fd4a55a4b5efffffff
	VPOPCNTQ Z1, K2, Z9                                // 6272fd4a55c9