_ = f
}

func issue11387(x int) func() int {
	f := func() int { return x }    // ERROR "func literal escapes to heap"
	slice1 := []func() int{f}       // ERROR "\[\].* does not escape"
	slice2 := make([]func() int, 1) // ERROR "make\(.*\) does not escape"
	copy(slice2, slice1)
	return slice2[0]
}

func issue12397(x, y int) { // ERROR "moved to heap: y$"
	// x does not escape below, because all relevant code is dead.

				}
				return cmp.Compare(a.n, b.n)
			}
			// Presort the slice so all benchmark iterations are identical.
			slices.SortFunc(structs, cmpFunc)
			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				// Sort the slice twice because slices.SortFunc modifies the slice in place.
				slices.SortFunc(structs, func(a, b *myStruct) int { return cmpFunc(b, a) })
				slices.SortFunc(structs, cmpFunc)
			}
		})
	}

          - pkg: maps
            desc: "do not use maps; use istio.io/istio/pkg/maps instead"
          - pkg: golang.org/x/exp/slices
            desc: "do not use golang.org/x/exp/slices; use istio.io/istio/pkg/slices instead"
          - pkg: slices
            desc: "do not use slices; use istio.io/istio/pkg/slices instead"
      DenyOperatorAndIstioctl:
        files:
          # Tests can do anything
          - "!$test"

		"fmt.Errorf":           true,
		"fmt.Sprint":           true,
		"fmt.Sprintf":          true,
		"slices.Clip":          true,
		"slices.Compact":       true,
		"slices.CompactFunc":   true,
		"slices.Delete":        true,
		"slices.DeleteFunc":    true,
		"slices.Grow":          true,
		"slices.Insert":        true,
		"slices.Replace":       true,
		"sort.Reverse":         true,
	}
	Analyzer.Flags.Var(&funcs, "funcs",

		{"(*Signature).String", Method, 5},
		{"(*Signature).TypeParams", Method, 18},
		{"(*Signature).Underlying", Method, 5},
		{"(*Signature).Variadic", Method, 5},
		{"(*Slice).Elem", Method, 5},
		{"(*Slice).String", Method, 5},
		{"(*Slice).Underlying", Method, 5},
		{"(*StdSizes).Alignof", Method, 5},
		{"(*StdSizes).Offsetsof", Method, 5},
		{"(*StdSizes).Sizeof", Method, 5},
		{"(*Struct).Field", Method, 5},

FILENAMES
	testdata/issue22856.go

FUNCTIONS
	// NewPointerSliceOfSlice is not a factory function because slices ...
	func NewPointerSliceOfSlice() [][]*T

	// NewSlice3 is not a factory function because 3 nested slices of ...
	func NewSlice3() [][][]T

	// NewSliceOfSlice is not a factory function because slices of a ...
	func NewSliceOfSlice() [][]T


TYPES
	// 
	type T struct{}

	// 
	func New() T

func (c *ConfigWriter) PrintPolicySummary(filter PolicyFilter) error {
	w := c.tabwriter()
	zDump := c.ztunnelDump

	pols := slices.Filter(zDump.Policies, filter.Verify)
	slices.SortFunc(pols, func(a, b *ZtunnelPolicy) int {
		if r := cmp.Compare(a.Namespace, b.Namespace); r != 0 {
			return r
		}
		return cmp.Compare(a.Name, b.Name)
	})

	c.RunAndWait(stop)
	cmt := clienttest.NewWriter[*corev1.ConfigMap](t, c)
	ConfigMapNames := krt.NewSingleton[string](
		func(ctx krt.HandlerContext) *string {
			cms := krt.Fetch(ctx, ConfigMaps)
			return ptr.Of(slices.Join(",", slices.Map(cms, func(c *corev1.ConfigMap) string {
				return config.NamespacedName(c).String()
			})...))
		},
	)
	ConfigMapNames.AsCollection().Synced().WaitUntilSynced(stop)
	tt := assert.NewTracker[string](t)

	spCacheEfficient.Set(pmKey80, EfficiencyInfo{Endpoints: 45, Slices: 1})
	spCacheEfficient.Set(pmKey80443, EfficiencyInfo{Endpoints: 35, Slices: 1})

	spCacheInefficient := NewEndpointPortCache()
	spCacheInefficient.Set(pmKey80, EfficiencyInfo{Endpoints: 12, Slices: 5})
	spCacheInefficient.Set(pmKey80443, EfficiencyInfo{Endpoints: 18, Slices: 8})

    // Attach controls for column groups in tables
    var controls = $("div#controls");
    var groups = [];
    var slices = [];
    $("tr.control-groups").closest("table").find("tr").each(function() {
        var row = $(this);
        if (row.hasClass('control-groups')) {
            var currentCol = 0;
            slices = [];
            row.find("th").each(function(){
                var e = $(this);