for (int i = 0; i < expected_results.size(); ++i) {
      TF_Tensor* out = csession.output_tensor(i);
      ASSERT_TRUE(out != nullptr);
      EXPECT_EQ(TF_INT32, TF_TensorType(out));
      EXPECT_EQ(0, TF_NumDims(out));  // scalar
      ASSERT_EQ(sizeof(int32_t), TF_TensorByteSize(out));
      int32_t* output_contents = static_cast<int32_t*>(TF_TensorData(out));
      EXPECT_EQ(expected_results[i], *output_contents);
    }
  }

                task producer(type: OutputFilesTask) {
                    out1.convention(layout.buildDirectory.file("\${project.name}.out1.jar"))
                    out2.convention(layout.buildDirectory.file("\${project.name}.out2.jar"))
                }

                artifacts {
                    implementation producer.out1
                    implementation producer.out2
                }

	}
	sort.Strings(typedefNames)
	for _, name := range typedefNames {
		def := typedef[name]
		fmt.Fprintf(fgo2, "type %s ", name)
		// We don't have source info for these types, so write them out without source info.
		// Otherwise types would look like:
		//
		// type _Ctype_struct_cb struct {
		// //line :1
		//        on_test *[0]byte
		// //line :1
		// }
		//

                      slice[-9876543210:-1] runtime error: slice bounds out of range [:-1]
                       slice[-9876543210:0] runtime error: slice bounds out of range [-9876543210:]
                       slice[-9876543210:3] runtime error: slice bounds out of range [-9876543210:]
                       slice[-9876543210:4] runtime error: slice bounds out of range [:4] with capacity 3

  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  TF_Tensor* out = csession.output_tensor(0);
  ASSERT_TRUE(out != nullptr);
  EXPECT_EQ(TF_FLOAT, TF_TensorType(out));
  EXPECT_EQ(2, TF_NumDims(out));
  EXPECT_EQ(4, TF_Dim(out, 0));
  EXPECT_EQ(1, TF_Dim(out, 1));
  float* values = static_cast<float*>(TF_TensorData(out));
  // These values are defined to be (input / 2) + 2.
  EXPECT_EQ(2, values[0]);

      rewrite_subgraph_fn, reuse_existing_functions, library));

  std::unique_ptr<Graph> out(new Graph(library));
  out->set_versions(graph_in.versions());
  TF_RETURN_IF_ERROR(encapsulator.BuildOutputGraph(out.get(), library));

  *graph_out = std::move(out);
  return absl::OkStatus();
}

// Finds the types of the _Arg nodes, indexed by position.

    auto op = cast<ResizeNearestNeighborOp>(src_op);
    auto loc = op.getLoc();
    auto result_ty = mlir::cast<ShapedType>(op.getType());

    auto input = op.getImages();
    auto input_ty = mlir::cast<ShapedType>(input.getType());
    auto input_element_ty = input_ty.getElementType();
    auto out_size = op.getSize();
    auto out_size_ty = mlir::cast<ShapedType>(out_size.getType());

                                    const OperatorT& quant_op, int idx) {
  const auto& builtin_code =
      GetBuiltinCode(quant_model.operator_codes[quant_op.opcode_index].get());
  for (const auto& expected_op : expected_graph.operators) {
    const auto& op_code =
        expected_model.operator_codes[expected_op->opcode_index].get();
    const auto& expected_code = GetBuiltinCode(op_code);
    if (expected_code == builtin_code) {

  auto loop_operands_n = UnpackResults(loop_operands_indexes_i);
  auto forward_res_nm2 = UnpackResults(forward_res_indexes_im2);
  auto forward_res_nm1 = UnpackResults(forward_res_indexes_im1);
  auto core_tpu_res_nm2 = UnpackResults(core_tpu_res_indexes_im2);
  auto non_tpu_res_nm1 = UnpackResults(non_tpu_res_indexes_im1);
  auto C_nm2 = new_while_op->getResult(C_index_im2);
  auto C_nm1 = new_while_op->getResult(C_index_im1);

  }

  auto c = op.input(0);
  auto x = op.input(1);
  auto y = op.input(2);

  auto zeros = ZerosLike(scope, grad_inputs[0]);
  auto gx = SelectV2(scope, c, grad_inputs[0], zeros);
  auto x_shape = Shape(scope, x);
  auto output_shape = Shape(scope, op.output(0));

  // Reduce away broadcasted leading dims.