public class AllowedMethodTypesClass {
    public void validMethod(String arg1, String arg2) {

    }

    public File invalidReturnType(String arg1, String arg2) {
        return null;
    }

    public void invalidParameterType(String arg1, File arg2) {

    }

    public <T extends File> void invalidTypeParameterBoundType(String arg1, String arg2) {

    }

    %0 = stablehlo.constant dense<500> : tensor<100xi64>
    %1 = stablehlo.constant dense<0> : tensor<100xi64>
    %2 = stablehlo.compare  LT, %arg2, %1 : (tensor<100xi64>, tensor<100xi64>) -> tensor<100xi1>
    %3 = stablehlo.add %arg2, %0 : tensor<100xi64>

package main

import "testing"

func and_ssa(arg1, arg2 bool) bool {
	return arg1 && rightCall(arg2)
}

func or_ssa(arg1, arg2 bool) bool {
	return arg1 || rightCall(arg2)
}

var rightCalled bool

//go:noinline
func rightCall(v bool) bool {
	rightCalled = true
	return v
	panic("unreached")
}

func testAnd(t *testing.T, arg1, arg2, wantRes bool) {

    public void info(String format, Object... arguments) {}

    public void info(String msg, Throwable t) {}

    public boolean isInfoEnabled(Marker marker) {
        return false;
    }

    public void info(Marker marker, String msg) {}

    public void info(Marker marker, String format, Object arg) {}

    public void info(Marker marker, String format, Object arg1, Object arg2) {}

	f    func(uint64, uint64) uint64
	arg1 uint64
	arg2 uint64
	res  uint64
	name string
}

var extTests = [...]extTest{
	{f: func(a, b uint64) uint64 { op1 := int32(a); op2 := int32(b); return uint64(uint32(op1 / op2)) }, arg1: 0x1, arg2: 0xfffffffeffffffff, res: 0xffffffff, name: "div"},
	{f: func(a, b uint64) uint64 { op1 := int32(a); op2 := int32(b); return uint64(uint32(op1 * op2)) }, arg1: 0x1, arg2: 0x100000001, res: 0x1, name: "mul"},

  %arg1: tensor<1x28x28x64xf32>,
  %arg2: tensor<64xf32>
) -> tensor<1x28x28x64xf32> {

  // CHECK: "tf.FusedBatchNormGradV3"
  // CHECK-SAME: (%[[X_TRANSPOSE:[0-9]*]], %[[Y_TRANSPOSE:[0-9]*]],
  // CHECK-SAME: data_format = "NCHW"
  %x_backprop, %scale_backprop, %offset_backprop, %reserve_1, %reserve_2
    = "tf.FusedBatchNormGradV3"(%arg0, %arg1, %arg2, %arg2, %arg2, %arg2)
       {
         data_format = "NHWC",

  %0 = "stablehlo.reduce"(%arg0, %arg1) ({
  ^bb0(%arg2: tensor<5xf32>, %arg3: tensor<5xf32> ):
    // CHECK:      %1 = "vhlo.abs_v1"(%arg2) : (tensor<5xf32>) -> tensor<5xf32>
    // CHECK-NEXT: %2 = tfl.add %1, %arg2 {fused_activation_function = "NONE"} : tensor<5xf32>
    // CHECK-NEXT: %3 = "vhlo.abs_v1"(%2) : (tensor<5xf32>) -> tensor<5xf32>
    %1 = stablehlo.abs %arg2 : tensor<5xf32>
    %2 = tfl.add %1, %arg2 {fused_activation_function = "NONE"} : tensor<5xf32>

  func.return
}

// CHECK-LABEL: func @replace_single_output
// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i1>, [[ARG1:%.+]]: tensor<i1>, [[ARG2:%.+]]: tensor<i1>, [[ARG3:%.+]]: tensor<!tf_type.resource>)
func.func @replace_single_output(%arg0: tensor<i1>, %arg1: tensor<i1>, %arg2: tensor<i1>, %arg3: tensor<!tf_type.resource>) {
  // CHECK:      {{%.+}}:2 = "tf_device.parallel_execute"
  %0:3 = "tf_device.parallel_execute"() ({

func.func @replicated(%arg0: tensor<!tf_type.resource<tensor<10x3xf32>>>, %arg1: tensor<!tf_type.resource<tensor<10x3xf32>>>, %arg2: tensor<!tf_type.resource<tensor<10x3xf32>>>, %arg3: tensor<!tf_type.resource<tensor<10x3xf32>>>) -> tensor<!tf_type.resourc...

  // CHECK: %[[ARG1_TPOSE:[0-9]*]] = "tf.Transpose"(%arg1, %[[ARG_PERM]])

  // CHECK: "tf.FusedBatchNormGradV3"
  // CHECK-SAME: (%[[ARG0_TPOSE]], %[[ARG1_TPOSE]], %arg2, %arg2, %arg2, %arg2)
  // CHECK-SAME: data_format = "NCHW"
  // CHECK-SAME: (tensor<1x64x28x28xf32>, tensor<1x64x28x28xf32>,
  // CHECK-SAME: -> (tensor<1x64x28x28xf32>,

  // CHECK: %[[RES_PERM:.*]] = "tf.Const"()