}
				if fun.values["phi"].Op != OpCondSelect {
					t.Fatalf("expected phi op to be CondSelect; found op %s", fun.values["phi"].Op)
				}
				if fun.values["phi"].Args[2] != fun.values["cond"] {
					t.Errorf("expected CondSelect condition to be %s; found %s", fun.values["cond"], fun.values["phi"].Args[2])
				}
				if fun.blocks["entry"].Kind != BlockExit {

	// i1.M()
	
	// This combination is illegal because
	// PM requires a pointer receiver.
	// var pi1 PI = t
	// pi1.PM()

	var pt = &t
	pt.M()
	pt.PM()

	var i2 I = pt
	i2.M()

	var pi2 PI = pt
	pi2.PM()

	if math.Abs(x) < reduceThreshold {
		// Use Cody-Waite reduction in three parts.
		const (
			// PI1, PI2 and PI3 comprise an extended precision value of PI
			// such that PI ~= PI1 + PI2 + PI3. The parts are chosen so
			// that PI1 and PI2 have an approximately equal number of trailing
			// zero bits. This ensures that t*PI1 and t*PI2 are exact for
			// large integer values of t. The full precision PI3 ensures the

			Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
			Goto("loop")),
		Bloc("loop",
			Valu("phi", OpPhi, types.TypeMem, 0, nil, "start", "wb"),
			Valu("v", OpConstNil, ptrType, 0, nil),
			Valu("addr", OpAddr, ptrType, 0, nil, "sb"),
			Valu("wb", OpStore, types.TypeMem, 0, ptrType, "addr", "v", "phi"), // has write barrier
			Goto("loop")))

	CheckFunc(fun.f)
	writebarrier(fun.f)
	CheckFunc(fun.f)

var testResetConfig = fmt.Sprintf(`apiVersion: %s
kind: ResetConfiguration
force: true
dryRun: true
cleanupTmpDir: true
criSocket: %s:///var/run/fake.sock
certificatesDir: /etc/kubernetes/pki2
ignorePreflightErrors:
- a
- b
`, kubeadmapiv1.SchemeGroupVersion.String(), defaultURLScheme)

func TestNewResetData(t *testing.T) {
	// create temp directory
	tmpDir, err := os.MkdirTemp("", "kubeadm-reset-test")

// Archived copy at:
// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/

// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
// Or, on 64-bit, just read lo:hi1 all at once atomically.
#define _INTERRUPT_TIME 0x7ffe0008
#define _SYSTEM_TIME 0x7ffe0014
#define time_lo 0
#define time_hi1 4

var i3 I1 = t0(0) // ERROR "does not implement|incompatible"

var p0i p0.I = t0(0) // ok
var p1i p1.I = t1(0) // ok

var p0i1 p0.I = t1(0) // ERROR "does not implement|incompatible"
var p0i2 p1.I = t0(0) // ERROR "does not implement|incompatible"

func foobar() {
	// check that cannot assign one to the other,
	// but can convert.
	v0 = v1 // ERROR "assign|cannot use"
	v1 = v0 // ERROR "assign|cannot use"

	// between assignments (typically branch-dependent
	// conditionals) occurring "before" the block (e.g., as inputs
	// to the block and its phi functions), "within" the block,
	// and "after" the block.
	AdjustBefore = -1 // defined before phi
	AdjustWithin = 0  // defined by phi
	AdjustAfter  = 1  // defined within block
)

// A SparseTree is a tree of Blocks.
// It allows rapid ancestor queries,

			Valu("addr", OpAddr, ptrType, 0, nil, "sb"),
			Goto("loop")),
		Bloc("loop",
			Valu("phi", OpPhi, types.TypeMem, 0, nil, "start", "store"),
			Valu("store", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr", "v", "phi"),
			If("v", "loop", "exit")),
		Bloc("exit",
			Exit("store")))

	CheckFunc(fun.f)
	dse(fun.f)
	CheckFunc(fun.f)
}

func TestDeadStoreTypes(t *testing.T) {

		am4 = []map[float64]map[G2]*func(*byte, map[uint]int64, G3, struct {
		}) G2{am4[i2%*pi3]}
		pi2 = &i2
		pi64_0 = pi64_1
		ai8_8[*pi3] = *pi8_5&ai8_9[(*pi4+*pi3)%*pi3] ^ ai8_8[90+i2|*pi4]
		ai64_2 = []int64{}
		m4 = m4
		pi2 = &i1
		pi3 = &i2
		_, _, _, _, _, _, _, _, _ = ai8_8, ai8_9, pi2, pi3, pi4, pi8_5, pi8_6, i64_0, i64_1
	}