j := 0
	myprint1(nil, &j) // ERROR "... argument does not escape$"
}

func foo78(z int) *int { // ERROR "moved to heap: z$"
	return &z
}

func foo78a(z int) *int { // ERROR "moved to heap: z$"
	y := &z
	x := &y
	return *x // really return y
}

func foo79() *int {
	return new(int) // ERROR "new\(int\) escapes to heap$"
}

func foo80() *int {
	var z *int

	foo061()
	foo062()
	foo063()
	foo064()
	foo065()
	foo066()
	foo067()
	foo068()
	foo069()
	foo070()
	foo071()
	foo072()
	foo073()
	foo074()
	foo075()
	foo076()
	foo077()
	foo078()
	foo079()
	foo080()
	foo081()
	foo082()
	foo083()
	foo084()
	foo085()
	foo086()
	foo087()
	foo088()
	foo089()
	foo090()
	foo091()
	foo092()
	foo093()
	foo094()
	foo095()

	j := 0
	myprint1(nil, &j) // ERROR "... argument does not escape$"
}

func foo78(z int) *int { // ERROR "moved to heap: z$"
	return &z
}

func foo78a(z int) *int { // ERROR "moved to heap: z$"
	y := &z
	x := &y
	return *x // really return y
}

func foo79() *int {
	return new(int) // ERROR "new\(int\) escapes to heap$"
}

func foo80() *int {
	var z *int

  function {
    signature {
      name: "foo5"
    }
  }
  function {
    signature {
      name: "foo6"
    }
  }
  function {
    signature {
      name: "foo7"
    }
  }
  function {
    signature {
      name: "foo8"
    }
  }
  function {
    signature {
      name: "foo9"
    }
  }
  function {
    signature {
      name: "foo10"
    }
  }
  function {

func t4[T Numeric4](s[]T){if( /* ERROR "non-boolean" */ 0){*s /* ERROR "cannot indirect" */ [0]}}

// crash 7
type foo7 interface { bar() }
type x7[A any] struct{ foo7 }
func main7() { var _ foo7 = x7[int]{} }

// crash 8
type foo8[A any] interface { ~A /* ERROR "cannot be a type parameter" */ }
func bar8[A foo8[A]](a A) {}

// crash 9
type foo9[A any] interface { foo9 /* ERROR "invalid recursive type" */ [A] }

	c.Set("foo6", "bar")
	c.Set("foo7", "bar")

	wg := new(sync.WaitGroup)
	workers := runtime.NumCPU()
	each := b.N / workers
	wg.Add(workers)

	b.ResetTimer()
	for i := 0; i < workers; i++ {
		go func() {
			for j := 0; j < each; j++ {
				c.Get("foo1")
				c.Get("foo2")
				c.Get("foo3")
				c.Get("foo5")
				c.Get("foo6")
				c.Get("foo7")
				c.Get("foo8") // doesn't exist
			}

		// Driver name length > 63
		ObjectMeta: metav1.ObjectMeta{Name: "foo7"},
		Spec: storage.CSINodeSpec{
			Drivers: []storage.CSINodeDriver{{
				Name:         longName,
				NodeID:       nodeID,
				TopologyKeys: []string{"company.com/zone1", "company.com/zone2"},
			}},
		},
	}, {
		// No driver name
		ObjectMeta: metav1.ObjectMeta{Name: "foo8"},
		Spec: storage.CSINodeSpec{

				makeGCContainer("foo5", "bar5", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo6", "bar6", 2, 2, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo7", "bar7", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
			},
			remain:               []int{0, 2, 4, 6, 8, 9},
			evictTerminatingPods: false,
			allSourcesReady:      true,
		},
		{

			node: api.Node{
				ObjectMeta: metav1.ObjectMeta{Name: "foo7"},
				Status:     api.NodeStatus{Conditions: []api.NodeCondition{{}}},
			},
			// Columns: Name, Status, Roles, Age, KubeletVersion
			expected: []metav1.TableRow{{Cells: []interface{}{"foo7", "Unknown", "<none>", "<unknown>", ""}}},
		},
		{
			node: api.Node{
				ObjectMeta: metav1.ObjectMeta{Name: "foo8"},
				Spec:       api.NodeSpec{Unschedulable: true},