// Demangle a string mangled with MangleShape.
Status DemangleShape(absl::string_view str, TensorShapeProto* proto);

// Return a TensorProto mangled as a string.
string MangleTensor(const TensorProto& tensor);
// Demangle a string mangled with MangleTensor.
Status DemangleTensor(absl::string_view str, TensorProto* proto);

// Return a DataType mangled as a string.
string MangleDataType(const DataType& dtype);

  tensor.matrix<tsl::qint8>()(1, 1) = tsl::qint8(4);

  ::tensorflow::TensorProto tensor_proto;
  tensor.AsProtoTensorContent(&tensor_proto);
  return ::tensorflow::mangling_util::MangleTensor(tensor_proto);
}

std::string GetQint16Tensor() {
  ::tensorflow::Tensor tensor(::tensorflow::DT_QINT16, {2, 2});
  tensor.matrix<tsl::qint16>()(0, 0) = tsl::qint16(1);

  return absl::StrCat(kTensorShapePrefix, PrintShortTextProto(shape));
}

Status DemangleShape(absl::string_view str, TensorShapeProto* proto) {
  return ParseTextProto(str, kTensorShapePrefix, proto);
}

string MangleTensor(const TensorProto& tensor) {
  return absl::StrCat(kTensorPrefix, PrintShortTextProto(tensor));
}

Status DemangleTensor(absl::string_view str, TensorProto* proto) {
  return ParseTextProto(str, kTensorPrefix, proto);

  if (use_tensor_content)
    input_tensor.AsProtoTensorContent(&tensor_proto);
  else
    input_tensor.AsProtoField(&tensor_proto);
  return tensor_proto;
}

static std::string MangleTensor(const Tensor& tensor) {
  return mangling_util::MangleTensor(ConvertToProto(tensor));
}

// Converts a TensorFlow tensor into an MLIR elements attribute.
template <typename T>
absl::StatusOr<ElementsAttr> ConvertFlatTensor(const Tensor& input_tensor,

      content.assign(reinterpret_cast<const char*>(&complex_value),
                     sizeof(complex_value));
      repr.set_tensor_content(content);
      std::string mangled = tensorflow::mangling_util::MangleTensor(repr);

      return mlir::TF::TensorProtoAttr::get(shaped_type, mangled);
    } else {
      return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                                "Unsupported type");
    }

                                              : tensorflow::DT_QINT32);

      tensor_proto_attr = ElementsAttr(TF::TensorProtoAttr::get(
          new_type, tensorflow::mangling_util::MangleTensor(tensor_proto)));
    }
    auto const_op =
        rewriter.create<TF::ConstOp>(loc, new_type, tensor_proto_attr);
    // Add scast op to match quantize -> composition pattern. The added scast

  } else if (elem_type.isa<mlir::ComplexType, mlir::TF::TensorFlowType>()) {
    tensorflow::TensorProto repr =
        tfl::ConvertTfliteConstTensor(tensor, buffer);
    std::string mangled = tensorflow::mangling_util::MangleTensor(repr);

    value = mlir::TF::TensorProtoAttr::get(shaped_type, mangled);
  } else {
    return errors::Unimplemented("Constant of unsupported type");
  }

  if (use_stablehlo_constant) {