input: "input"
  input: "input"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "func0"
  op: "func_name"
  input: "Switch0:1"
}
node {
  name: "Merge"
  op: "Merge"
  input: "Switch0:1"
  input: "Switch0"
  input: "^func0"
  attr {
    key: "N"
    value {
      i: 2
    }
  }
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }

        %1 = "tf.opB"() : () -> tensor<f32>
        tf_executor.yield %1 : tensor<f32>
      }
      tf_executor.fetch %outputs_0 : tensor<f32>
    }
    func.return %0 : tensor<f32>
  }
// CHECK-LABEL: func @func2
  func.func @func2(%arg0: tensor<i1>) -> tensor<i1> {
    %0 = tf_executor.graph {
      %outputs, %control = tf_executor.island {
        %1 = "tf.opB"() : () -> tensor<f32>

#include "tensorflow/core/protobuf/struct.pb.h"

namespace tensorflow {

TFConcreteFunction::TFConcreteFunction(std::unique_ptr<FlatTensorFunction> func,
                                       FunctionMetadata metadata)
    : func_(std::move(func)), metadata_(std::move(metadata)) {}

Status TFConcreteFunction::Create(
    const FunctionDef* function_def,
    std::vector<ImmediateExecutionTensorHandle*> captures,

#include "tensorflow/core/protobuf/struct.pb.h"

namespace tensorflow {

TFSignatureDefFunction::TFSignatureDefFunction(
    std::unique_ptr<FlatTensorFunction> func,
    SignatureDefFunctionMetadata metadata)
    : func_(std::move(func)), metadata_(std::move(metadata)) {}

Status TFSignatureDefFunction::Create(
    const FunctionDef* function_def,
    std::vector<ImmediateExecutionTensorHandle*> captures,

// Take the following example:
//
// call @func_1_CPU {tac.interface_name = "func_1"}
//
// "func_1" is the interface name where "func_1_cpu" is the real implementation
// we can have multiple FuncOps like "func_1_cpu" and "func_1_gpu" and they
// both implement "func_1".
//
// The attribute on the FuncOp means what it actually implements while the
// attribute on the CallOp means what it actually looks for.

func funcpctab(ctxt *Link, func_ *LSym, desc string, valfunc func(*Link, *LSym, int32, *Prog, int32, interface{}) int32, arg interface{}) *LSym {
	dbg := desc == ctxt.Debugpcln
	dst := []byte{}
	sym := &LSym{
		Type:      objabi.SRODATA,
		Attribute: AttrContentAddressable | AttrPcdata,
	}

	if dbg {
		ctxt.Logf("funcpctab %s [valfunc=%s]\n", func_.Name, desc)
	}

	val := int32(-1)
	oldval := val

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

// Test that result parameters are in the same scope as regular parameters.
// Does not compile.

package main

func f1(a int) (int, float32) {
	return 7, 7.0
}


func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition|redeclared"
	return 8, 8.0

func add(x, y int) int {
	return x + y
}

func fn() func(int, int) int {
	return f
}

var fc func(int, int, chan int)

func addc(x, y int, c chan int) {
	c <- x+y
}

func fnc() func(int, int, chan int) {
	return fc
}

func three(x int) {
	if x != 3 {
		println("wrong val", x)
		panic("fail")
	}
}

var notmain func()

func emptyresults() {}
func noresults()    {}

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

// Test closures in if conditions.

package main

func main() {
	if func() bool { return true }() {}  // gc used to say this was a syntax error
	if (func() bool { return true })() {}
	if (func() bool { return true }()) {}

	return m
}

// addValueFuncs adds to values the functions in funcs, converting them to reflect.Values.
func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
	for name, fn := range in {
		if !goodName(name) {
			panic(fmt.Errorf("function name %q is not a valid identifier", name))
		}
		v := reflect.ValueOf(fn)
		if v.Kind() != reflect.Func {
			panic("value for " + name + " not a function")
		}