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
    }

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")
		}

// Verify that illegal function signatures are detected.
// Does not compile.

package main

type t1 int
type t2 int
type t3 int

func f1(*t2, x t3)	// ERROR "named"
func f2(t1, *t2, x t3)	// ERROR "named"
func f3() (x int, *string)	// ERROR "named"

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

// Verify that it is illegal to take the address of a function.
// Does not compile.

package main

var notmain func()

func main() {
	var x = &main		// ERROR "address of|invalid"
	main = notmain	// ERROR "assign to|invalid"
	_ = x

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

// Test evaluation order in if condition.

package main

var calledf = false

func f() int {
	calledf = true
	return 1
}

func g() int {
	if !calledf {
		panic("BUG: func7 - called g before f")
	}
	return 0
}

func main() {
	// gc used to evaluate g() before f().
	if f() < g() {
		panic("wrong answer")
	}

        file("src/main/headers/funcs.h") << """
            int func1();
            int func2();
"""
        file("src/main/cpp/main.cpp") << """
            #include <iostream>
            #include "funcs.h"
            int main () {
                std::cout << func1() << func2() << std::endl;
                return 0;
            }
"""
        file("src/main/cpp1/func1.cpp") << """
            int getOne();

	f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"
		p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x"
	}
	f()
}

func f2() {} // ERROR "can inline f2"

// No inline for recover; panic now allowed to inline.
func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
func f4() { recover() }

func f5() *byte { // ERROR "can inline f5"

# assembly 2^26 or so times.
#
# We build something which should be laid out as such:
#
# bar.Bar
# main.Func1
# bar.Bar+400-tramp0
# main.BigAsm
# main.Func2
# bar.Bar+400-tramp1
#
# bar.Bar needs to be placed far enough away to generate relocations
# from main package calls. and main.Func1 and main.Func2 are placed
# a bit more than the direct call limit apart, but not more than 0x400