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()

# This test is tailored to reproduce b/141617294. In particular, the function
# library contains "foo1", "foo2", ..., "foo20", from which "foo1" and "foo11"
# were mapped to the same name "foo110" in the bug.
node {
  name: "unnamed"
  op: "foo1"
}
node {
  name: "unnamed1"
  op: "foo11"
}
library {
  function {
    signature {
      name: "foo1"
    }
  }
  function {
    signature {
      name: "foo2"
    }
  }

}

// Test case 1 from issue

type Fooer1[t any] interface {
	Foo(Barer[t])
}
type Barer[t any] interface {
	Bar(t)
}

// For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
// type Foo1[t any] t
// type Bar[t any] t
// 
// func (l Foo1[t]) Foo(v Barer[t]) { v.Bar(t(l)) }
// func (b *Bar[t]) Bar(l t)        { *b = Bar[t](l) }
// 

		go func() {
			for j := 0; j < each; j++ {
				c.Set("foo1", "bar")
				c.Set("foo2", "bar")
				c.Set("foo3", "bar")
				c.Set("foo4", "bar")
				c.Set("foo5", "bar")
				c.Set("foo6", "bar")
				c.Set("foo7", "bar")
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

func benchmarkCacheGetSetConcurrent(c Cache, b *testing.B) {
	c.Set("foo1", "bar")
	c.Set("foo2", "bar")
	c.Set("foo3", "bar")

# In GraphDef custom gradient functions are modeled using GradientDef which
# links the function and its gradient. In MLIR a TF ops gradient function is
# added to its list of function attributes.

# CHECK: func private @foo0(
# CHECK:   tf.gradient = @foo_grad

node {
  name: "Const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {

package main

func main() {
	Gooer2[byte]()
}

type Fooer[T any] interface {
	Foo(p T)
}

type fooer1[T any] struct{}

func (fooer1[T]) Foo(T) {}

type fooer2[T any] struct {
	r []Fooer[T]
}

//go:noinline
func (mr fooer2[T]) Foo(p T) {
	mr.r[0] = fooer1[T]{}
	return
}

func Gooer2[T any]() Fooer[T] {
	return fooer2[T]{}

	server8001.HandleFunc("/foo", foo8001)
	server8001.HandleFunc("/bar", bar8001)

	server8002 := http.NewServeMux()
	server8002.HandleFunc("/foo", foo8002)
	server8002.HandleFunc("/bar", bar8002)

	go func() {
		http.ListenAndServe(":8001", server8001)
	}()

	go func() {
		http.ListenAndServe(":8002", server8002)
	}()

	<-finish
}

func foo8001(w http.ResponseWriter, _ *http.Request) {

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

	_ = x.foo1 // ERROR "x.foo1 undefined (type S has no field or method foo1, but does have field Foo1)"
	_ = x.foo2 // ERROR "x.foo2 undefined (type S has no field or method foo2, but does have field FoO2)"
	_ = x.foo3 // OK
	_ = x.foo4 // ERROR "x.foo4 undefined (type S has no field or method foo4, but does have field foO4)"
}

func _() {
	_ = S{Foo1: 0} // OK

            #include "foo.h"
            int main () {
               foo1();
               foo2();
               return 0;
            }
        """),

        sourceFile("c/foo1", "foo.c", """
            #include <stdio.h>
            #include "foo.h"

            void foo1() {
                printf("foo1");
            }
        """),

        sourceFile("c/foo2", "foo.c", """