b := 3
			return func(y int) int { // ERROR "can inline main.func27.1" "can inline main.main.func27.func34"
				c := 5
				return func(z int) int { // ERROR "can inline main.func27.1.1" "can inline main.main.func27.func34.1" "can inline main.func27.main.func27.1.2" "can inline main.main.func27.main.main.func27.func34.func36"
					return a*x + b*y + c*z
				}(10) // ERROR "inlining call to main.func27.1.1"

	// the rest of the test, they will block.
	go func() { // func1
		select {}
	}()
	go func() { // func2
		var c chan int
		c <- 0
	}()
	go func() { // func3
		var c chan int
		<-c
	}()
	done1 := make(chan bool)
	go func() { // func4
		<-done1
	}()
	done2 := make(chan bool)
	go func() { // func5
		done2 <- true
	}()
	c1 := make(chan int)
	c2 := make(chan int)

			t.Fatal("did not see a goroutine in a the region 'special'")
		}
	})
}

func TestTraceGCStress(t *testing.T) {
	testTraceProg(t, "gc-stress.go", nil)
}

func TestTraceGOMAXPROCS(t *testing.T) {
	testTraceProg(t, "gomaxprocs.go", nil)
}

func TestTraceStacks(t *testing.T) {
	testTraceProg(t, "stacks.go", func(t *testing.T, tb, _ []byte, stress bool) {
		type frame struct {
			fn   string
			line int

    %2 = func.call @func_2_CPU_FLOAT(%0, %1) {tac.device = "CPU", tac.inference_type = "FLOAT", tac.interface_name = "func_2"} : (tensor<100xf32>, tensor<100xf32>) -> tensor<2x100xf32>
    func.return %2 : tensor<2x100xf32>
  }

module {
  func.func @simpleTest(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>, %arg2: tensor<1xf32>, %arg3: tensor<1xf32>) -> tensor<2x1xf32> {
    %0 = func.call @func_0_GPU_FLOAT(%arg0, %arg1, %arg2) {tac.interface_name = "func_0"} : (tensor<1xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
    %1 = func.call @func_1_GPU_FLOAT(%arg0, %arg3) {tac.interface_name = "func_1"} : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>

  func.return %0 : tensor<i32>
}
}

// CHECK:     func.func @simpleWhile(%arg0: tensor<i32>) -> tensor<i32> {
// CHECK:       %0 = call @func_0_CPU_FLOAT(%arg0) {tac.device = "CPU", tac.inference_type = "FLOAT", tac.interface_name = "func_0"} : (tensor<i32>) -> tensor<i32>
// CHECK:       return %0 : tensor<i32>
// CHECK:     }

  if (GetName(funcs[0]) == GetName(func0)) {
    AssertEqual(func0, funcs[0]);
    AssertEqual(func1, funcs[1]);
  } else {
    AssertEqual(func0, funcs[1]);
    AssertEqual(func1, funcs[0]);
  }

  TF_DeleteFunction(funcs[0]);
  TF_DeleteFunction(funcs[1]);

  TF_DeleteFunction(func0);
  TF_DeleteFunction(func1);
}

}  // namespace

#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_COMMON_FUNC_H_

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project

namespace mlir::quant {

// Returns a public `func::FuncOp` in `module_op` whose name matches either
// `main` or `serving_default`. If `func::FuncOps` with both names exist, the
// function with name "main" takes precedence. Returns null if no such a

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

            argument_index = i;
            break;
          }
        }

        // Copy the const into the consumer func and replace their usages.
        func::FuncOp func = module.lookupSymbol<func::FuncOp>(function_name);

        CopyConstantIntoFunc(argument_index, op, func);
      }
    });
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateFoldConstantsToSubgraphPass(