size: 3
        }
      }
    }
  }
}
node {
  name: "MobilenetV1/Conv2d_0/weights"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 3
          }
          dim {
            size: 3
          }

  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "Enter"
  op: "Enter"
  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {

module  {
  tfg.graph #tf_type.version<producer = 62, min_consumer = 12> {
    %Const, %ctl = Const name("Constant") {dtype = i32, value = dense<0> : tensor<i32>} : () -> (tensor<i32>)
    %foo, %ctl_0 = foo(%Const) name("_tf.foo") : (tensor<i32>) -> (tensor<*xi32>)
  }
  tfg.func @foo(%arg: tensor<*xi32> {tfg.name = "arg"})
       -> (tensor<*xi32> {tfg.dtype = i32, tfg.name = "return_value"})
   {
    // CHECK-NOT: ^bb0{{.*}}, %arg2: !tf_type.control

  attr: {
    key: "key_dtype"
    value: {
      type: DT_INT32
    }
  }
  attr: {
    key: "shared_name"
    value: {
      s: ""
    }
  }
  attr: {
    key: "value_dtype"
    value: {
      type: DT_FLOAT
    }
  }
}
node {
  name: "variable_node"
  op: "Variable"
  attr {
    key: "dtype"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "shape"

  static Status CreateUninitialized(
      ImmediateExecutionContext* ctx, DataType dtype, TensorShape shape,
      absl::optional<std::string> name, const char* raw_device_name,
      const std::vector<std::string>& component_devices,
      std::unique_ptr<Variable>* output);

  // The dtype of the underlying variable.
  DataType dtype();

  // The shape of the underlying variable.
  TensorShape shape();

  auto dtype = input->DataType();
  if (DataTypeIsFloating(BaseType(dtype)) ||
      DataTypeIsInteger(BaseType(dtype))) {
    return tensorflow::ops::Identity(ctx, input, output, name);
  } else if (!DataTypeIsComplex(BaseType(dtype)) &&
             BaseType(dtype) != DT_VARIANT) {
    return errors::InvalidArgument(
        "Expected numeric or variant tensor, got dtype ", dtype);
  }

node {
  name: "const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 0.0
      }
    }
  }
}
node {
  name: "test_fn_call"

  // CHECK-NEXT: op: "Const"
  // CHECK: attr {
  // CHECK:        key: "dtype"
  // CHECK-NEXT:   value {
  // CHECK-NEXT:     type: DT_INT32
  // CHECK-NEXT:   }
  // CHECK-NEXT: }
  // CHECK-NEXT: attr {
  // CHECK-NEXT:   key: "value"
  // CHECK-NEXT:   value {
  // CHECK-NEXT:     tensor {
  // CHECK-NEXT:       dtype: DT_INT32
  // CHECK-NEXT:       tensor_shape {
  // CHECK-NEXT:         dim {

          size: 2
        }
      }
    }
  }
}
node {
  name: "conv_net_2d/conv_2d_0/w"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 3
          }
          dim {
            size: 3
          }

        }
      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 1
          }
          dim {
            size: 1
          }