// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.proto
// Protobuf C++ Version: 5.28.3

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 5028003
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/map.h"  // IWYU pragma: export
#include "google/protobuf/map_entry.h"
#include "google/protobuf/map_field_inl.h"
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "tensorflow/compiler/mlir/quantization/stablehlo/quantization_config.pb.h"
#include "tensorflow/core/framework/tensor.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto PROTOBUF_EXPORT

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct PROTOBUF_EXPORT TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto {
  static const ::uint32_t offsets[];
};
PROTOBUF_EXPORT extern const ::google::protobuf::internal::DescriptorTable
    descriptor_table_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
namespace tensorflow {
namespace quantization {
class QuantizationComponentSpec;
struct QuantizationComponentSpecDefaultTypeInternal;
PROTOBUF_EXPORT extern QuantizationComponentSpecDefaultTypeInternal _QuantizationComponentSpec_default_instance_;
class QuantizationMethod;
struct QuantizationMethodDefaultTypeInternal;
PROTOBUF_EXPORT extern QuantizationMethodDefaultTypeInternal _QuantizationMethod_default_instance_;
class QuantizationOptions;
struct QuantizationOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern QuantizationOptionsDefaultTypeInternal _QuantizationOptions_default_instance_;
class QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse;
struct QuantizationOptions_RepresentativeDatasetsEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern QuantizationOptions_RepresentativeDatasetsEntry_DoNotUseDefaultTypeInternal _QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse_default_instance_;
class RepresentativeDataSample;
struct RepresentativeDataSampleDefaultTypeInternal;
PROTOBUF_EXPORT extern RepresentativeDataSampleDefaultTypeInternal _RepresentativeDataSample_default_instance_;
class RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse;
struct RepresentativeDataSample_TensorProtoInputsEntry_DoNotUseDefaultTypeInternal;
PROTOBUF_EXPORT extern RepresentativeDataSample_TensorProtoInputsEntry_DoNotUseDefaultTypeInternal _RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse_default_instance_;
class RepresentativeDatasetFile;
struct RepresentativeDatasetFileDefaultTypeInternal;
PROTOBUF_EXPORT extern RepresentativeDatasetFileDefaultTypeInternal _RepresentativeDatasetFile_default_instance_;
class UnitWiseQuantizationSpec;
struct UnitWiseQuantizationSpecDefaultTypeInternal;
PROTOBUF_EXPORT extern UnitWiseQuantizationSpecDefaultTypeInternal _UnitWiseQuantizationSpec_default_instance_;
class UnitWiseQuantizationSpec_QuantizationUnit;
struct UnitWiseQuantizationSpec_QuantizationUnitDefaultTypeInternal;
PROTOBUF_EXPORT extern UnitWiseQuantizationSpec_QuantizationUnitDefaultTypeInternal _UnitWiseQuantizationSpec_QuantizationUnit_default_instance_;
}  // namespace quantization
}  // namespace tensorflow
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace tensorflow {
namespace quantization {
enum QuantizationMethod_PresetMethod : int {
  QuantizationMethod_PresetMethod_METHOD_UNSPECIFIED = 0,
  QuantizationMethod_PresetMethod_METHOD_NO_QUANTIZE = 1,
  QuantizationMethod_PresetMethod_METHOD_STATIC_RANGE_INT8 = 2,
  QuantizationMethod_PresetMethod_METHOD_DYNAMIC_RANGE_INT8 = 3,
  QuantizationMethod_PresetMethod_METHOD_STATIC_RANGE_WEIGHT_ONLY_INT8 = 4,
  QuantizationMethod_PresetMethod_QuantizationMethod_PresetMethod_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  QuantizationMethod_PresetMethod_QuantizationMethod_PresetMethod_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool QuantizationMethod_PresetMethod_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t QuantizationMethod_PresetMethod_internal_data_[];
constexpr QuantizationMethod_PresetMethod QuantizationMethod_PresetMethod_PresetMethod_MIN = static_cast<QuantizationMethod_PresetMethod>(0);
constexpr QuantizationMethod_PresetMethod QuantizationMethod_PresetMethod_PresetMethod_MAX = static_cast<QuantizationMethod_PresetMethod>(4);
constexpr int QuantizationMethod_PresetMethod_PresetMethod_ARRAYSIZE = 4 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
QuantizationMethod_PresetMethod_descriptor();
template <typename T>
const std::string& QuantizationMethod_PresetMethod_Name(T value) {
  static_assert(std::is_same<T, QuantizationMethod_PresetMethod>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PresetMethod_Name().");
  return QuantizationMethod_PresetMethod_Name(static_cast<QuantizationMethod_PresetMethod>(value));
}
template <>
inline const std::string& QuantizationMethod_PresetMethod_Name(QuantizationMethod_PresetMethod value) {
  return ::google::protobuf::internal::NameOfDenseEnum<QuantizationMethod_PresetMethod_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool QuantizationMethod_PresetMethod_Parse(absl::string_view name, QuantizationMethod_PresetMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QuantizationMethod_PresetMethod>(
      QuantizationMethod_PresetMethod_descriptor(), name, value);
}
enum QuantizationComponentSpec_QuantizationComponent : int {
  QuantizationComponentSpec_QuantizationComponent_COMPONENT_UNSPECIFIED = 0,
  QuantizationComponentSpec_QuantizationComponent_COMPONENT_ACTIVATION = 1,
  QuantizationComponentSpec_QuantizationComponent_COMPONENT_WEIGHT = 2,
  QuantizationComponentSpec_QuantizationComponent_COMPONENT_BIAS = 3,
  QuantizationComponentSpec_QuantizationComponent_QuantizationComponentSpec_QuantizationComponent_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  QuantizationComponentSpec_QuantizationComponent_QuantizationComponentSpec_QuantizationComponent_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool QuantizationComponentSpec_QuantizationComponent_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t QuantizationComponentSpec_QuantizationComponent_internal_data_[];
constexpr QuantizationComponentSpec_QuantizationComponent QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_MIN = static_cast<QuantizationComponentSpec_QuantizationComponent>(0);
constexpr QuantizationComponentSpec_QuantizationComponent QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_MAX = static_cast<QuantizationComponentSpec_QuantizationComponent>(3);
constexpr int QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
QuantizationComponentSpec_QuantizationComponent_descriptor();
template <typename T>
const std::string& QuantizationComponentSpec_QuantizationComponent_Name(T value) {
  static_assert(std::is_same<T, QuantizationComponentSpec_QuantizationComponent>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to QuantizationComponent_Name().");
  return QuantizationComponentSpec_QuantizationComponent_Name(static_cast<QuantizationComponentSpec_QuantizationComponent>(value));
}
template <>
inline const std::string& QuantizationComponentSpec_QuantizationComponent_Name(QuantizationComponentSpec_QuantizationComponent value) {
  return ::google::protobuf::internal::NameOfDenseEnum<QuantizationComponentSpec_QuantizationComponent_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool QuantizationComponentSpec_QuantizationComponent_Parse(absl::string_view name, QuantizationComponentSpec_QuantizationComponent* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QuantizationComponentSpec_QuantizationComponent>(
      QuantizationComponentSpec_QuantizationComponent_descriptor(), name, value);
}
enum QuantizationComponentSpec_TensorType : int {
  QuantizationComponentSpec_TensorType_TENSORTYPE_UNSPECIFIED = 0,
  QuantizationComponentSpec_TensorType_TENSORTYPE_INT_4 = 1,
  QuantizationComponentSpec_TensorType_TENSORTYPE_INT_8 = 2,
  QuantizationComponentSpec_TensorType_TENSORTYPE_INT_32 = 3,
  QuantizationComponentSpec_TensorType_QuantizationComponentSpec_TensorType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  QuantizationComponentSpec_TensorType_QuantizationComponentSpec_TensorType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool QuantizationComponentSpec_TensorType_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t QuantizationComponentSpec_TensorType_internal_data_[];
constexpr QuantizationComponentSpec_TensorType QuantizationComponentSpec_TensorType_TensorType_MIN = static_cast<QuantizationComponentSpec_TensorType>(0);
constexpr QuantizationComponentSpec_TensorType QuantizationComponentSpec_TensorType_TensorType_MAX = static_cast<QuantizationComponentSpec_TensorType>(3);
constexpr int QuantizationComponentSpec_TensorType_TensorType_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
QuantizationComponentSpec_TensorType_descriptor();
template <typename T>
const std::string& QuantizationComponentSpec_TensorType_Name(T value) {
  static_assert(std::is_same<T, QuantizationComponentSpec_TensorType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to TensorType_Name().");
  return QuantizationComponentSpec_TensorType_Name(static_cast<QuantizationComponentSpec_TensorType>(value));
}
template <>
inline const std::string& QuantizationComponentSpec_TensorType_Name(QuantizationComponentSpec_TensorType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<QuantizationComponentSpec_TensorType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool QuantizationComponentSpec_TensorType_Parse(absl::string_view name, QuantizationComponentSpec_TensorType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QuantizationComponentSpec_TensorType>(
      QuantizationComponentSpec_TensorType_descriptor(), name, value);
}
enum OpSet : int {
  OP_SET_UNSPECIFIED = 0,
  TF = 1,
  XLA = 2,
  UNIFORM_QUANTIZED = 3,
  STABLEHLO = 4,
  OpSet_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  OpSet_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

PROTOBUF_EXPORT bool OpSet_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t OpSet_internal_data_[];
constexpr OpSet OpSet_MIN = static_cast<OpSet>(0);
constexpr OpSet OpSet_MAX = static_cast<OpSet>(4);
constexpr int OpSet_ARRAYSIZE = 4 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
OpSet_descriptor();
template <typename T>
const std::string& OpSet_Name(T value) {
  static_assert(std::is_same<T, OpSet>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OpSet_Name().");
  return OpSet_Name(static_cast<OpSet>(value));
}
template <>
inline const std::string& OpSet_Name(OpSet value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OpSet_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool OpSet_Parse(absl::string_view name, OpSet* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OpSet>(
      OpSet_descriptor(), name, value);
}

// ===================================================================


// -------------------------------------------------------------------

class PROTOBUF_EXPORT UnitWiseQuantizationSpec_QuantizationUnit final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit) */ {
 public:
  inline UnitWiseQuantizationSpec_QuantizationUnit() : UnitWiseQuantizationSpec_QuantizationUnit(nullptr) {}
  ~UnitWiseQuantizationSpec_QuantizationUnit() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR UnitWiseQuantizationSpec_QuantizationUnit(
      ::google::protobuf::internal::ConstantInitialized);

  inline UnitWiseQuantizationSpec_QuantizationUnit(const UnitWiseQuantizationSpec_QuantizationUnit& from) : UnitWiseQuantizationSpec_QuantizationUnit(nullptr, from) {}
  inline UnitWiseQuantizationSpec_QuantizationUnit(UnitWiseQuantizationSpec_QuantizationUnit&& from) noexcept
      : UnitWiseQuantizationSpec_QuantizationUnit(nullptr, std::move(from)) {}
  inline UnitWiseQuantizationSpec_QuantizationUnit& operator=(const UnitWiseQuantizationSpec_QuantizationUnit& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnitWiseQuantizationSpec_QuantizationUnit& operator=(UnitWiseQuantizationSpec_QuantizationUnit&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UnitWiseQuantizationSpec_QuantizationUnit& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnitWiseQuantizationSpec_QuantizationUnit* internal_default_instance() {
    return reinterpret_cast<const UnitWiseQuantizationSpec_QuantizationUnit*>(
        &_UnitWiseQuantizationSpec_QuantizationUnit_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(UnitWiseQuantizationSpec_QuantizationUnit& a, UnitWiseQuantizationSpec_QuantizationUnit& b) { a.Swap(&b); }
  inline void Swap(UnitWiseQuantizationSpec_QuantizationUnit* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UnitWiseQuantizationSpec_QuantizationUnit* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UnitWiseQuantizationSpec_QuantizationUnit* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<UnitWiseQuantizationSpec_QuantizationUnit>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const UnitWiseQuantizationSpec_QuantizationUnit& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const UnitWiseQuantizationSpec_QuantizationUnit& from) { UnitWiseQuantizationSpec_QuantizationUnit::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(UnitWiseQuantizationSpec_QuantizationUnit* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit"; }

 protected:
  explicit UnitWiseQuantizationSpec_QuantizationUnit(::google::protobuf::Arena* arena);
  UnitWiseQuantizationSpec_QuantizationUnit(::google::protobuf::Arena* arena, const UnitWiseQuantizationSpec_QuantizationUnit& from);
  UnitWiseQuantizationSpec_QuantizationUnit(::google::protobuf::Arena* arena, UnitWiseQuantizationSpec_QuantizationUnit&& from) noexcept
      : UnitWiseQuantizationSpec_QuantizationUnit(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kOpTypeFieldNumber = 1,
    kNodeNameFieldNumber = 2,
    kFuncNameFieldNumber = 3,
  };
  // string op_type = 1;
  void clear_op_type() ;
  const std::string& op_type() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_op_type(Arg_&& arg, Args_... args);
  std::string* mutable_op_type();
  PROTOBUF_NODISCARD std::string* release_op_type();
  void set_allocated_op_type(std::string* value);

  private:
  const std::string& _internal_op_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(
      const std::string& value);
  std::string* _internal_mutable_op_type();

  public:
  // string node_name = 2;
  void clear_node_name() ;
  const std::string& node_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_node_name(Arg_&& arg, Args_... args);
  std::string* mutable_node_name();
  PROTOBUF_NODISCARD std::string* release_node_name();
  void set_allocated_node_name(std::string* value);

  private:
  const std::string& _internal_node_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name(
      const std::string& value);
  std::string* _internal_mutable_node_name();

  public:
  // string func_name = 3;
  void clear_func_name() ;
  const std::string& func_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_func_name(Arg_&& arg, Args_... args);
  std::string* mutable_func_name();
  PROTOBUF_NODISCARD std::string* release_func_name();
  void set_allocated_func_name(std::string* value);

  private:
  const std::string& _internal_func_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_func_name(
      const std::string& value);
  std::string* _internal_mutable_func_name();

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      99, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const UnitWiseQuantizationSpec_QuantizationUnit& from_msg);
    ::google::protobuf::internal::ArenaStringPtr op_type_;
    ::google::protobuf::internal::ArenaStringPtr node_name_;
    ::google::protobuf::internal::ArenaStringPtr func_name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT RepresentativeDatasetFile final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.RepresentativeDatasetFile) */ {
 public:
  inline RepresentativeDatasetFile() : RepresentativeDatasetFile(nullptr) {}
  ~RepresentativeDatasetFile() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR RepresentativeDatasetFile(
      ::google::protobuf::internal::ConstantInitialized);

  inline RepresentativeDatasetFile(const RepresentativeDatasetFile& from) : RepresentativeDatasetFile(nullptr, from) {}
  inline RepresentativeDatasetFile(RepresentativeDatasetFile&& from) noexcept
      : RepresentativeDatasetFile(nullptr, std::move(from)) {}
  inline RepresentativeDatasetFile& operator=(const RepresentativeDatasetFile& from) {
    CopyFrom(from);
    return *this;
  }
  inline RepresentativeDatasetFile& operator=(RepresentativeDatasetFile&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RepresentativeDatasetFile& default_instance() {
    return *internal_default_instance();
  }
  enum DatasetFileCase {
    kTfrecordFilePath = 1,
    DATASET_FILE_NOT_SET = 0,
  };
  static inline const RepresentativeDatasetFile* internal_default_instance() {
    return reinterpret_cast<const RepresentativeDatasetFile*>(
        &_RepresentativeDatasetFile_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(RepresentativeDatasetFile& a, RepresentativeDatasetFile& b) { a.Swap(&b); }
  inline void Swap(RepresentativeDatasetFile* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RepresentativeDatasetFile* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RepresentativeDatasetFile* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<RepresentativeDatasetFile>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RepresentativeDatasetFile& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const RepresentativeDatasetFile& from) { RepresentativeDatasetFile::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RepresentativeDatasetFile* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.RepresentativeDatasetFile"; }

 protected:
  explicit RepresentativeDatasetFile(::google::protobuf::Arena* arena);
  RepresentativeDatasetFile(::google::protobuf::Arena* arena, const RepresentativeDatasetFile& from);
  RepresentativeDatasetFile(::google::protobuf::Arena* arena, RepresentativeDatasetFile&& from) noexcept
      : RepresentativeDatasetFile(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTfrecordFilePathFieldNumber = 1,
  };
  // string tfrecord_file_path = 1;
  bool has_tfrecord_file_path() const;
  void clear_tfrecord_file_path() ;
  const std::string& tfrecord_file_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tfrecord_file_path(Arg_&& arg, Args_... args);
  std::string* mutable_tfrecord_file_path();
  PROTOBUF_NODISCARD std::string* release_tfrecord_file_path();
  void set_allocated_tfrecord_file_path(std::string* value);

  private:
  const std::string& _internal_tfrecord_file_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tfrecord_file_path(
      const std::string& value);
  std::string* _internal_mutable_tfrecord_file_path();

  public:
  void clear_dataset_file();
  DatasetFileCase dataset_file_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.RepresentativeDatasetFile)
 private:
  class _Internal;
  void set_has_tfrecord_file_path();
  inline bool has_dataset_file() const;
  inline void clear_has_dataset_file();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      76, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const RepresentativeDatasetFile& from_msg);
    union DatasetFileUnion {
      constexpr DatasetFileUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr tfrecord_file_path_;
    } dataset_file_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT QuantizationComponentSpec final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.QuantizationComponentSpec) */ {
 public:
  inline QuantizationComponentSpec() : QuantizationComponentSpec(nullptr) {}
  ~QuantizationComponentSpec() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR QuantizationComponentSpec(
      ::google::protobuf::internal::ConstantInitialized);

  inline QuantizationComponentSpec(const QuantizationComponentSpec& from) : QuantizationComponentSpec(nullptr, from) {}
  inline QuantizationComponentSpec(QuantizationComponentSpec&& from) noexcept
      : QuantizationComponentSpec(nullptr, std::move(from)) {}
  inline QuantizationComponentSpec& operator=(const QuantizationComponentSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline QuantizationComponentSpec& operator=(QuantizationComponentSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const QuantizationComponentSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const QuantizationComponentSpec* internal_default_instance() {
    return reinterpret_cast<const QuantizationComponentSpec*>(
        &_QuantizationComponentSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(QuantizationComponentSpec& a, QuantizationComponentSpec& b) { a.Swap(&b); }
  inline void Swap(QuantizationComponentSpec* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QuantizationComponentSpec* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  QuantizationComponentSpec* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<QuantizationComponentSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const QuantizationComponentSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const QuantizationComponentSpec& from) { QuantizationComponentSpec::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(QuantizationComponentSpec* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.QuantizationComponentSpec"; }

 protected:
  explicit QuantizationComponentSpec(::google::protobuf::Arena* arena);
  QuantizationComponentSpec(::google::protobuf::Arena* arena, const QuantizationComponentSpec& from);
  QuantizationComponentSpec(::google::protobuf::Arena* arena, QuantizationComponentSpec&& from) noexcept
      : QuantizationComponentSpec(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using QuantizationComponent = QuantizationComponentSpec_QuantizationComponent;
  static constexpr QuantizationComponent COMPONENT_UNSPECIFIED = QuantizationComponentSpec_QuantizationComponent_COMPONENT_UNSPECIFIED;
  static constexpr QuantizationComponent COMPONENT_ACTIVATION = QuantizationComponentSpec_QuantizationComponent_COMPONENT_ACTIVATION;
  static constexpr QuantizationComponent COMPONENT_WEIGHT = QuantizationComponentSpec_QuantizationComponent_COMPONENT_WEIGHT;
  static constexpr QuantizationComponent COMPONENT_BIAS = QuantizationComponentSpec_QuantizationComponent_COMPONENT_BIAS;
  static inline bool QuantizationComponent_IsValid(int value) {
    return QuantizationComponentSpec_QuantizationComponent_IsValid(value);
  }
  static constexpr QuantizationComponent QuantizationComponent_MIN = QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_MIN;
  static constexpr QuantizationComponent QuantizationComponent_MAX = QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_MAX;
  static constexpr int QuantizationComponent_ARRAYSIZE = QuantizationComponentSpec_QuantizationComponent_QuantizationComponent_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* QuantizationComponent_descriptor() {
    return QuantizationComponentSpec_QuantizationComponent_descriptor();
  }
  template <typename T>
  static inline const std::string& QuantizationComponent_Name(T value) {
    return QuantizationComponentSpec_QuantizationComponent_Name(value);
  }
  static inline bool QuantizationComponent_Parse(absl::string_view name, QuantizationComponent* value) {
    return QuantizationComponentSpec_QuantizationComponent_Parse(name, value);
  }
  using TensorType = QuantizationComponentSpec_TensorType;
  static constexpr TensorType TENSORTYPE_UNSPECIFIED = QuantizationComponentSpec_TensorType_TENSORTYPE_UNSPECIFIED;
  static constexpr TensorType TENSORTYPE_INT_4 = QuantizationComponentSpec_TensorType_TENSORTYPE_INT_4;
  static constexpr TensorType TENSORTYPE_INT_8 = QuantizationComponentSpec_TensorType_TENSORTYPE_INT_8;
  static constexpr TensorType TENSORTYPE_INT_32 = QuantizationComponentSpec_TensorType_TENSORTYPE_INT_32;
  static inline bool TensorType_IsValid(int value) {
    return QuantizationComponentSpec_TensorType_IsValid(value);
  }
  static constexpr TensorType TensorType_MIN = QuantizationComponentSpec_TensorType_TensorType_MIN;
  static constexpr TensorType TensorType_MAX = QuantizationComponentSpec_TensorType_TensorType_MAX;
  static constexpr int TensorType_ARRAYSIZE = QuantizationComponentSpec_TensorType_TensorType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* TensorType_descriptor() {
    return QuantizationComponentSpec_TensorType_descriptor();
  }
  template <typename T>
  static inline const std::string& TensorType_Name(T value) {
    return QuantizationComponentSpec_TensorType_Name(value);
  }
  static inline bool TensorType_Parse(absl::string_view name, TensorType* value) {
    return QuantizationComponentSpec_TensorType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kQuantizationComponentFieldNumber = 1,
    kTensorTypeFieldNumber = 2,
  };
  // .tensorflow.quantization.QuantizationComponentSpec.QuantizationComponent quantization_component = 1;
  void clear_quantization_component() ;
  ::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent quantization_component() const;
  void set_quantization_component(::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent value);

  private:
  ::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent _internal_quantization_component() const;
  void _internal_set_quantization_component(::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent value);

  public:
  // .tensorflow.quantization.QuantizationComponentSpec.TensorType tensor_type = 2;
  void clear_tensor_type() ;
  ::tensorflow::quantization::QuantizationComponentSpec_TensorType tensor_type() const;
  void set_tensor_type(::tensorflow::quantization::QuantizationComponentSpec_TensorType value);

  private:
  ::tensorflow::quantization::QuantizationComponentSpec_TensorType _internal_tensor_type() const;
  void _internal_set_tensor_type(::tensorflow::quantization::QuantizationComponentSpec_TensorType value);

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.QuantizationComponentSpec)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const QuantizationComponentSpec& from_msg);
    int quantization_component_;
    int tensor_type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse, std::string, ::tensorflow::quantization::RepresentativeDatasetFile,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse, std::string, ::tensorflow::quantization::RepresentativeDatasetFile,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>;
  QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse*>(
        &_QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      83, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT QuantizationMethod final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.QuantizationMethod) */ {
 public:
  inline QuantizationMethod() : QuantizationMethod(nullptr) {}
  ~QuantizationMethod() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR QuantizationMethod(
      ::google::protobuf::internal::ConstantInitialized);

  inline QuantizationMethod(const QuantizationMethod& from) : QuantizationMethod(nullptr, from) {}
  inline QuantizationMethod(QuantizationMethod&& from) noexcept
      : QuantizationMethod(nullptr, std::move(from)) {}
  inline QuantizationMethod& operator=(const QuantizationMethod& from) {
    CopyFrom(from);
    return *this;
  }
  inline QuantizationMethod& operator=(QuantizationMethod&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const QuantizationMethod& default_instance() {
    return *internal_default_instance();
  }
  static inline const QuantizationMethod* internal_default_instance() {
    return reinterpret_cast<const QuantizationMethod*>(
        &_QuantizationMethod_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(QuantizationMethod& a, QuantizationMethod& b) { a.Swap(&b); }
  inline void Swap(QuantizationMethod* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QuantizationMethod* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  QuantizationMethod* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<QuantizationMethod>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const QuantizationMethod& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const QuantizationMethod& from) { QuantizationMethod::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(QuantizationMethod* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.QuantizationMethod"; }

 protected:
  explicit QuantizationMethod(::google::protobuf::Arena* arena);
  QuantizationMethod(::google::protobuf::Arena* arena, const QuantizationMethod& from);
  QuantizationMethod(::google::protobuf::Arena* arena, QuantizationMethod&& from) noexcept
      : QuantizationMethod(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using PresetMethod = QuantizationMethod_PresetMethod;
  static constexpr PresetMethod METHOD_UNSPECIFIED = QuantizationMethod_PresetMethod_METHOD_UNSPECIFIED;
  static constexpr PresetMethod METHOD_NO_QUANTIZE = QuantizationMethod_PresetMethod_METHOD_NO_QUANTIZE;
  static constexpr PresetMethod METHOD_STATIC_RANGE_INT8 = QuantizationMethod_PresetMethod_METHOD_STATIC_RANGE_INT8;
  static constexpr PresetMethod METHOD_DYNAMIC_RANGE_INT8 = QuantizationMethod_PresetMethod_METHOD_DYNAMIC_RANGE_INT8;
  static constexpr PresetMethod METHOD_STATIC_RANGE_WEIGHT_ONLY_INT8 = QuantizationMethod_PresetMethod_METHOD_STATIC_RANGE_WEIGHT_ONLY_INT8;
  static inline bool PresetMethod_IsValid(int value) {
    return QuantizationMethod_PresetMethod_IsValid(value);
  }
  static constexpr PresetMethod PresetMethod_MIN = QuantizationMethod_PresetMethod_PresetMethod_MIN;
  static constexpr PresetMethod PresetMethod_MAX = QuantizationMethod_PresetMethod_PresetMethod_MAX;
  static constexpr int PresetMethod_ARRAYSIZE = QuantizationMethod_PresetMethod_PresetMethod_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PresetMethod_descriptor() {
    return QuantizationMethod_PresetMethod_descriptor();
  }
  template <typename T>
  static inline const std::string& PresetMethod_Name(T value) {
    return QuantizationMethod_PresetMethod_Name(value);
  }
  static inline bool PresetMethod_Parse(absl::string_view name, PresetMethod* value) {
    return QuantizationMethod_PresetMethod_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kQuantizationComponentSpecsFieldNumber = 3,
    kPresetMethodFieldNumber = 4,
  };
  // repeated .tensorflow.quantization.QuantizationComponentSpec quantization_component_specs = 3;
  int quantization_component_specs_size() const;
  private:
  int _internal_quantization_component_specs_size() const;

  public:
  void clear_quantization_component_specs() ;
  ::tensorflow::quantization::QuantizationComponentSpec* mutable_quantization_component_specs(int index);
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>* mutable_quantization_component_specs();

  private:
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>& _internal_quantization_component_specs() const;
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>* _internal_mutable_quantization_component_specs();
  public:
  const ::tensorflow::quantization::QuantizationComponentSpec& quantization_component_specs(int index) const;
  ::tensorflow::quantization::QuantizationComponentSpec* add_quantization_component_specs();
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>& quantization_component_specs() const;
  // .tensorflow.quantization.QuantizationMethod.PresetMethod preset_method = 4;
  void clear_preset_method() ;
  ::tensorflow::quantization::QuantizationMethod_PresetMethod preset_method() const;
  void set_preset_method(::tensorflow::quantization::QuantizationMethod_PresetMethod value);

  private:
  ::tensorflow::quantization::QuantizationMethod_PresetMethod _internal_preset_method() const;
  void _internal_set_preset_method(::tensorflow::quantization::QuantizationMethod_PresetMethod value);

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.QuantizationMethod)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const QuantizationMethod& from_msg);
    ::google::protobuf::RepeatedPtrField< ::tensorflow::quantization::QuantizationComponentSpec > quantization_component_specs_;
    int preset_method_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT UnitWiseQuantizationSpec final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.UnitWiseQuantizationSpec) */ {
 public:
  inline UnitWiseQuantizationSpec() : UnitWiseQuantizationSpec(nullptr) {}
  ~UnitWiseQuantizationSpec() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR UnitWiseQuantizationSpec(
      ::google::protobuf::internal::ConstantInitialized);

  inline UnitWiseQuantizationSpec(const UnitWiseQuantizationSpec& from) : UnitWiseQuantizationSpec(nullptr, from) {}
  inline UnitWiseQuantizationSpec(UnitWiseQuantizationSpec&& from) noexcept
      : UnitWiseQuantizationSpec(nullptr, std::move(from)) {}
  inline UnitWiseQuantizationSpec& operator=(const UnitWiseQuantizationSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnitWiseQuantizationSpec& operator=(UnitWiseQuantizationSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UnitWiseQuantizationSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnitWiseQuantizationSpec* internal_default_instance() {
    return reinterpret_cast<const UnitWiseQuantizationSpec*>(
        &_UnitWiseQuantizationSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(UnitWiseQuantizationSpec& a, UnitWiseQuantizationSpec& b) { a.Swap(&b); }
  inline void Swap(UnitWiseQuantizationSpec* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UnitWiseQuantizationSpec* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UnitWiseQuantizationSpec* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<UnitWiseQuantizationSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const UnitWiseQuantizationSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const UnitWiseQuantizationSpec& from) { UnitWiseQuantizationSpec::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(UnitWiseQuantizationSpec* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.UnitWiseQuantizationSpec"; }

 protected:
  explicit UnitWiseQuantizationSpec(::google::protobuf::Arena* arena);
  UnitWiseQuantizationSpec(::google::protobuf::Arena* arena, const UnitWiseQuantizationSpec& from);
  UnitWiseQuantizationSpec(::google::protobuf::Arena* arena, UnitWiseQuantizationSpec&& from) noexcept
      : UnitWiseQuantizationSpec(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using QuantizationUnit = UnitWiseQuantizationSpec_QuantizationUnit;

  // accessors -------------------------------------------------------
  enum : int {
    kUnitFieldNumber = 5,
    kQuantizationMethodFieldNumber = 6,
  };
  // repeated .tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit unit = 5;
  int unit_size() const;
  private:
  int _internal_unit_size() const;

  public:
  void clear_unit() ;
  ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit* mutable_unit(int index);
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>* mutable_unit();

  private:
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>& _internal_unit() const;
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>* _internal_mutable_unit();
  public:
  const ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit& unit(int index) const;
  ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit* add_unit();
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>& unit() const;
  // .tensorflow.quantization.QuantizationMethod quantization_method = 6;
  bool has_quantization_method() const;
  void clear_quantization_method() ;
  const ::tensorflow::quantization::QuantizationMethod& quantization_method() const;
  PROTOBUF_NODISCARD ::tensorflow::quantization::QuantizationMethod* release_quantization_method();
  ::tensorflow::quantization::QuantizationMethod* mutable_quantization_method();
  void set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value);
  void unsafe_arena_set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value);
  ::tensorflow::quantization::QuantizationMethod* unsafe_arena_release_quantization_method();

  private:
  const ::tensorflow::quantization::QuantizationMethod& _internal_quantization_method() const;
  ::tensorflow::quantization::QuantizationMethod* _internal_mutable_quantization_method();

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.UnitWiseQuantizationSpec)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const UnitWiseQuantizationSpec& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit > unit_;
    ::tensorflow::quantization::QuantizationMethod* quantization_method_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT QuantizationOptions final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.QuantizationOptions) */ {
 public:
  inline QuantizationOptions() : QuantizationOptions(nullptr) {}
  ~QuantizationOptions() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR QuantizationOptions(
      ::google::protobuf::internal::ConstantInitialized);

  inline QuantizationOptions(const QuantizationOptions& from) : QuantizationOptions(nullptr, from) {}
  inline QuantizationOptions(QuantizationOptions&& from) noexcept
      : QuantizationOptions(nullptr, std::move(from)) {}
  inline QuantizationOptions& operator=(const QuantizationOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline QuantizationOptions& operator=(QuantizationOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const QuantizationOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const QuantizationOptions* internal_default_instance() {
    return reinterpret_cast<const QuantizationOptions*>(
        &_QuantizationOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(QuantizationOptions& a, QuantizationOptions& b) { a.Swap(&b); }
  inline void Swap(QuantizationOptions* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QuantizationOptions* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  QuantizationOptions* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<QuantizationOptions>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const QuantizationOptions& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const QuantizationOptions& from) { QuantizationOptions::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(QuantizationOptions* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.QuantizationOptions"; }

 protected:
  explicit QuantizationOptions(::google::protobuf::Arena* arena);
  QuantizationOptions(::google::protobuf::Arena* arena, const QuantizationOptions& from);
  QuantizationOptions(::google::protobuf::Arena* arena, QuantizationOptions&& from) noexcept
      : QuantizationOptions(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTagsFieldNumber = 5,
    kSignatureKeysFieldNumber = 6,
    kRepresentativeDatasetsFieldNumber = 7,
    kUnitWiseQuantizationSpecsFieldNumber = 17,
    kQuantizationMethodFieldNumber = 1,
    kCalibrationOptionsFieldNumber = 15,
    kDebuggerConfigFieldNumber = 16,
    kMinNumElementsForWeightsFieldNumber = 8,
    kOpSetFieldNumber = 2,
    kFreezeAllVariablesFieldNumber = 9,
    kEnablePerChannelQuantizationFieldNumber = 10,
    kEnableTwoInputTensorsFieldNumber = 11,
    kExperimentalEnableTpuModelSupportFieldNumber = 12,
    kEnableLegacyWeightOnlyFieldNumber = 13,
    kForceGraphModeCalibrationFieldNumber = 14,
  };
  // repeated string tags = 5;
  int tags_size() const;
  private:
  int _internal_tags_size() const;

  public:
  void clear_tags() ;
  const std::string& tags(int index) const;
  std::string* mutable_tags(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tags(int index, Arg_&& value, Args_... args);
  std::string* add_tags();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_tags(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& tags() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_tags();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_tags() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_tags();

  public:
  // repeated string signature_keys = 6;
  int signature_keys_size() const;
  private:
  int _internal_signature_keys_size() const;

  public:
  void clear_signature_keys() ;
  const std::string& signature_keys(int index) const;
  std::string* mutable_signature_keys(int index);
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_signature_keys(int index, Arg_&& value, Args_... args);
  std::string* add_signature_keys();
  template <typename Arg_ = const std::string&, typename... Args_>
  void add_signature_keys(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<std::string>& signature_keys() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_signature_keys();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_signature_keys() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_signature_keys();

  public:
  // map<string, .tensorflow.quantization.RepresentativeDatasetFile> representative_datasets = 7;
  int representative_datasets_size() const;
  private:
  int _internal_representative_datasets_size() const;

  public:
  void clear_representative_datasets() ;
  const ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>& representative_datasets() const;
  ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>* mutable_representative_datasets();

  private:
  const ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>& _internal_representative_datasets() const;
  ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>* _internal_mutable_representative_datasets();

  public:
  // repeated .tensorflow.quantization.UnitWiseQuantizationSpec unit_wise_quantization_specs = 17;
  int unit_wise_quantization_specs_size() const;
  private:
  int _internal_unit_wise_quantization_specs_size() const;

  public:
  void clear_unit_wise_quantization_specs() ;
  ::tensorflow::quantization::UnitWiseQuantizationSpec* mutable_unit_wise_quantization_specs(int index);
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>* mutable_unit_wise_quantization_specs();

  private:
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>& _internal_unit_wise_quantization_specs() const;
  ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>* _internal_mutable_unit_wise_quantization_specs();
  public:
  const ::tensorflow::quantization::UnitWiseQuantizationSpec& unit_wise_quantization_specs(int index) const;
  ::tensorflow::quantization::UnitWiseQuantizationSpec* add_unit_wise_quantization_specs();
  const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>& unit_wise_quantization_specs() const;
  // .tensorflow.quantization.QuantizationMethod quantization_method = 1;
  bool has_quantization_method() const;
  void clear_quantization_method() ;
  const ::tensorflow::quantization::QuantizationMethod& quantization_method() const;
  PROTOBUF_NODISCARD ::tensorflow::quantization::QuantizationMethod* release_quantization_method();
  ::tensorflow::quantization::QuantizationMethod* mutable_quantization_method();
  void set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value);
  void unsafe_arena_set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value);
  ::tensorflow::quantization::QuantizationMethod* unsafe_arena_release_quantization_method();

  private:
  const ::tensorflow::quantization::QuantizationMethod& _internal_quantization_method() const;
  ::tensorflow::quantization::QuantizationMethod* _internal_mutable_quantization_method();

  public:
  // .stablehlo.quantization.CalibrationOptions calibration_options = 15;
  bool has_calibration_options() const;
  void clear_calibration_options() ;
  const ::stablehlo::quantization::CalibrationOptions& calibration_options() const;
  PROTOBUF_NODISCARD ::stablehlo::quantization::CalibrationOptions* release_calibration_options();
  ::stablehlo::quantization::CalibrationOptions* mutable_calibration_options();
  void set_allocated_calibration_options(::stablehlo::quantization::CalibrationOptions* value);
  void unsafe_arena_set_allocated_calibration_options(::stablehlo::quantization::CalibrationOptions* value);
  ::stablehlo::quantization::CalibrationOptions* unsafe_arena_release_calibration_options();

  private:
  const ::stablehlo::quantization::CalibrationOptions& _internal_calibration_options() const;
  ::stablehlo::quantization::CalibrationOptions* _internal_mutable_calibration_options();

  public:
  // .stablehlo.quantization.DebuggerConfig debugger_config = 16;
  bool has_debugger_config() const;
  void clear_debugger_config() ;
  const ::stablehlo::quantization::DebuggerConfig& debugger_config() const;
  PROTOBUF_NODISCARD ::stablehlo::quantization::DebuggerConfig* release_debugger_config();
  ::stablehlo::quantization::DebuggerConfig* mutable_debugger_config();
  void set_allocated_debugger_config(::stablehlo::quantization::DebuggerConfig* value);
  void unsafe_arena_set_allocated_debugger_config(::stablehlo::quantization::DebuggerConfig* value);
  ::stablehlo::quantization::DebuggerConfig* unsafe_arena_release_debugger_config();

  private:
  const ::stablehlo::quantization::DebuggerConfig& _internal_debugger_config() const;
  ::stablehlo::quantization::DebuggerConfig* _internal_mutable_debugger_config();

  public:
  // int64 min_num_elements_for_weights = 8;
  void clear_min_num_elements_for_weights() ;
  ::int64_t min_num_elements_for_weights() const;
  void set_min_num_elements_for_weights(::int64_t value);

  private:
  ::int64_t _internal_min_num_elements_for_weights() const;
  void _internal_set_min_num_elements_for_weights(::int64_t value);

  public:
  // .tensorflow.quantization.OpSet op_set = 2;
  void clear_op_set() ;
  ::tensorflow::quantization::OpSet op_set() const;
  void set_op_set(::tensorflow::quantization::OpSet value);

  private:
  ::tensorflow::quantization::OpSet _internal_op_set() const;
  void _internal_set_op_set(::tensorflow::quantization::OpSet value);

  public:
  // optional bool freeze_all_variables = 9;
  bool has_freeze_all_variables() const;
  void clear_freeze_all_variables() ;
  bool freeze_all_variables() const;
  void set_freeze_all_variables(bool value);

  private:
  bool _internal_freeze_all_variables() const;
  void _internal_set_freeze_all_variables(bool value);

  public:
  // optional bool enable_per_channel_quantization = 10;
  bool has_enable_per_channel_quantization() const;
  void clear_enable_per_channel_quantization() ;
  bool enable_per_channel_quantization() const;
  void set_enable_per_channel_quantization(bool value);

  private:
  bool _internal_enable_per_channel_quantization() const;
  void _internal_set_enable_per_channel_quantization(bool value);

  public:
  // bool enable_two_input_tensors = 11;
  void clear_enable_two_input_tensors() ;
  bool enable_two_input_tensors() const;
  void set_enable_two_input_tensors(bool value);

  private:
  bool _internal_enable_two_input_tensors() const;
  void _internal_set_enable_two_input_tensors(bool value);

  public:
  // bool experimental_enable_tpu_model_support = 12;
  void clear_experimental_enable_tpu_model_support() ;
  bool experimental_enable_tpu_model_support() const;
  void set_experimental_enable_tpu_model_support(bool value);

  private:
  bool _internal_experimental_enable_tpu_model_support() const;
  void _internal_set_experimental_enable_tpu_model_support(bool value);

  public:
  // bool enable_legacy_weight_only = 13;
  void clear_enable_legacy_weight_only() ;
  bool enable_legacy_weight_only() const;
  void set_enable_legacy_weight_only(bool value);

  private:
  bool _internal_enable_legacy_weight_only() const;
  void _internal_set_enable_legacy_weight_only(bool value);

  public:
  // bool force_graph_mode_calibration = 14;
  void clear_force_graph_mode_calibration() ;
  bool force_graph_mode_calibration() const;
  void set_force_graph_mode_calibration(bool value);

  private:
  bool _internal_force_graph_mode_calibration() const;
  void _internal_set_force_graph_mode_calibration(bool value);

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.QuantizationOptions)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 15, 6,
      101, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const QuantizationOptions& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<std::string> tags_;
    ::google::protobuf::RepeatedPtrField<std::string> signature_keys_;
    ::google::protobuf::internal::MapField<QuantizationOptions_RepresentativeDatasetsEntry_DoNotUse, std::string, ::tensorflow::quantization::RepresentativeDatasetFile,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>
        representative_datasets_;
    ::google::protobuf::RepeatedPtrField< ::tensorflow::quantization::UnitWiseQuantizationSpec > unit_wise_quantization_specs_;
    ::tensorflow::quantization::QuantizationMethod* quantization_method_;
    ::stablehlo::quantization::CalibrationOptions* calibration_options_;
    ::stablehlo::quantization::DebuggerConfig* debugger_config_;
    ::int64_t min_num_elements_for_weights_;
    int op_set_;
    bool freeze_all_variables_;
    bool enable_per_channel_quantization_;
    bool enable_two_input_tensors_;
    bool experimental_enable_tpu_model_support_;
    bool enable_legacy_weight_only_;
    bool force_graph_mode_calibration_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<
          RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse, std::string, ::tensorflow::TensorProto,
          ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
          ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> {
 public:
  using SuperType = ::google::protobuf::internal::MapEntry<
      RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse, std::string, ::tensorflow::TensorProto,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>;
  RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse(::google::protobuf::Arena* arena);
  static const RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse* internal_default_instance() {
    return reinterpret_cast<const RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse*>(
        &_RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse_default_instance_);
  }


 private:
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      83, 2>
      _table_;

  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_EXPORT RepresentativeDataSample final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:tensorflow.quantization.RepresentativeDataSample) */ {
 public:
  inline RepresentativeDataSample() : RepresentativeDataSample(nullptr) {}
  ~RepresentativeDataSample() PROTOBUF_FINAL;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR RepresentativeDataSample(
      ::google::protobuf::internal::ConstantInitialized);

  inline RepresentativeDataSample(const RepresentativeDataSample& from) : RepresentativeDataSample(nullptr, from) {}
  inline RepresentativeDataSample(RepresentativeDataSample&& from) noexcept
      : RepresentativeDataSample(nullptr, std::move(from)) {}
  inline RepresentativeDataSample& operator=(const RepresentativeDataSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline RepresentativeDataSample& operator=(RepresentativeDataSample&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RepresentativeDataSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const RepresentativeDataSample* internal_default_instance() {
    return reinterpret_cast<const RepresentativeDataSample*>(
        &_RepresentativeDataSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(RepresentativeDataSample& a, RepresentativeDataSample& b) { a.Swap(&b); }
  inline void Swap(RepresentativeDataSample* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RepresentativeDataSample* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RepresentativeDataSample* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
    return ::google::protobuf::Message::DefaultConstruct<RepresentativeDataSample>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RepresentativeDataSample& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const RepresentativeDataSample& from) { RepresentativeDataSample::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RepresentativeDataSample* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "tensorflow.quantization.RepresentativeDataSample"; }

 protected:
  explicit RepresentativeDataSample(::google::protobuf::Arena* arena);
  RepresentativeDataSample(::google::protobuf::Arena* arena, const RepresentativeDataSample& from);
  RepresentativeDataSample(::google::protobuf::Arena* arena, RepresentativeDataSample&& from) noexcept
      : RepresentativeDataSample(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
  static const ::google::protobuf::Message::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTensorProtoInputsFieldNumber = 2,
  };
  // map<string, .tensorflow.TensorProto> tensor_proto_inputs = 2;
  int tensor_proto_inputs_size() const;
  private:
  int _internal_tensor_proto_inputs_size() const;

  public:
  void clear_tensor_proto_inputs() ;
  const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& tensor_proto_inputs() const;
  ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>* mutable_tensor_proto_inputs();

  private:
  const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& _internal_tensor_proto_inputs() const;
  ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>* _internal_mutable_tensor_proto_inputs();

  public:
  // @@protoc_insertion_point(class_scope:tensorflow.quantization.RepresentativeDataSample)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 2,
      76, 2>
      _table_;


  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const RepresentativeDataSample& from_msg);
    ::google::protobuf::internal::MapField<RepresentativeDataSample_TensorProtoInputsEntry_DoNotUse, std::string, ::tensorflow::TensorProto,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>
        tensor_proto_inputs_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto;
};

// ===================================================================




// ===================================================================


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// QuantizationMethod

// .tensorflow.quantization.QuantizationMethod.PresetMethod preset_method = 4;
inline void QuantizationMethod::clear_preset_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preset_method_ = 0;
}
inline ::tensorflow::quantization::QuantizationMethod_PresetMethod QuantizationMethod::preset_method() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationMethod.preset_method)
  return _internal_preset_method();
}
inline void QuantizationMethod::set_preset_method(::tensorflow::quantization::QuantizationMethod_PresetMethod value) {
  _internal_set_preset_method(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationMethod.preset_method)
}
inline ::tensorflow::quantization::QuantizationMethod_PresetMethod QuantizationMethod::_internal_preset_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::tensorflow::quantization::QuantizationMethod_PresetMethod>(_impl_.preset_method_);
}
inline void QuantizationMethod::_internal_set_preset_method(::tensorflow::quantization::QuantizationMethod_PresetMethod value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preset_method_ = value;
}

// repeated .tensorflow.quantization.QuantizationComponentSpec quantization_component_specs = 3;
inline int QuantizationMethod::_internal_quantization_component_specs_size() const {
  return _internal_quantization_component_specs().size();
}
inline int QuantizationMethod::quantization_component_specs_size() const {
  return _internal_quantization_component_specs_size();
}
inline void QuantizationMethod::clear_quantization_component_specs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quantization_component_specs_.Clear();
}
inline ::tensorflow::quantization::QuantizationComponentSpec* QuantizationMethod::mutable_quantization_component_specs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationMethod.quantization_component_specs)
  return _internal_mutable_quantization_component_specs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>* QuantizationMethod::mutable_quantization_component_specs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.quantization.QuantizationMethod.quantization_component_specs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_quantization_component_specs();
}
inline const ::tensorflow::quantization::QuantizationComponentSpec& QuantizationMethod::quantization_component_specs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationMethod.quantization_component_specs)
  return _internal_quantization_component_specs().Get(index);
}
inline ::tensorflow::quantization::QuantizationComponentSpec* QuantizationMethod::add_quantization_component_specs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::tensorflow::quantization::QuantizationComponentSpec* _add = _internal_mutable_quantization_component_specs()->Add();
  // @@protoc_insertion_point(field_add:tensorflow.quantization.QuantizationMethod.quantization_component_specs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>& QuantizationMethod::quantization_component_specs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:tensorflow.quantization.QuantizationMethod.quantization_component_specs)
  return _internal_quantization_component_specs();
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>&
QuantizationMethod::_internal_quantization_component_specs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.quantization_component_specs_;
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::QuantizationComponentSpec>*
QuantizationMethod::_internal_mutable_quantization_component_specs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.quantization_component_specs_;
}

// -------------------------------------------------------------------

// QuantizationComponentSpec

// .tensorflow.quantization.QuantizationComponentSpec.QuantizationComponent quantization_component = 1;
inline void QuantizationComponentSpec::clear_quantization_component() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quantization_component_ = 0;
}
inline ::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent QuantizationComponentSpec::quantization_component() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationComponentSpec.quantization_component)
  return _internal_quantization_component();
}
inline void QuantizationComponentSpec::set_quantization_component(::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent value) {
  _internal_set_quantization_component(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationComponentSpec.quantization_component)
}
inline ::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent QuantizationComponentSpec::_internal_quantization_component() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent>(_impl_.quantization_component_);
}
inline void QuantizationComponentSpec::_internal_set_quantization_component(::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quantization_component_ = value;
}

// .tensorflow.quantization.QuantizationComponentSpec.TensorType tensor_type = 2;
inline void QuantizationComponentSpec::clear_tensor_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_type_ = 0;
}
inline ::tensorflow::quantization::QuantizationComponentSpec_TensorType QuantizationComponentSpec::tensor_type() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationComponentSpec.tensor_type)
  return _internal_tensor_type();
}
inline void QuantizationComponentSpec::set_tensor_type(::tensorflow::quantization::QuantizationComponentSpec_TensorType value) {
  _internal_set_tensor_type(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationComponentSpec.tensor_type)
}
inline ::tensorflow::quantization::QuantizationComponentSpec_TensorType QuantizationComponentSpec::_internal_tensor_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::tensorflow::quantization::QuantizationComponentSpec_TensorType>(_impl_.tensor_type_);
}
inline void QuantizationComponentSpec::_internal_set_tensor_type(::tensorflow::quantization::QuantizationComponentSpec_TensorType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_type_ = value;
}

// -------------------------------------------------------------------

// UnitWiseQuantizationSpec_QuantizationUnit

// string op_type = 1;
inline void UnitWiseQuantizationSpec_QuantizationUnit::clear_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.ClearToEmpty();
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::op_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.op_type)
  return _internal_op_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void UnitWiseQuantizationSpec_QuantizationUnit::set_op_type(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.op_type)
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::mutable_op_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_op_type();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.op_type)
  return _s;
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::_internal_op_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.op_type_.Get();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::_internal_set_op_type(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.Set(value, GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::_internal_mutable_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.op_type_.Mutable( GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::release_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.op_type)
  return _impl_.op_type_.Release();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::set_allocated_op_type(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.op_type_.IsDefault()) {
          _impl_.op_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.op_type)
}

// string node_name = 2;
inline void UnitWiseQuantizationSpec_QuantizationUnit::clear_node_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_name_.ClearToEmpty();
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::node_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.node_name)
  return _internal_node_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void UnitWiseQuantizationSpec_QuantizationUnit::set_node_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.node_name)
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::mutable_node_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_node_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.node_name)
  return _s;
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::_internal_node_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_name_.Get();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::_internal_set_node_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_name_.Set(value, GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::_internal_mutable_node_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_name_.Mutable( GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::release_node_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.node_name)
  return _impl_.node_name_.Release();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::set_allocated_node_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.node_name_.IsDefault()) {
          _impl_.node_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.node_name)
}

// string func_name = 3;
inline void UnitWiseQuantizationSpec_QuantizationUnit::clear_func_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.func_name_.ClearToEmpty();
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::func_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.func_name)
  return _internal_func_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void UnitWiseQuantizationSpec_QuantizationUnit::set_func_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.func_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.func_name)
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::mutable_func_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_func_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.func_name)
  return _s;
}
inline const std::string& UnitWiseQuantizationSpec_QuantizationUnit::_internal_func_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.func_name_.Get();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::_internal_set_func_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.func_name_.Set(value, GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::_internal_mutable_func_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.func_name_.Mutable( GetArena());
}
inline std::string* UnitWiseQuantizationSpec_QuantizationUnit::release_func_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.func_name)
  return _impl_.func_name_.Release();
}
inline void UnitWiseQuantizationSpec_QuantizationUnit::set_allocated_func_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.func_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.func_name_.IsDefault()) {
          _impl_.func_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit.func_name)
}

// -------------------------------------------------------------------

// UnitWiseQuantizationSpec

// repeated .tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit unit = 5;
inline int UnitWiseQuantizationSpec::_internal_unit_size() const {
  return _internal_unit().size();
}
inline int UnitWiseQuantizationSpec::unit_size() const {
  return _internal_unit_size();
}
inline void UnitWiseQuantizationSpec::clear_unit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unit_.Clear();
}
inline ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit* UnitWiseQuantizationSpec::mutable_unit(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.UnitWiseQuantizationSpec.unit)
  return _internal_mutable_unit()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>* UnitWiseQuantizationSpec::mutable_unit()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.quantization.UnitWiseQuantizationSpec.unit)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_unit();
}
inline const ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit& UnitWiseQuantizationSpec::unit(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.UnitWiseQuantizationSpec.unit)
  return _internal_unit().Get(index);
}
inline ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit* UnitWiseQuantizationSpec::add_unit() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit* _add = _internal_mutable_unit()->Add();
  // @@protoc_insertion_point(field_add:tensorflow.quantization.UnitWiseQuantizationSpec.unit)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>& UnitWiseQuantizationSpec::unit() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:tensorflow.quantization.UnitWiseQuantizationSpec.unit)
  return _internal_unit();
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>&
UnitWiseQuantizationSpec::_internal_unit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.unit_;
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec_QuantizationUnit>*
UnitWiseQuantizationSpec::_internal_mutable_unit() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.unit_;
}

// .tensorflow.quantization.QuantizationMethod quantization_method = 6;
inline bool UnitWiseQuantizationSpec::has_quantization_method() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quantization_method_ != nullptr);
  return value;
}
inline void UnitWiseQuantizationSpec::clear_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_method_ != nullptr) _impl_.quantization_method_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::tensorflow::quantization::QuantizationMethod& UnitWiseQuantizationSpec::_internal_quantization_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::tensorflow::quantization::QuantizationMethod* p = _impl_.quantization_method_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::quantization::QuantizationMethod&>(::tensorflow::quantization::_QuantizationMethod_default_instance_);
}
inline const ::tensorflow::quantization::QuantizationMethod& UnitWiseQuantizationSpec::quantization_method() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.UnitWiseQuantizationSpec.quantization_method)
  return _internal_quantization_method();
}
inline void UnitWiseQuantizationSpec::unsafe_arena_set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quantization_method_);
  }
  _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.quantization.UnitWiseQuantizationSpec.quantization_method)
}
inline ::tensorflow::quantization::QuantizationMethod* UnitWiseQuantizationSpec::release_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* released = _impl_.quantization_method_;
  _impl_.quantization_method_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::tensorflow::quantization::QuantizationMethod* UnitWiseQuantizationSpec::unsafe_arena_release_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.UnitWiseQuantizationSpec.quantization_method)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* temp = _impl_.quantization_method_;
  _impl_.quantization_method_ = nullptr;
  return temp;
}
inline ::tensorflow::quantization::QuantizationMethod* UnitWiseQuantizationSpec::_internal_mutable_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_method_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::tensorflow::quantization::QuantizationMethod>(GetArena());
    _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(p);
  }
  return _impl_.quantization_method_;
}
inline ::tensorflow::quantization::QuantizationMethod* UnitWiseQuantizationSpec::mutable_quantization_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* _msg = _internal_mutable_quantization_method();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.UnitWiseQuantizationSpec.quantization_method)
  return _msg;
}
inline void UnitWiseQuantizationSpec::set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.quantization_method_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(value);
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.UnitWiseQuantizationSpec.quantization_method)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// RepresentativeDataSample

// map<string, .tensorflow.TensorProto> tensor_proto_inputs = 2;
inline int RepresentativeDataSample::_internal_tensor_proto_inputs_size() const {
  return _internal_tensor_proto_inputs().size();
}
inline int RepresentativeDataSample::tensor_proto_inputs_size() const {
  return _internal_tensor_proto_inputs_size();
}
inline const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& RepresentativeDataSample::_internal_tensor_proto_inputs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tensor_proto_inputs_.GetMap();
}
inline const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& RepresentativeDataSample::tensor_proto_inputs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:tensorflow.quantization.RepresentativeDataSample.tensor_proto_inputs)
  return _internal_tensor_proto_inputs();
}
inline ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>* RepresentativeDataSample::_internal_mutable_tensor_proto_inputs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tensor_proto_inputs_.MutableMap();
}
inline ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>* RepresentativeDataSample::mutable_tensor_proto_inputs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.quantization.RepresentativeDataSample.tensor_proto_inputs)
  return _internal_mutable_tensor_proto_inputs();
}

// -------------------------------------------------------------------

// RepresentativeDatasetFile

// string tfrecord_file_path = 1;
inline bool RepresentativeDatasetFile::has_tfrecord_file_path() const {
  return dataset_file_case() == kTfrecordFilePath;
}
inline void RepresentativeDatasetFile::set_has_tfrecord_file_path() {
  _impl_._oneof_case_[0] = kTfrecordFilePath;
}
inline void RepresentativeDatasetFile::clear_tfrecord_file_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dataset_file_case() == kTfrecordFilePath) {
    _impl_.dataset_file_.tfrecord_file_path_.Destroy();
    clear_has_dataset_file();
  }
}
inline const std::string& RepresentativeDatasetFile::tfrecord_file_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.RepresentativeDatasetFile.tfrecord_file_path)
  return _internal_tfrecord_file_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RepresentativeDatasetFile::set_tfrecord_file_path(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dataset_file_case() != kTfrecordFilePath) {
    clear_dataset_file();

    set_has_tfrecord_file_path();
    _impl_.dataset_file_.tfrecord_file_path_.InitDefault();
  }
  _impl_.dataset_file_.tfrecord_file_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:tensorflow.quantization.RepresentativeDatasetFile.tfrecord_file_path)
}
inline std::string* RepresentativeDatasetFile::mutable_tfrecord_file_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tfrecord_file_path();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.RepresentativeDatasetFile.tfrecord_file_path)
  return _s;
}
inline const std::string& RepresentativeDatasetFile::_internal_tfrecord_file_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (dataset_file_case() != kTfrecordFilePath) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.dataset_file_.tfrecord_file_path_.Get();
}
inline void RepresentativeDatasetFile::_internal_set_tfrecord_file_path(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dataset_file_case() != kTfrecordFilePath) {
    clear_dataset_file();

    set_has_tfrecord_file_path();
    _impl_.dataset_file_.tfrecord_file_path_.InitDefault();
  }
  _impl_.dataset_file_.tfrecord_file_path_.Set(value, GetArena());
}
inline std::string* RepresentativeDatasetFile::_internal_mutable_tfrecord_file_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dataset_file_case() != kTfrecordFilePath) {
    clear_dataset_file();

    set_has_tfrecord_file_path();
    _impl_.dataset_file_.tfrecord_file_path_.InitDefault();
  }
  return _impl_.dataset_file_.tfrecord_file_path_.Mutable( GetArena());
}
inline std::string* RepresentativeDatasetFile::release_tfrecord_file_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.RepresentativeDatasetFile.tfrecord_file_path)
  if (dataset_file_case() != kTfrecordFilePath) {
    return nullptr;
  }
  clear_has_dataset_file();
  return _impl_.dataset_file_.tfrecord_file_path_.Release();
}
inline void RepresentativeDatasetFile::set_allocated_tfrecord_file_path(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_dataset_file()) {
    clear_dataset_file();
  }
  if (value != nullptr) {
    set_has_tfrecord_file_path();
    _impl_.dataset_file_.tfrecord_file_path_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.RepresentativeDatasetFile.tfrecord_file_path)
}

inline bool RepresentativeDatasetFile::has_dataset_file() const {
  return dataset_file_case() != DATASET_FILE_NOT_SET;
}
inline void RepresentativeDatasetFile::clear_has_dataset_file() {
  _impl_._oneof_case_[0] = DATASET_FILE_NOT_SET;
}
inline RepresentativeDatasetFile::DatasetFileCase RepresentativeDatasetFile::dataset_file_case() const {
  return RepresentativeDatasetFile::DatasetFileCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// QuantizationOptions

// .tensorflow.quantization.QuantizationMethod quantization_method = 1;
inline bool QuantizationOptions::has_quantization_method() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quantization_method_ != nullptr);
  return value;
}
inline void QuantizationOptions::clear_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_method_ != nullptr) _impl_.quantization_method_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::tensorflow::quantization::QuantizationMethod& QuantizationOptions::_internal_quantization_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::tensorflow::quantization::QuantizationMethod* p = _impl_.quantization_method_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::quantization::QuantizationMethod&>(::tensorflow::quantization::_QuantizationMethod_default_instance_);
}
inline const ::tensorflow::quantization::QuantizationMethod& QuantizationOptions::quantization_method() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.quantization_method)
  return _internal_quantization_method();
}
inline void QuantizationOptions::unsafe_arena_set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quantization_method_);
  }
  _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.quantization.QuantizationOptions.quantization_method)
}
inline ::tensorflow::quantization::QuantizationMethod* QuantizationOptions::release_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* released = _impl_.quantization_method_;
  _impl_.quantization_method_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::tensorflow::quantization::QuantizationMethod* QuantizationOptions::unsafe_arena_release_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.QuantizationOptions.quantization_method)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* temp = _impl_.quantization_method_;
  _impl_.quantization_method_ = nullptr;
  return temp;
}
inline ::tensorflow::quantization::QuantizationMethod* QuantizationOptions::_internal_mutable_quantization_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quantization_method_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::tensorflow::quantization::QuantizationMethod>(GetArena());
    _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(p);
  }
  return _impl_.quantization_method_;
}
inline ::tensorflow::quantization::QuantizationMethod* QuantizationOptions::mutable_quantization_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::tensorflow::quantization::QuantizationMethod* _msg = _internal_mutable_quantization_method();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.quantization_method)
  return _msg;
}
inline void QuantizationOptions::set_allocated_quantization_method(::tensorflow::quantization::QuantizationMethod* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.quantization_method_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.quantization_method_ = reinterpret_cast<::tensorflow::quantization::QuantizationMethod*>(value);
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.QuantizationOptions.quantization_method)
}

// .tensorflow.quantization.OpSet op_set = 2;
inline void QuantizationOptions::clear_op_set() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_set_ = 0;
}
inline ::tensorflow::quantization::OpSet QuantizationOptions::op_set() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.op_set)
  return _internal_op_set();
}
inline void QuantizationOptions::set_op_set(::tensorflow::quantization::OpSet value) {
  _internal_set_op_set(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.op_set)
}
inline ::tensorflow::quantization::OpSet QuantizationOptions::_internal_op_set() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::tensorflow::quantization::OpSet>(_impl_.op_set_);
}
inline void QuantizationOptions::_internal_set_op_set(::tensorflow::quantization::OpSet value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_set_ = value;
}

// repeated .tensorflow.quantization.UnitWiseQuantizationSpec unit_wise_quantization_specs = 17;
inline int QuantizationOptions::_internal_unit_wise_quantization_specs_size() const {
  return _internal_unit_wise_quantization_specs().size();
}
inline int QuantizationOptions::unit_wise_quantization_specs_size() const {
  return _internal_unit_wise_quantization_specs_size();
}
inline void QuantizationOptions::clear_unit_wise_quantization_specs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unit_wise_quantization_specs_.Clear();
}
inline ::tensorflow::quantization::UnitWiseQuantizationSpec* QuantizationOptions::mutable_unit_wise_quantization_specs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.unit_wise_quantization_specs)
  return _internal_mutable_unit_wise_quantization_specs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>* QuantizationOptions::mutable_unit_wise_quantization_specs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.quantization.QuantizationOptions.unit_wise_quantization_specs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_unit_wise_quantization_specs();
}
inline const ::tensorflow::quantization::UnitWiseQuantizationSpec& QuantizationOptions::unit_wise_quantization_specs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.unit_wise_quantization_specs)
  return _internal_unit_wise_quantization_specs().Get(index);
}
inline ::tensorflow::quantization::UnitWiseQuantizationSpec* QuantizationOptions::add_unit_wise_quantization_specs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::tensorflow::quantization::UnitWiseQuantizationSpec* _add = _internal_mutable_unit_wise_quantization_specs()->Add();
  // @@protoc_insertion_point(field_add:tensorflow.quantization.QuantizationOptions.unit_wise_quantization_specs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>& QuantizationOptions::unit_wise_quantization_specs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:tensorflow.quantization.QuantizationOptions.unit_wise_quantization_specs)
  return _internal_unit_wise_quantization_specs();
}
inline const ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>&
QuantizationOptions::_internal_unit_wise_quantization_specs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.unit_wise_quantization_specs_;
}
inline ::google::protobuf::RepeatedPtrField<::tensorflow::quantization::UnitWiseQuantizationSpec>*
QuantizationOptions::_internal_mutable_unit_wise_quantization_specs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.unit_wise_quantization_specs_;
}

// repeated string tags = 5;
inline int QuantizationOptions::_internal_tags_size() const {
  return _internal_tags().size();
}
inline int QuantizationOptions::tags_size() const {
  return _internal_tags_size();
}
inline void QuantizationOptions::clear_tags() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tags_.Clear();
}
inline std::string* QuantizationOptions::add_tags() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_tags()->Add();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.quantization.QuantizationOptions.tags)
  return _s;
}
inline const std::string& QuantizationOptions::tags(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.tags)
  return _internal_tags().Get(index);
}
inline std::string* QuantizationOptions::mutable_tags(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.tags)
  return _internal_mutable_tags()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void QuantizationOptions::set_tags(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_tags()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.tags)
}
template <typename Arg_, typename... Args_>
inline void QuantizationOptions::add_tags(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_tags(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:tensorflow.quantization.QuantizationOptions.tags)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
QuantizationOptions::tags() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:tensorflow.quantization.QuantizationOptions.tags)
  return _internal_tags();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
QuantizationOptions::mutable_tags() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.quantization.QuantizationOptions.tags)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_tags();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
QuantizationOptions::_internal_tags() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tags_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
QuantizationOptions::_internal_mutable_tags() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.tags_;
}

// repeated string signature_keys = 6;
inline int QuantizationOptions::_internal_signature_keys_size() const {
  return _internal_signature_keys().size();
}
inline int QuantizationOptions::signature_keys_size() const {
  return _internal_signature_keys_size();
}
inline void QuantizationOptions::clear_signature_keys() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.signature_keys_.Clear();
}
inline std::string* QuantizationOptions::add_signature_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  std::string* _s = _internal_mutable_signature_keys()->Add();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.quantization.QuantizationOptions.signature_keys)
  return _s;
}
inline const std::string& QuantizationOptions::signature_keys(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.signature_keys)
  return _internal_signature_keys().Get(index);
}
inline std::string* QuantizationOptions::mutable_signature_keys(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.signature_keys)
  return _internal_mutable_signature_keys()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void QuantizationOptions::set_signature_keys(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_signature_keys()->Mutable(index),
      std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.signature_keys)
}
template <typename Arg_, typename... Args_>
inline void QuantizationOptions::add_signature_keys(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_signature_keys(),
                               std::forward<Arg_>(value),
                               args... );
  // @@protoc_insertion_point(field_add:tensorflow.quantization.QuantizationOptions.signature_keys)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
QuantizationOptions::signature_keys() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:tensorflow.quantization.QuantizationOptions.signature_keys)
  return _internal_signature_keys();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
QuantizationOptions::mutable_signature_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.quantization.QuantizationOptions.signature_keys)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_signature_keys();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
QuantizationOptions::_internal_signature_keys() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.signature_keys_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
QuantizationOptions::_internal_mutable_signature_keys() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.signature_keys_;
}

// map<string, .tensorflow.quantization.RepresentativeDatasetFile> representative_datasets = 7;
inline int QuantizationOptions::_internal_representative_datasets_size() const {
  return _internal_representative_datasets().size();
}
inline int QuantizationOptions::representative_datasets_size() const {
  return _internal_representative_datasets_size();
}
inline void QuantizationOptions::clear_representative_datasets() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.representative_datasets_.Clear();
}
inline const ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>& QuantizationOptions::_internal_representative_datasets() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.representative_datasets_.GetMap();
}
inline const ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>& QuantizationOptions::representative_datasets() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:tensorflow.quantization.QuantizationOptions.representative_datasets)
  return _internal_representative_datasets();
}
inline ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>* QuantizationOptions::_internal_mutable_representative_datasets() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.representative_datasets_.MutableMap();
}
inline ::google::protobuf::Map<std::string, ::tensorflow::quantization::RepresentativeDatasetFile>* QuantizationOptions::mutable_representative_datasets() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.quantization.QuantizationOptions.representative_datasets)
  return _internal_mutable_representative_datasets();
}

// int64 min_num_elements_for_weights = 8;
inline void QuantizationOptions::clear_min_num_elements_for_weights() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.min_num_elements_for_weights_ = ::int64_t{0};
}
inline ::int64_t QuantizationOptions::min_num_elements_for_weights() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.min_num_elements_for_weights)
  return _internal_min_num_elements_for_weights();
}
inline void QuantizationOptions::set_min_num_elements_for_weights(::int64_t value) {
  _internal_set_min_num_elements_for_weights(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.min_num_elements_for_weights)
}
inline ::int64_t QuantizationOptions::_internal_min_num_elements_for_weights() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.min_num_elements_for_weights_;
}
inline void QuantizationOptions::_internal_set_min_num_elements_for_weights(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.min_num_elements_for_weights_ = value;
}

// optional bool freeze_all_variables = 9;
inline bool QuantizationOptions::has_freeze_all_variables() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void QuantizationOptions::clear_freeze_all_variables() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.freeze_all_variables_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool QuantizationOptions::freeze_all_variables() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.freeze_all_variables)
  return _internal_freeze_all_variables();
}
inline void QuantizationOptions::set_freeze_all_variables(bool value) {
  _internal_set_freeze_all_variables(value);
  _impl_._has_bits_[0] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.freeze_all_variables)
}
inline bool QuantizationOptions::_internal_freeze_all_variables() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.freeze_all_variables_;
}
inline void QuantizationOptions::_internal_set_freeze_all_variables(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.freeze_all_variables_ = value;
}

// optional bool enable_per_channel_quantization = 10;
inline bool QuantizationOptions::has_enable_per_channel_quantization() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void QuantizationOptions::clear_enable_per_channel_quantization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_per_channel_quantization_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool QuantizationOptions::enable_per_channel_quantization() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.enable_per_channel_quantization)
  return _internal_enable_per_channel_quantization();
}
inline void QuantizationOptions::set_enable_per_channel_quantization(bool value) {
  _internal_set_enable_per_channel_quantization(value);
  _impl_._has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.enable_per_channel_quantization)
}
inline bool QuantizationOptions::_internal_enable_per_channel_quantization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_per_channel_quantization_;
}
inline void QuantizationOptions::_internal_set_enable_per_channel_quantization(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_per_channel_quantization_ = value;
}

// bool enable_two_input_tensors = 11;
inline void QuantizationOptions::clear_enable_two_input_tensors() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_two_input_tensors_ = false;
}
inline bool QuantizationOptions::enable_two_input_tensors() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.enable_two_input_tensors)
  return _internal_enable_two_input_tensors();
}
inline void QuantizationOptions::set_enable_two_input_tensors(bool value) {
  _internal_set_enable_two_input_tensors(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.enable_two_input_tensors)
}
inline bool QuantizationOptions::_internal_enable_two_input_tensors() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_two_input_tensors_;
}
inline void QuantizationOptions::_internal_set_enable_two_input_tensors(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_two_input_tensors_ = value;
}

// bool experimental_enable_tpu_model_support = 12;
inline void QuantizationOptions::clear_experimental_enable_tpu_model_support() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.experimental_enable_tpu_model_support_ = false;
}
inline bool QuantizationOptions::experimental_enable_tpu_model_support() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.experimental_enable_tpu_model_support)
  return _internal_experimental_enable_tpu_model_support();
}
inline void QuantizationOptions::set_experimental_enable_tpu_model_support(bool value) {
  _internal_set_experimental_enable_tpu_model_support(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.experimental_enable_tpu_model_support)
}
inline bool QuantizationOptions::_internal_experimental_enable_tpu_model_support() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.experimental_enable_tpu_model_support_;
}
inline void QuantizationOptions::_internal_set_experimental_enable_tpu_model_support(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.experimental_enable_tpu_model_support_ = value;
}

// bool enable_legacy_weight_only = 13;
inline void QuantizationOptions::clear_enable_legacy_weight_only() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_legacy_weight_only_ = false;
}
inline bool QuantizationOptions::enable_legacy_weight_only() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.enable_legacy_weight_only)
  return _internal_enable_legacy_weight_only();
}
inline void QuantizationOptions::set_enable_legacy_weight_only(bool value) {
  _internal_set_enable_legacy_weight_only(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.enable_legacy_weight_only)
}
inline bool QuantizationOptions::_internal_enable_legacy_weight_only() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_legacy_weight_only_;
}
inline void QuantizationOptions::_internal_set_enable_legacy_weight_only(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_legacy_weight_only_ = value;
}

// bool force_graph_mode_calibration = 14;
inline void QuantizationOptions::clear_force_graph_mode_calibration() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.force_graph_mode_calibration_ = false;
}
inline bool QuantizationOptions::force_graph_mode_calibration() const {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.force_graph_mode_calibration)
  return _internal_force_graph_mode_calibration();
}
inline void QuantizationOptions::set_force_graph_mode_calibration(bool value) {
  _internal_set_force_graph_mode_calibration(value);
  // @@protoc_insertion_point(field_set:tensorflow.quantization.QuantizationOptions.force_graph_mode_calibration)
}
inline bool QuantizationOptions::_internal_force_graph_mode_calibration() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.force_graph_mode_calibration_;
}
inline void QuantizationOptions::_internal_set_force_graph_mode_calibration(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.force_graph_mode_calibration_ = value;
}

// .stablehlo.quantization.CalibrationOptions calibration_options = 15;
inline bool QuantizationOptions::has_calibration_options() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.calibration_options_ != nullptr);
  return value;
}
inline const ::stablehlo::quantization::CalibrationOptions& QuantizationOptions::_internal_calibration_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::stablehlo::quantization::CalibrationOptions* p = _impl_.calibration_options_;
  return p != nullptr ? *p : reinterpret_cast<const ::stablehlo::quantization::CalibrationOptions&>(::stablehlo::quantization::_CalibrationOptions_default_instance_);
}
inline const ::stablehlo::quantization::CalibrationOptions& QuantizationOptions::calibration_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.calibration_options)
  return _internal_calibration_options();
}
inline void QuantizationOptions::unsafe_arena_set_allocated_calibration_options(::stablehlo::quantization::CalibrationOptions* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.calibration_options_);
  }
  _impl_.calibration_options_ = reinterpret_cast<::stablehlo::quantization::CalibrationOptions*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.quantization.QuantizationOptions.calibration_options)
}
inline ::stablehlo::quantization::CalibrationOptions* QuantizationOptions::release_calibration_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::stablehlo::quantization::CalibrationOptions* released = _impl_.calibration_options_;
  _impl_.calibration_options_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::stablehlo::quantization::CalibrationOptions* QuantizationOptions::unsafe_arena_release_calibration_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.QuantizationOptions.calibration_options)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::stablehlo::quantization::CalibrationOptions* temp = _impl_.calibration_options_;
  _impl_.calibration_options_ = nullptr;
  return temp;
}
inline ::stablehlo::quantization::CalibrationOptions* QuantizationOptions::_internal_mutable_calibration_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.calibration_options_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::stablehlo::quantization::CalibrationOptions>(GetArena());
    _impl_.calibration_options_ = reinterpret_cast<::stablehlo::quantization::CalibrationOptions*>(p);
  }
  return _impl_.calibration_options_;
}
inline ::stablehlo::quantization::CalibrationOptions* QuantizationOptions::mutable_calibration_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::stablehlo::quantization::CalibrationOptions* _msg = _internal_mutable_calibration_options();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.calibration_options)
  return _msg;
}
inline void QuantizationOptions::set_allocated_calibration_options(::stablehlo::quantization::CalibrationOptions* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.calibration_options_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.calibration_options_ = reinterpret_cast<::stablehlo::quantization::CalibrationOptions*>(value);
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.QuantizationOptions.calibration_options)
}

// .stablehlo.quantization.DebuggerConfig debugger_config = 16;
inline bool QuantizationOptions::has_debugger_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.debugger_config_ != nullptr);
  return value;
}
inline const ::stablehlo::quantization::DebuggerConfig& QuantizationOptions::_internal_debugger_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::stablehlo::quantization::DebuggerConfig* p = _impl_.debugger_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::stablehlo::quantization::DebuggerConfig&>(::stablehlo::quantization::_DebuggerConfig_default_instance_);
}
inline const ::stablehlo::quantization::DebuggerConfig& QuantizationOptions::debugger_config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:tensorflow.quantization.QuantizationOptions.debugger_config)
  return _internal_debugger_config();
}
inline void QuantizationOptions::unsafe_arena_set_allocated_debugger_config(::stablehlo::quantization::DebuggerConfig* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.debugger_config_);
  }
  _impl_.debugger_config_ = reinterpret_cast<::stablehlo::quantization::DebuggerConfig*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.quantization.QuantizationOptions.debugger_config)
}
inline ::stablehlo::quantization::DebuggerConfig* QuantizationOptions::release_debugger_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::stablehlo::quantization::DebuggerConfig* released = _impl_.debugger_config_;
  _impl_.debugger_config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::stablehlo::quantization::DebuggerConfig* QuantizationOptions::unsafe_arena_release_debugger_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:tensorflow.quantization.QuantizationOptions.debugger_config)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::stablehlo::quantization::DebuggerConfig* temp = _impl_.debugger_config_;
  _impl_.debugger_config_ = nullptr;
  return temp;
}
inline ::stablehlo::quantization::DebuggerConfig* QuantizationOptions::_internal_mutable_debugger_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.debugger_config_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::stablehlo::quantization::DebuggerConfig>(GetArena());
    _impl_.debugger_config_ = reinterpret_cast<::stablehlo::quantization::DebuggerConfig*>(p);
  }
  return _impl_.debugger_config_;
}
inline ::stablehlo::quantization::DebuggerConfig* QuantizationOptions::mutable_debugger_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000004u;
  ::stablehlo::quantization::DebuggerConfig* _msg = _internal_mutable_debugger_config();
  // @@protoc_insertion_point(field_mutable:tensorflow.quantization.QuantizationOptions.debugger_config)
  return _msg;
}
inline void QuantizationOptions::set_allocated_debugger_config(::stablehlo::quantization::DebuggerConfig* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.debugger_config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.debugger_config_ = reinterpret_cast<::stablehlo::quantization::DebuggerConfig*>(value);
  // @@protoc_insertion_point(field_set_allocated:tensorflow.quantization.QuantizationOptions.debugger_config)
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace quantization
}  // namespace tensorflow


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::tensorflow::quantization::QuantizationMethod_PresetMethod> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::tensorflow::quantization::QuantizationMethod_PresetMethod>() {
  return ::tensorflow::quantization::QuantizationMethod_PresetMethod_descriptor();
}
template <>
struct is_proto_enum<::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent>() {
  return ::tensorflow::quantization::QuantizationComponentSpec_QuantizationComponent_descriptor();
}
template <>
struct is_proto_enum<::tensorflow::quantization::QuantizationComponentSpec_TensorType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::tensorflow::quantization::QuantizationComponentSpec_TensorType>() {
  return ::tensorflow::quantization::QuantizationComponentSpec_TensorType_descriptor();
}
template <>
struct is_proto_enum<::tensorflow::quantization::OpSet> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::tensorflow::quantization::OpSet>() {
  return ::tensorflow::quantization::OpSet_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fmlir_2fquantization_2ftensorflow_2fquantization_5foptions_2eproto_2epb_2eh
