explicit Tensor(TF_Tensor* tensor) : tensor_(tensor) {}

  // Tensor is not copyable
  Tensor(const Tensor&) = delete;
  Tensor& operator=(const Tensor&) = delete;

  // Returns the underlying TF_Tensor that this object wraps.
  // This object retains ownership of the pointer.
  TF_Tensor* GetTFTensor() const { return tensor_.get(); }

  struct DeleterStruct {

  CHECK(SerializeToTString(s, output_tstring));
  TF_DeleteTensor(summary_tensor);
}

bool IsSameSize(TF_Tensor* tensor1, TF_Tensor* tensor2) {
  if (TF_NumDims(tensor1) != TF_NumDims(tensor2)) {
    return false;
  }
  for (int d = 0; d < TF_NumDims(tensor1); d++) {
    if (TF_Dim(tensor1, d) != TF_Dim(tensor2, d)) {
      return false;
    }
  }
  return true;
}

std::string SingleTag(TF_Tensor* tags) {

#include "absl/container/flat_hash_map.h"
#include "tensorflow/core/graph/tensor_id.h"

namespace tensorflow {
namespace deadness_analysis_internal {

// Returns a map describing the predicate each Tensor was mapped to.  For
// testing purposes only.
using PredicateMapTy = absl::flat_hash_map<TensorId, string, TensorId::Hasher>;
Status ComputePredicates(const Graph& graph, PredicateMapTy* out_predicate_map,

  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor1,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {2.0f}))
  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor2,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {3.0f}))

  TF_ASSERT_OK_AND_ASSIGN(Tensor result_tensor,
                          fn.Call<Tensor>(tensor1, tensor2));
  float out_val[1];

// RUN: tf-opt "-tfl-lower-static-tensor-list=allow-tensorlist-pass-through default-to-single-batch=false" -split-input-file %s | FileCheck %s

// -----

func.func @tensorlistReserveConstantUnknownElementShapeDim(%arg0: tensor<i32>, %arg1: tensor<i32>) -> tensor<?x7xf32> {
  %cst = arith.constant dense<[-1, 7]> : tensor<2xi32>
  %0 = "tf.TensorListReserve"(%cst, %arg0) : (tensor<2xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<?x7xf32>>>

TF_CAPI_EXPORT extern TF_Tensor* TF_TensorMaybeMove(TF_Tensor* tensor);

// Destroy a tensor.
TF_CAPI_EXPORT extern void TF_DeleteTensor(TF_Tensor*);

// Return the type of a tensor element.
TF_CAPI_EXPORT extern TF_DataType TF_TensorType(const TF_Tensor*);

// Set a new shape for the Tensor.
TF_CAPI_EXPORT extern void TF_SetShape(TF_Tensor* tensor, const int64_t* dims,

  );

  let results = (outs
    TensorOf<[TF_Float32]>:$output,
    TensorOf<[TF_Float32]>:$min,
    TensorOf<[TF_Float32]>:$max,
    TensorOf<[TF_Int64]>:$histogram
  );
}

def TF_CalibrationStatisticsSaverOp : TF_Op<"CalibrationStatisticsSaver", []> {
  let summary = "Aggregates and saves calibration statistics.";

  let arguments = (ins
    Variadic<TensorOf<[TF_Float32, TF_Int64]>>:$inputs,

func.func @sub(%arg0: tensor<3x2xf32>) -> tensor<3x2xf32> attributes {tf.entry_function = {inputs = "serving_default_x", outputs = "outputs"}} {
  %0 = "tfl.pseudo_const" () {value = dense<[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]> : tensor<3x2xf32>} : () -> tensor<3x2xf32>
  %1 = "tfl.sub" (%0, %arg0) {fused_activation_function = "NONE"} : (tensor<3x2xf32>, tensor<3x2xf32>) -> tensor<3x2xf32>
  func.return %1 : tensor<3x2xf32>
}
}

// CHECK:      {

 func.func @main () -> tensor<1x1x1x96xf32> {
  %0 = "vhlo.constant_v1"() <{value = #vhlo.tensor_v1<dense<0.000000e+00> : tensor<f32>>}> : () -> tensor<1x1x1x96xf32>
  func.return %0 : tensor<1x1x1x96xf32>
 }
}

//CHECK: func.func @main() -> tensor<1x1x1x96xf32> attributes {tf.entry_function = {outputs = "vhlo.constant_v1"}} {

    oneof name_oneof {
      string name = 1;

      // An regex can be used to match multiple tensors.
      string name_regex = 2;
    }

    // The quantization parameters for the tensor. If it is for per-axis, the
    // parameters should be defined for each axis, otherwise, if it is for
    // per-tensor, this repeated field should only contain a single element.
    repeated PerAxisParams params = 3;