foo033()
	foo034()
	foo035()
	foo036()
	foo037()
	foo038()
	foo039()
	foo040()
	foo041()
	foo042()
	foo043()
	foo044()
	foo045()
	foo046()
	foo047()
	foo048()
	foo049()
	foo050()
	foo051()
	foo052()
	foo053()
	foo054()
	foo055()
	foo056()
	foo057()
	foo058()
	foo059()
	foo060()
	foo061()
	foo062()
	foo063()
	foo064()
	foo065()
	foo066()
	foo067()

    signature {
      name: "foo15"
    }
  }
  function {
    signature {
      name: "foo16"
    }
  }
  function {
    signature {
      name: "foo17"
    }
  }
  function {
    signature {
      name: "foo18"
    }
  }
  function {
    signature {
      name: "foo19"
    }
  }
  function {
    signature {
      name: "foo20"
    }
  }
}

}

type MV int

func (MV) M() {}

func foo65() {
	var mv MV
	foo63(&mv)
}

func foo66() {
	var mv MV // ERROR "moved to heap: mv$"
	foo64(&mv)
}

func foo67() {
	var mv MV
	foo63(mv) // ERROR "mv does not escape$"
}

func foo68() {
	var mv MV
	// escapes but it's an int so irrelevant
	foo64(mv) // ERROR "mv escapes to heap$"
}

type G15[X any] s /* ERROR "undefined" */
func (G15 /* ERRORx `generic type .* without instantiation` */ ) p()

// crash 16
type Foo16[T any] r16 /* ERROR "not a type" */
func r16[T any]() Foo16[Foo16[T]] { panic(0) }

// crash 17
type Y17 interface{ c() }
type Z17 interface {
	c() Y17
	Y17 /* ERROR "duplicate method" */
}
func F17[T Z17](T) {}

// crash 18

    }

    def "old build script classloaders are collected"() {
        given:
        buildFile << """
            class Foo0 {
                static final byte[] MEMORY_HOG = new byte[10 * 1024 * 1024]
            }
            task myTask() {
                doLast {
                    println new Foo0()
                }
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {

# CHECK-LABEL:  func @main() {
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = true, f = @foo0}> {device = ""}
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# CHECK-LABEL:  func private @foo0()
# CHECK: "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# the names are matching between the function definition and the uses / call
# site (a numerical suffix may be appended).

# CHECK: "tf.LegacyCall"(%outputs) <{_disable_call_shape_inference = false, f = @foo0}> {device = ""}

	c.Set("foo5", "bar")
	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")

	}
	return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many return values\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)|too many arguments to return"
}

func foo6() (T, string) {
	return "T", true, true // ERROR "too many return values\n\thave \(string, bool, bool\)\n\twant \(T, string\)|too many arguments to return"

    )

    static final UBER_MOBILE_APP = new IncrementalAndroidTestProject(
        templateName: 'uberMobileApp',
        pathToChange: 'leafModuleAvg/src/main/java/leafModuleAvgpackageJava0/Foo0.java',
        taskToRunForChange: ':rootModule:assembleDebug'
    )

    String pathToChange
    String taskToRunForChange

    @Override
    void configure(CrossVersionPerformanceTestRunner runner) {