NodeName: ptr.To("node-4"),
					},
				},
			},
			expectedEPS: &discovery.EndpointSlice{
				Endpoints: []discovery.Endpoint{
					{
						Hostname: ptr.To("hostname-1"),
						NodeName: ptr.To("valid-node-1"),
					},
					{
						Hostname: ptr.To("hostname-2"),
					},
					{
						Hostname: ptr.To("hostname-3"),
						NodeName: ptr.To("node-3"),
					},
					{

(Load <t> ptr mem) && (is32BitInt(t) && !t.IsSigned()) => (MOVWUload ptr mem)
(Load <t> ptr mem) && (is64BitInt(t) || isPtr(t))      => (MOVDload  ptr mem)
(Load <t> ptr mem) &&  is32BitFloat(t)                 => (FMOVWload ptr mem)
(Load <t> ptr mem) &&  is64BitFloat(t)                 => (FMOVDload ptr mem)

// Stores
(Store {t} ptr val mem) && t.Size() == 1 => (MOVBstore ptr val mem)

					SucceededIndexes: ptr.To("3-6"),
					SucceededCount:   ptr.To[int32](2),
				}},
			},
		},
		"rules.succeededIndexes is specified; succeededIndexes are nothing": {
			completions:      10,
			succeededIndexes: orderedIntervals{},
			successPolicy: &batch.SuccessPolicy{
				Rules: []batch.SuccessPolicyRule{{
					SucceededCount: ptr.To[int32](4),
				}},
			},
		},

	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	//	ptr ptr INT ptr ptr
	// aka
	//
	//	ptr ptr INT ptr ptr ptr ptr INT
	//	ptr ptr ptr ptr INT ptr ptr ptr
	//	ptr INT ptr ptr ptr ptr INT ptr
	//	ptr ptr ptr INT ptr ptr ptr ptr
	//	INT ptr ptr ptr ptr INT ptr ptr
	//

					CertificateRenewal: ptr.To(true),
					EtcdUpgrade:        ptr.To(true),
					ImagePullPolicy:    v1.PullIfNotPresent,
					ImagePullSerial:    ptr.To(true),
				},
				Node: kubeadmapi.UpgradeNodeConfiguration{
					CertificateRenewal: ptr.To(true),
					EtcdUpgrade:        ptr.To(true),
					ImagePullPolicy:    v1.PullIfNotPresent,
					ImagePullSerial:    ptr.To(true),
				},
			},
		},
		{

(Load <t> ptr mem) && is32BitFloat(t) => (MOVFload ptr mem)
(Load <t> ptr mem) && is64BitFloat(t) => (MOVDload ptr mem)

// stores
(Store {t} ptr val mem) && t.Size() == 1 => (MOVBstore ptr val mem)
(Store {t} ptr val mem) && t.Size() == 2 => (MOVHstore ptr val mem)
(Store {t} ptr val mem) && t.Size() == 4 && !t.IsFloat() => (MOVWstore ptr val mem)

		x.AuxInt = int32ToAuxInt(vo.Off())
		x.Aux = symToAux(sym)
		x.AddArg2(ptr, mem)
		v.AddArg2(x, x)
		return true
	}
	// match: (CMPBconstload {sym} [vo] ptr mem)
	// cond: vo.Val() != 0
	// result: (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
	for {
		vo := auxIntToValAndOff(v.AuxInt)
		sym := auxToSym(v.Aux)
		ptr := v_0
		mem := v_1
		if !(vo.Val() != 0) {
			break
		}
		v.reset(OpAMD64CMPBconst)

				},
				PercentageOfNodesToScore: ptr.To[int32](config.DefaultPercentageOfNodesToScore),
				PodInitialBackoffSeconds: ptr.To[int64](1),
				PodMaxBackoffSeconds:     ptr.To[int64](10),
				Profiles: []configv1.KubeSchedulerProfile{
					{
						Plugins:       getDefaultPlugins(),
						PluginConfig:  pluginConfigs,
						SchedulerName: ptr.To("default-scheduler"),
					},
				},
			},
		},

(Load <t> ptr mem) && (is8BitInt(t)  && !t.IsSigned()) => (MOVBUload ptr mem)
(Load <t> ptr mem) && (is16BitInt(t) &&  t.IsSigned()) => (MOVHload ptr mem)
(Load <t> ptr mem) && (is16BitInt(t) && !t.IsSigned()) => (MOVHUload ptr mem)
(Load <t> ptr mem) && (is32BitInt(t) || isPtr(t)) => (MOVWload ptr mem)
(Load <t> ptr mem) && is32BitFloat(t) => (MOVFload ptr mem)

		v2.AuxInt = int64ToAuxInt(8)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsString()
	// result: (StringMake (Load <typ.BytePtr> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsString()) {
			break
		}
		v.reset(OpStringMake)