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:
      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";
}