// CHECK: }

func.func @unknown_side_effecting_op(%arg0: tensor<32xf32>) -> () {
  tf_executor.graph {
    %island = tf_executor.island {
      %vh0 = "tf.VarHandleOp"() {container = "c", shared_name = "v0"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>
      %vh1 = "tf.VarHandleOp"() {container = "c", shared_name = "v1"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>

func.func @unknown_side_effecting_op(%arg0: tensor<32xf32>) {
  tf_executor.graph {
    %outputs, %control = tf_executor.island wraps "tf.VarHandleOp"() {container = "c", shared_name = "v0"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>
    %outputs_0, %control_1 = tf_executor.island wraps "tf.VarHandleOp"() {container = "c", shared_name = "v1"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>

      "IdentityN",  // Variadic input+output
      "SparseSoftmaxCrossEntropyWithLogits",  // 2 outputs
      "AccumulatorApplyGradient",             // 0 outputs
      "VarHandleOp",                          // type, shape, list(string) attrs
      "RestoreV2",  // Variadic output-only, list(type) attr
  };

  cpp::CppConfig cpp_config(category, name_space);

  bool unconditionally_use_set_output_shapes = false;

  // Apply default attributes from the op definition to the loaded op.
  bool add_default_attributes = true;

  // If set, promote tf.VarHandleOp to resource arguments for all functions.
  bool lift_variables = true;

  // Keeps the variables in initializers before lifting variables (when
  // `lift_variables == true`) or newly adding variable initialization patterns

  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation)) {
    mutable_variables_.insert(GetResourceKey(operation));
  }
}

bool ResourceAnalyzer::IsPotentiallyWritten(Value resource) const {
  assert(IsResource(resource));
  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation))
    return mutable_variables_.contains(GetResourceKey(operation));

                                                                               \
  REGISTER_KERNEL_BUILDER(                                                     \
      Name("VarHandleOp").Device(DEVICE).HostMemory("resource"), VarHandleOp); \
  REGISTER_KERNEL_BUILDER(                                                     \
      Name("_VarHandlesOp").Device(DEVICE).HostMemory("resources"),            \

#include "tensorflow/c/eager/abstract_context.h"
#include "tensorflow/c/eager/abstract_tensor_handle.h"

namespace tensorflow {
namespace ops {

// Creates a handle to a Variable resource.
Status VarHandleOp(AbstractContext* ctx, AbstractTensorHandle** resource,
                   DataType dtype, const PartialTensorShape shape,
                   const char* container = "", const char* shared_name = "",

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/status.h"

namespace tensorflow {
namespace internal {

// Executes a VarHandleOp using `ctx`, and fills `handle` with the DT_RESOURCE
// TensorHandle associated with the variable. This is equivalent to creating an
// unitialized TF2 tf.Variable.

      Operation *op = *latticeElement->getValue().ops.begin();
      GlobalTensorOp globalTensor = llvm::dyn_cast<GlobalTensorOp>(op);

      if (!globalTensor)
        continue;  // happens if the name is e.g. in a VarHandleOp.

      if (globalTensor.getIsMutable()) {
        freezeable[val] = false;
        continue;
      }

      freezeable[val] = true;

      // Verify users are supported kind.

//