package x

import "internal/abi"

func Fn0() // defined in assembly

func Fn1() {}

var FnExpr func()

func test() {
	_ = abi.FuncPCABI0(Fn0)           // line 16, no error
	_ = abi.FuncPCABIInternal(Fn0)    // line 17, error
	_ = abi.FuncPCABI0(Fn1)           // line 18, error
	_ = abi.FuncPCABIInternal(Fn1)    // line 19, no error
	_ = abi.FuncPCABI0(FnExpr)        // line 20, error

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"strconv"
)

func test1[T any](fn func(T) int, v T) int {
	fn1 := func() int {
		var i interface{} = v
		val := fn(i.(T))
		return val
	}
	return fn1()
}

func main() {
	want := 123
	got := test1(func(s string) int {
		r, err := strconv.Atoi(s)
		if err != nil {
			return 0
		}
		return r

	return int(*c)
}

func (c *count) IsBoolFlag() bool {
	return true
}

func (c *count) IsCountFlag() bool {
	return true
}

type fn1 func(string)

func (f fn1) Set(s string) error {
	f(s)
	return nil
}

func (f fn1) String() string { return "" }

// DecodeArg decodes an argument.
//
// This function is public for testing with the parallel encoder.

		t.Fatalf("Child returned %q, want an absolute path", out)
	}
	if !sameFile(outs, ep) {
		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
	}
}

func sameFile(fn1, fn2 string) bool {
	fi1, err := os.Stat(fn1)
	if err != nil {
		return false
	}
	fi2, err := os.Stat(fn2)
	if err != nil {
		return false
	}
	return os.SameFile(fi1, fi2)
}

func init() {

    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      %out_ch = tfrt_fallback_async.createop(%in_ch) key(0) device("/CPU:0")
        "some.op"() {attr1 = value, attr2 = value2} {f_attr1 = "fn1", f_attr2 = "fn2"} num_args(1)
  }];

  let arguments = (ins
    TFRT_ChainType:$in_ch,
    I64Attr:$num_args,
    StrAttr:$device,
    ArrayAttr:$op_attrs,

	y float32
}

type NotBasic Basic

type DeepEqualTest struct {
	a, b any
	eq   bool
}

// Simple functions for DeepEqual tests.
var (
	fn1 func()             // nil.
	fn2 func()             // nil.
	fn3 = func() { fn1() } // Not nil.
)

type self struct{}

type Loop *Loop
type Loopy any

var loop1, loop2 Loop
var loopy1, loopy2 Loopy

func init() {

    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      tfrt_fallback_sync.createop() key(0) device("/CPU:0")
        "some.op"() {attr1 = value, attr2 = value2} {f_attr1 = "fn1", f_attr2 = "fn2"} num_args(1)
  }];

  let arguments = (ins
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let results = (outs);

  let assemblyFormat = "attr-dict";
}

  TFE_ContextAddFunctionDef(ctx, fdef1.data(), fdef1.size(), status);
  TFE_Op* fn1 = TFE_NewOp(ctx, "FunctionWithTestNonCommUnavailable", status);
  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_Execute(fn1, retval, &num_retvals, status);
  EXPECT_EQ(TF_INTERNAL, TF_GetCode(status)) << TF_Message(status);
  TFE_DeleteOp(fn1);

  const string& fdef2 = FunctionWithErrorOp("TestCommUnavailable");

}

type NotBasic Basic

type DeepEqualTest struct {
	a, b any
	eq   bool
}

// Simple functions for DeepEqual tests.
var (
	fn1 func()             // nil.
	fn2 func()             // nil.
	fn3 = func() { fn1() } // Not nil.
)

type self struct{}

type Loop *Loop
type Loopy any

var loop1, loop2 Loop
var loopy1, loopy2 Loopy

	}
}

func TestMarshalMismatch(t *testing.T) {
	h := []func() hash.Hash{
		New,
		New384,
		New512_224,
		New512_256,
	}

	for i, fn1 := range h {
		for j, fn2 := range h {
			if i == j {
				continue
			}

			h1 := fn1()
			h2 := fn2()

			state, err := h1.(encoding.BinaryMarshaler).MarshalBinary()
			if err != nil {
				t.Errorf("i=%d: could not marshal: %v", i, err)