return x
	}
}

func foo23a(x int) func() int {
	f := func() int { // ERROR "func literal escapes to heap$"
		return x
	}
	return f
}

func foo23b(x int) *(func() int) {
	f := func() int { return x } // ERROR "func literal escapes to heap$" "moved to heap: f$"
	return &f
}

func foo23c(x int) func() int { // ERROR "moved to heap: x$"

  func.return %0 : tensor<4xi32>
}

// CHECK-LABEL: func @div_unranked
func.func @div_unranked(%arg0: tensor<*xi32>, %arg1: tensor<?x?xi32>) -> tensor<?x?xi32> {
  // CHECK-NEXT: tf.Div
  %0 = "tf.Div"(%arg0, %arg1) : (tensor<*xi32>, tensor<?x?xi32>) -> tensor<?x?xi32>
  func.return %0: tensor<?x?xi32>
}

// CHECK-LABEL: func @maximum

func (c *sigctxt) t1() uint64  { return c.regs().mc_gpregs.gp_t[1] }
func (c *sigctxt) t2() uint64  { return c.regs().mc_gpregs.gp_t[2] }
func (c *sigctxt) s0() uint64  { return c.regs().mc_gpregs.gp_s[0] }
func (c *sigctxt) s1() uint64  { return c.regs().mc_gpregs.gp_s[1] }
func (c *sigctxt) a0() uint64  { return c.regs().mc_gpregs.gp_a[0] }
func (c *sigctxt) a1() uint64  { return c.regs().mc_gpregs.gp_a[1] }

  // CHECK-LABEL: func.func @convert_cluster_func
  func.func @convert_cluster_func(%arg0: tensor<i32>) -> tensor<i32> {
    // CHECK: "tf.XlaLaunch"(%arg0) <{function = @func, operandSegmentSizes = array<i32: 0, 1, 0>}> : (tensor<i32>) -> tensor<i32>
    %0 = "tf_device.cluster_func"(%arg0) {func = @func} : (tensor<i32>) -> tensor<i32>
    func.return %0 : tensor<i32>
  }

  func.func @func(%arg0: tensor<i32>) -> tensor<i32> {

func one() {
	two()
}

//go:noinline
func two() {
	defer func() {
	}()

	three()
}

//go:noinline
func three() {
	defer func() {
	}()

	defer func() {
		fmt.Println(recover())
	}()

	defer func() {
		fmt.Println(recover())
		panic("second panic")
	}()

	panic("first panic")
}

func GoexitExit() {
	println("t1")
	go func() {

	shouldPanic("len out of range", func() { _ = make(T, int64(n)) })
	shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) })
	shouldPanic("len out of range", func() { _ = make(T, uint64(n)) })
	shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) })
}

func testMakeBytes(n uint64) {
	type T []byte
	shouldPanic("len out of range", func() { _ = make(T, int(n)) })
	shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) })

		}
	}()
	f()
}

func onceFuncPanic() {
	panic("x")
}

func TestOnceXGC(t *testing.T) {
	fns := map[string]func([]byte) func(){
		"OnceFunc": func(buf []byte) func() {
			return sync.OnceFunc(func() { buf[0] = 1 })
		},
		"OnceValue": func(buf []byte) func() {
			f := sync.OnceValue(func() any { buf[0] = 1; return nil })
			return func() { f() }
		},

  func.return
}

// -----

// CHECK-LABEL: func @empty_replicate
func.func @empty_replicate() {
  tf_device.replicate {n = 2 : i32} {
  }
  func.return

// CHECK:      tf_device.replicate
// CHECK-SAME: n = 2
// CHECK-NEXT:   tf_device.return
}

// -----

// CHECK-LABEL: func @no_operand_replicate
func.func @no_operand_replicate() {

package main

var ok = false

func f() func(int, int) int {
	ok = true
	return func(int, int) int { return 0 }
}

func g() (int, int) {
	if !ok {
		panic("FAIL")
	}
	return 0, 0
}

var _ = f()(g())

func main() {
	f1()
	f2()
	f3()
	f4()
}

func f1() {
	ok := false

	f := func() func(int, int) {
		ok = true
		return func(int, int) {}
	}
	g := func() (int, int) {

package p

func f1(func(int))
func f2(func(int), func(string))
func f3(func(int), func(string), func(float32))

func g1[P any](P) {}

func _() {
	f1(g1)
	f2(g1, g1)
	f3(g1, g1, g1)
}

// More complex examples

func g2[P any](P, P)                                         {}
func h3[P any](func(P), func(P), func() P)                   {}