// 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.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

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

func SHA224([]byte) [28]byte { panic("boringcrypto: not available") }
func SHA256([]byte) [32]byte { panic("boringcrypto: not available") }
func SHA384([]byte) [48]byte { panic("boringcrypto: not available") }
func SHA512([]byte) [64]byte { panic("boringcrypto: not available") }

func NewHMAC(h func() hash.Hash, key []byte) hash.Hash { panic("boringcrypto: not available") }

func Or8(ptr *uint8, val uint8)

//go:noescape
func And(ptr *uint32, val uint32)

//go:noescape
func Or(ptr *uint32, val uint32)

//go:noescape
func And32(ptr *uint32, val uint32) uint32

//go:noescape
func Or32(ptr *uint32, val uint32) uint32

//go:noescape
func Anduintptr(ptr *uintptr, val uintptr) uintptr

//go:noescape
func Oruintptr(ptr *uintptr, val uintptr) uintptr

//go:noescape

  func.return %0 : tensor<2xf32>
}

// -----

// If with no outputs, some inputs
// CHECK: func private @testIf1Then{{.+}}
// CHECK: func private @testIf1Else{{.+}}
func.func private @testIf1Then(tensor<*xf32>) -> ()
func.func private @testIf1Else(tensor<*xf32>) -> ()

// CHECK-LABEL: func @testIfNoResult(%arg0: tensor<i1>, %arg1: tensor<2xf32>)
func.func @testIfNoResult(%arg0: tensor<i1>, %arg1: tensor<2xf32>) -> () {

func (c *sigctxt) r6() uint64  { return c.regs().gpr[6] }
func (c *sigctxt) r7() uint64  { return c.regs().gpr[7] }
func (c *sigctxt) r8() uint64  { return c.regs().gpr[8] }
func (c *sigctxt) r9() uint64  { return c.regs().gpr[9] }
func (c *sigctxt) r10() uint64 { return c.regs().gpr[10] }
func (c *sigctxt) r11() uint64 { return c.regs().gpr[11] }
func (c *sigctxt) r12() uint64 { return c.regs().gpr[12] }

		return fmt.Sprint
	}()

	RedBoldf = func() func(format string, a ...interface{}) string {
		if IsTerminal() {
			return color.New(color.FgRed, color.Bold).SprintfFunc()
		}
		return fmt.Sprintf
	}()

	Red = func() func(format string, a ...interface{}) string {
		if IsTerminal() {
			return color.New(color.FgRed).SprintfFunc()
		}
		return fmt.Sprintf
	}()

	Blue = func() func(format string, a ...interface{}) string {