{29, "SIGPROF", "profiling Timer Expired"},
	{30, "SIGXCPU", "cpu Limit Exceeded"},
	{31, "SIGXFSZ", "file Size Limit Exceeded"},
	{32, "SIGWAITING", "no runnable lwp"},
	{33, "SIGLWP", "inter-lwp signal"},
	{34, "SIGFREEZE", "checkpoint Freeze"},
	{35, "SIGTHAW", "checkpoint Thaw"},
	{36, "SIGCANCEL", "thread Cancellation"},
	{37, "SIGLOST", "resource Lost"},
	{38, "SIGXRES", "resource Control Exceeded"},

		Gated:                   pqi.Gated,
	}
}

// PodInfo is a wrapper to a Pod with additional pre-computed information to
// accelerate processing. This information is typically immutable (e.g., pre-processed
// inter-pod affinity selectors).
type PodInfo struct {
	Pod                        *v1.Pod
	RequiredAffinityTerms      []AffinityTerm
	RequiredAntiAffinityTerms  []AffinityTerm
	PreferredAffinityTerms     []WeightedAffinityTerm

		},
		// Test the symmetry cases for affinity, the difference between affinity and symmetry is not the pod wants to run together with some existing pods,
		// but the existing pods have the inter pod affinity preference while the pod to schedule satisfy the preference.
		{
			name: "Affinity symmetry: considered only the preferredDuringSchedulingIgnoredDuringExecution in pod affinity symmetry",

	typeAssertGen++
	c := rttype.NewCursor(lsym, 0, rttype.TypeAssert)
	c.Field("Cache").WritePtr(typecheck.LookupRuntimeVar("emptyTypeAssertCache"))
	c.Field("Inter").WritePtr(reflectdata.TypeLinksym(target))
	c.Field("CanFail").WriteBool(canFail)
	objw.Global(lsym, int32(rttype.TypeAssert.Size()), obj.LOCAL)
	lsym.Gotype = reflectdata.TypeLinksym(rttype.TypeAssert)
	return lsym
}

func TestInterfaceGet(t *testing.T) {
	var inter struct {
		E any
	}
	inter.E = 123.456
	v1 := ValueOf(&inter)
	v2 := v1.Elem().Field(0)
	assert(t, v2.Type().String(), "interface {}")
	i2 := v2.Interface()
	v3 := ValueOf(i2)
	assert(t, v3.Type().String(), "float64")
}

func TestInterfaceValue(t *testing.T) {
	var inter struct {
		E any
	}
	inter.E = 123.456
	v1 := ValueOf(&inter)

how many dependencies you have between subprojects.
A build whose execution time is dominated by a single subproject won't benefit much at all.
Neither will a project with lots of inter-subproject dependencies.
But most multi-subproject builds see a reduction in build times.

=== Visualize parallelism with build scans

Build scans give you a visual timeline of task execution. In the following

// partially instantiated generic functions may be assigned
// (incl. returned) to variables of function type and type
// inference will attempt to infer the missing type arguments.
// Available with go1.21.
const enableReverseTypeInference = true // disable for debugging

// infer attempts to infer the complete set of type arguments for generic function instantiation/call

    This pass converts the control outputs of a while loop body function to data
    outputs. Thus, inter iteration control dependencies are transformed to
    data dependencies. Since data dependencies can express which particular
    operations in the while loop body are dependent on which inputs, it captures
    inter iteration parallelism in while loop. Control dependencies on the other

			},
		}, {
			description: "valid, with signer name, with inter-block garbage",
			bundle: &capi.ClusterTrustBundle{
				ObjectMeta: metav1.ObjectMeta{
					Name: "k8s.io:foo:abc",
				},
				Spec: capi.ClusterTrustBundleSpec{
					SignerName:  "k8s.io/foo",

// partially instantiated generic functions may be assigned
// (incl. returned) to variables of function type and type
// inference will attempt to infer the missing type arguments.
// Available with go1.21.
const enableReverseTypeInference = true // disable for debugging

// infer attempts to infer the complete set of type arguments for generic function instantiation/call