= "args_7"}, %arg8: tensor<?x?xf32> {tf._user_specified_name = "args_8"}, %arg9: tensor<?x300xi32> {tf._user_specified_name = "args_9"}, %arg10: tensor<?x300xi32> {tf._user_specified_name = "args_10"}, %arg11: tensor<?x300xf32> {tf._user_specified_name = "args_11"}, %arg12: tensor<?x300xf32> {tf._user_specified_name = "args_12"}, %arg13: tensor<?x!tf_type.string> {tf._user_specified_name = "args_13"}, %arg14: tensor<?x!tf_type.string> {tf._user_specified_name = "args_14"}, %arg15: tensor<!tf_ty...

# CHECK-SAME: _xla_compile_device_type = "GPU"
# CHECK-SAME: allow_soft_placement
# CHECK-SAME: control_outputs = ""
# CHECK-SAME: inputs = "args_0,args_1,args_2,args_3"
# CHECK-SAME: outputs = "rets_0,rets_1"
# CHECK:          %[[ISLAND_0:.*]], %[[ISLAND_0_control:.*]] = tf_executor.island wraps "tf.Const"

    // CHECK-NEXT: "tf.MakeIterator"(%[[ARG_0]], %[[ANON_ITER]])
    // CHECK-NEXT: %[[COND:.*]] = "tf.Const"
    // CHECK-NEXT: %[[WHILE:[0-9]*]]:5 = "tf.WhileRegion"(%[[COND]], %[[ARG_1]], %[[ARG_2]], %[[ARG_3]], %[[ARG_4]])
    // CHECK-NEXT:   ^bb0(%[[ARG_5:.*]]: tensor<i1>, %[[ARG_6:.*]]: tensor<i64>, %[[ARG_7:.*]]: tensor<i32>, %[[ARG_8:.*]]: tensor<!tf_type.resource<tensor<64xf32>>>, %[[ARG_9:.*]]: tensor<!tf_type.resource<tensor<128xf32>>>)

	arg_Dn_half
	arg_R1_0
	arg_R1_12
	arg_R2_0
	arg_R2_12
	arg_R_0
	arg_R_12
	arg_R_12_nzcv
	arg_R_16
	arg_R_16_WB
	arg_R_8
	arg_R_rotate
	arg_R_shift_R
	arg_R_shift_imm
	arg_SP
	arg_Sd
	arg_Sd_Dd
	arg_Dd_Sd
	arg_Sm
	arg_Sm_Dm
	arg_Sn
	arg_Sn_Dn
	arg_const
	arg_endian
	arg_fbits
	arg_fp_0
	arg_imm24
	arg_imm5
	arg_imm5_32
	arg_imm5_nz

// Start step 0
C_0 = cond(args_0)
N_0 = non_tpu(args_0)
if (C_0) {
   F_0 = forward(args_0, N_0)
   T_0 = core_tpu(args_0, N_0, F_0)
   // B_0 = backward() is not evaluated here.
}

args_1 = update_args(args_0, N_0, T_0)

// Start step 1
C_1 = cond(args_1)
N_1 = non_tpu(args_1)
if (C_1) {
   F_1 = forward(args_1, N_1)
   // T_1 = core_tpu() is not evaluated here.

    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "args_0"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_RESOURCE
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "spc1"
  op: "StatefulPartitionedCall"
  input: "input0"
  input: "args_0"
  attr {
    key: "Tin"
    value {
      list {

    func.return %4, %6 : tensor<!tf_type.variant>, tensor<!tf_type.variant>
  }
  // CHECK-LABEL: @funcB_renamed
  func.func private @funcB_renamed(%arg0: tensor<i64> {tf._user_specified_name = "args_0"}) -> tensor<!tf_type.variant> attributes {tf._original_func_name = "funcB", tf._tf_data_function = true, tf.signature.is_stateful} {
    %0 = "tf.Const"() {device = "/device:CPU:0", value = dense<0> : tensor<i64>} : () -> tensor<i64>

    func.return %4 : tensor<!tf_type.variant>
  }
  // CHECK-LABEL: __inference_Dataset_flat_map_lambda_190
  func.func private @__inference_Dataset_flat_map_lambda_190(%arg0: tensor<i64> {tf._user_specified_name = "args_0"}) -> tensor<!tf_type.variant> attributes {tf._original_func_name = "__inference_Dataset_flat_map_lambda_19", tf._tf_data_function = true, tf.signature.is_stateful} {

                         AbstractContext* ctx) {
  auto CallFn = [fn_name, fn, ctx](TaggedValue args_,
                                   TaggedValue kwargs_) -> TaggedValue {
    std::cout << "Calling " << fn_name << std::endl;
    tensorflow::StatusOr<TaggedValue> v = fn.Execute(ctx, args_);
    return v.value();
  };
  return TaggedValue(CallFn);
}

// Import a module from a saved model.
//

        assertThat(args2.length, is(1));

        final ParameterizedClassDesc arg2_1 = args2[0];
        assertThat(arg2_1.getRawClass(), is(sameClass(Integer.class)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testMethodParameterType() throws Exception {