TF_RETURN_IF_ERROR(MaybeSetOpName(op_ptr.get(), name));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(x));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(y));
  int num_retvals = 1;
  return op_ptr->Execute(absl::MakeSpan(z, 1), &num_retvals);
}

// Op: Conj()
// Summary: Returns the complex conjugate of a complex number.
//
// Description:
//   Given a tensor `input` of complex numbers, this operation returns a tensor

  TF_RETURN_IF_ERROR(op_ptr->Reset("Identity", raw_device_name));
  TF_RETURN_IF_ERROR(MaybeSetOpName(op_ptr.get(), name));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(input));
  int num_retvals = 1;
  return op_ptr->Execute(absl::MakeSpan(output, 1), &num_retvals);
}

// Op: IdentityN()
// Summary: Returns a list of tensors with the same shapes and contents as the
// input
//
// Description:
//   tensors.
//

  TF_RETURN_IF_ERROR(op_ptr->Reset("Neg", raw_device_name));
  TF_RETURN_IF_ERROR(MaybeSetOpName(op_ptr.get(), name));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(x));
  int num_retvals = 1;
  return op_ptr->Execute(absl::MakeSpan(y, 1), &num_retvals);
}

// Op: MatMul()
// Summary:
//
// Description:

      Tensor tensor, runtime.CreateHostTensor<float>({}, TF_FLOAT, {2.0f}));
  TF_ASSERT_OK_AND_ASSIGN(Tensor result, fn.Call<Tensor>(Tensor(tensor)));

  float out_val[1];
  TF_ASSERT_OK(result.GetValue(absl::MakeSpan(out_val)));
  EXPECT_EQ(out_val[0], 6.0);
}

TEST_P(RuntimeTest, SimpleModelCallableIntTest) {
  Runtime runtime = RuntimeTest::GetParam()();

  // Import the module and grab the callable

  TF_RETURN_IF_ERROR(op_ptr->SetAttrShape("shape", shape));
  TF_RETURN_IF_ERROR(
      op_ptr->SetAttrStringList("allowed_devices", allowed_devices));
  int num_retvals = 1;
  return op_ptr->Execute(absl::MakeSpan(resource, 1), &num_retvals);
}

// Op: ReadVariableOp()
// Summary: Reads the value of a variable.
//
// Description:
//   The tensor returned by this operation is immutable.
//

  TF_RETURN_IF_ERROR(MaybeSetOpName(op_ptr.get(), name));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(gradients));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(features));
  int num_retvals = 1;
  return op_ptr->Execute(absl::MakeSpan(backprops, 1), &num_retvals);
}

// Op: Relu()
// Summary: Computes rectified linear: `max(features, 0)`.
//
// Description:
//   See: https://en.wikipedia.org/wiki/Rectifier_(neural_networks)
//   Example usage:

}

void OpImplementationRenderer::RenderExecutionSingleOutput() {
  ArgView output_arg = op_.OnlyOutput();
  Statement("int num_retvals = 1");
  Statement("return $0->Execute(absl::MakeSpan($1, 1), &num_retvals)",
            op_.VariableName(), output_arg.VariableName());
}

void OpImplementationRenderer::RenderExecutionMultipleOutputs() {
  Statement("int num_retvals = $0", op_.NumOutputs());

                                  strlen(ResourceHandle::ANONYMOUS_NAME)));

  AbstractTensorHandle* var_handle = nullptr;
  int num_retvals = 1;
  TF_RETURN_IF_ERROR(varhandle_op->Execute(
      absl::MakeSpan(&var_handle, num_retvals), &num_retvals));
  AbstractTensorHandlePtr owned_var_handle(var_handle);
  if (!tensorflow::isa<ImmediateExecutionTensorHandle>(
          owned_var_handle.get())) {

  // Copy to eliminate the `const` qualifier so that `absl::MakeSpan` can be
  // called on it.
  std::vector<std::string> exported_names = signature_keys;
  absl::StatusOr<OwningOpRef<ModuleOp>> module_op =
      SavedModelSignatureDefsToMlirImport(saved_model_path, tags,
                                          absl::MakeSpan(exported_names), &ctx,
                                          import_options, &bundle);

                      absl::Span<AbstractTensorHandle*> outputs) {
  std::vector<AbstractTensorHandle*> temp_outputs(2);
  TF_RETURN_IF_ERROR(
      ops::IdentityN(ctx, inputs, absl::MakeSpan(temp_outputs), "IdentityN"));
  // Although, `ops::IdentityN` returns 2 tensors, the first tensor isn't needed
  // for computing gradient so we could safely drop it.
  outputs[0] = temp_outputs[1];
  temp_outputs[0]->Unref();