EIC code displayed by LXR master/​include/​onnx/​onnx-ml.pb.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-02-21 10:05:43

 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // NO CHECKED-IN PROTOBUF GENCODE
 // source: onnx/onnx-ml.proto
 // Protobuf C++ Version: 5.28.2
 
 #ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh
 #define GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh
 
 #include <limits>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 #include "google/protobuf/runtime_version.h"
 #if PROTOBUF_VERSION != 5028002
 #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/generated_enum_reflection.h"
 #include "google/protobuf/unknown_field_set.h"
 // @@protoc_insertion_point(includes)
 
 // Must be included last.
 #include "google/protobuf/port_def.inc"
 
 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2dml_2eproto ONNX_API
 
 namespace google {
 namespace protobuf {
 namespace internal {
 class AnyMetadata;
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google
 
 // Internal implementation detail -- do not use these members.
 struct ONNX_API TableStruct_onnx_2fonnx_2dml_2eproto {
   static const ::uint32_t offsets[];
 };
 ONNX_API extern const ::google::protobuf::internal::DescriptorTable
     descriptor_table_onnx_2fonnx_2dml_2eproto;
 namespace onnx {
 class AttributeProto;
 struct AttributeProtoDefaultTypeInternal;
 ONNX_API extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
 class FunctionProto;
 struct FunctionProtoDefaultTypeInternal;
 ONNX_API extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
 class GraphProto;
 struct GraphProtoDefaultTypeInternal;
 ONNX_API extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
 class ModelProto;
 struct ModelProtoDefaultTypeInternal;
 ONNX_API extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
 class NodeProto;
 struct NodeProtoDefaultTypeInternal;
 ONNX_API extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
 class OperatorSetIdProto;
 struct OperatorSetIdProtoDefaultTypeInternal;
 ONNX_API extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
 class SparseTensorProto;
 struct SparseTensorProtoDefaultTypeInternal;
 ONNX_API extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
 class StringStringEntryProto;
 struct StringStringEntryProtoDefaultTypeInternal;
 ONNX_API extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
 class TensorAnnotation;
 struct TensorAnnotationDefaultTypeInternal;
 ONNX_API extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
 class TensorProto;
 struct TensorProtoDefaultTypeInternal;
 ONNX_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
 class TensorProto_Segment;
 struct TensorProto_SegmentDefaultTypeInternal;
 ONNX_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
 class TensorShapeProto;
 struct TensorShapeProtoDefaultTypeInternal;
 ONNX_API extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
 class TensorShapeProto_Dimension;
 struct TensorShapeProto_DimensionDefaultTypeInternal;
 ONNX_API extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
 class TrainingInfoProto;
 struct TrainingInfoProtoDefaultTypeInternal;
 ONNX_API extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
 class TypeProto;
 struct TypeProtoDefaultTypeInternal;
 ONNX_API extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
 class TypeProto_Map;
 struct TypeProto_MapDefaultTypeInternal;
 ONNX_API extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
 class TypeProto_Opaque;
 struct TypeProto_OpaqueDefaultTypeInternal;
 ONNX_API extern TypeProto_OpaqueDefaultTypeInternal _TypeProto_Opaque_default_instance_;
 class TypeProto_Optional;
 struct TypeProto_OptionalDefaultTypeInternal;
 ONNX_API extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
 class TypeProto_Sequence;
 struct TypeProto_SequenceDefaultTypeInternal;
 ONNX_API extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
 class TypeProto_SparseTensor;
 struct TypeProto_SparseTensorDefaultTypeInternal;
 ONNX_API extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
 class TypeProto_Tensor;
 struct TypeProto_TensorDefaultTypeInternal;
 ONNX_API extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
 class ValueInfoProto;
 struct ValueInfoProtoDefaultTypeInternal;
 ONNX_API extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
 }  // namespace onnx
 namespace google {
 namespace protobuf {
 }  // namespace protobuf
 }  // namespace google
 
 namespace onnx {
 enum AttributeProto_AttributeType : int {
   AttributeProto_AttributeType_UNDEFINED = 0,
   AttributeProto_AttributeType_FLOAT = 1,
   AttributeProto_AttributeType_INT = 2,
   AttributeProto_AttributeType_STRING = 3,
   AttributeProto_AttributeType_TENSOR = 4,
   AttributeProto_AttributeType_GRAPH = 5,
   AttributeProto_AttributeType_SPARSE_TENSOR = 11,
   AttributeProto_AttributeType_TYPE_PROTO = 13,
   AttributeProto_AttributeType_FLOATS = 6,
   AttributeProto_AttributeType_INTS = 7,
   AttributeProto_AttributeType_STRINGS = 8,
   AttributeProto_AttributeType_TENSORS = 9,
   AttributeProto_AttributeType_GRAPHS = 10,
   AttributeProto_AttributeType_SPARSE_TENSORS = 12,
   AttributeProto_AttributeType_TYPE_PROTOS = 14,
 };
 
 ONNX_API bool AttributeProto_AttributeType_IsValid(int value);
 ONNX_API extern const uint32_t AttributeProto_AttributeType_internal_data_[];
 constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = static_cast<AttributeProto_AttributeType>(0);
 constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = static_cast<AttributeProto_AttributeType>(14);
 constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = 14 + 1;
 ONNX_API const ::google::protobuf::EnumDescriptor*
 AttributeProto_AttributeType_descriptor();
 template <typename T>
 const std::string& AttributeProto_AttributeType_Name(T value) {
   static_assert(std::is_same<T, AttributeProto_AttributeType>::value ||
                     std::is_integral<T>::value,
                 "Incorrect type passed to AttributeType_Name().");
   return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(value));
 }
 template <>
 inline const std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
   return ::google::protobuf::internal::NameOfDenseEnum<AttributeProto_AttributeType_descriptor,
                                                  0, 14>(
       static_cast<int>(value));
 }
 inline bool AttributeProto_AttributeType_Parse(absl::string_view name, AttributeProto_AttributeType* value) {
   return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(
       AttributeProto_AttributeType_descriptor(), name, value);
 }
 enum TensorProto_DataType : int {
   TensorProto_DataType_UNDEFINED = 0,
   TensorProto_DataType_FLOAT = 1,
   TensorProto_DataType_UINT8 = 2,
   TensorProto_DataType_INT8 = 3,
   TensorProto_DataType_UINT16 = 4,
   TensorProto_DataType_INT16 = 5,
   TensorProto_DataType_INT32 = 6,
   TensorProto_DataType_INT64 = 7,
   TensorProto_DataType_STRING = 8,
   TensorProto_DataType_BOOL = 9,
   TensorProto_DataType_FLOAT16 = 10,
   TensorProto_DataType_DOUBLE = 11,
   TensorProto_DataType_UINT32 = 12,
   TensorProto_DataType_UINT64 = 13,
   TensorProto_DataType_COMPLEX64 = 14,
   TensorProto_DataType_COMPLEX128 = 15,
   TensorProto_DataType_BFLOAT16 = 16,
   TensorProto_DataType_FLOAT8E4M3FN = 17,
   TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
   TensorProto_DataType_FLOAT8E5M2 = 19,
   TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
 };
 
 ONNX_API bool TensorProto_DataType_IsValid(int value);
 ONNX_API extern const uint32_t TensorProto_DataType_internal_data_[];
 constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = static_cast<TensorProto_DataType>(0);
 constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = static_cast<TensorProto_DataType>(20);
 constexpr int TensorProto_DataType_DataType_ARRAYSIZE = 20 + 1;
 ONNX_API const ::google::protobuf::EnumDescriptor*
 TensorProto_DataType_descriptor();
 template <typename T>
 const std::string& TensorProto_DataType_Name(T value) {
   static_assert(std::is_same<T, TensorProto_DataType>::value ||
                     std::is_integral<T>::value,
                 "Incorrect type passed to DataType_Name().");
   return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(value));
 }
 template <>
 inline const std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataType_descriptor,
                                                  0, 20>(
       static_cast<int>(value));
 }
 inline bool TensorProto_DataType_Parse(absl::string_view name, TensorProto_DataType* value) {
   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
       TensorProto_DataType_descriptor(), name, value);
 }
 enum TensorProto_DataLocation : int {
   TensorProto_DataLocation_DEFAULT = 0,
   TensorProto_DataLocation_EXTERNAL = 1,
 };
 
 ONNX_API bool TensorProto_DataLocation_IsValid(int value);
 ONNX_API extern const uint32_t TensorProto_DataLocation_internal_data_[];
 constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = static_cast<TensorProto_DataLocation>(0);
 constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = static_cast<TensorProto_DataLocation>(1);
 constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = 1 + 1;
 ONNX_API const ::google::protobuf::EnumDescriptor*
 TensorProto_DataLocation_descriptor();
 template <typename T>
 const std::string& TensorProto_DataLocation_Name(T value) {
   static_assert(std::is_same<T, TensorProto_DataLocation>::value ||
                     std::is_integral<T>::value,
                 "Incorrect type passed to DataLocation_Name().");
   return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(value));
 }
 template <>
 inline const std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value) {
   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataLocation_descriptor,
                                                  0, 1>(
       static_cast<int>(value));
 }
 inline bool TensorProto_DataLocation_Parse(absl::string_view name, TensorProto_DataLocation* value) {
   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataLocation>(
       TensorProto_DataLocation_descriptor(), name, value);
 }
 enum Version : int {
   _START_VERSION = 0,
   IR_VERSION_2017_10_10 = 1,
   IR_VERSION_2017_10_30 = 2,
   IR_VERSION_2017_11_3 = 3,
   IR_VERSION_2019_1_22 = 4,
   IR_VERSION_2019_3_18 = 5,
   IR_VERSION_2019_9_19 = 6,
   IR_VERSION_2020_5_8 = 7,
   IR_VERSION_2021_7_30 = 8,
   IR_VERSION = 9,
 };
 
 ONNX_API bool Version_IsValid(int value);
 ONNX_API extern const uint32_t Version_internal_data_[];
 constexpr Version Version_MIN = static_cast<Version>(0);
 constexpr Version Version_MAX = static_cast<Version>(9);
 constexpr int Version_ARRAYSIZE = 9 + 1;
 ONNX_API const ::google::protobuf::EnumDescriptor*
 Version_descriptor();
 template <typename T>
 const std::string& Version_Name(T value) {
   static_assert(std::is_same<T, Version>::value ||
                     std::is_integral<T>::value,
                 "Incorrect type passed to Version_Name().");
   return Version_Name(static_cast<Version>(value));
 }
 template <>
 inline const std::string& Version_Name(Version value) {
   return ::google::protobuf::internal::NameOfDenseEnum<Version_descriptor,
                                                  0, 9>(
       static_cast<int>(value));
 }
 inline bool Version_Parse(absl::string_view name, Version* value) {
   return ::google::protobuf::internal::ParseNamedEnum<Version>(
       Version_descriptor(), name, value);
 }
 enum OperatorStatus : int {
   EXPERIMENTAL = 0,
   STABLE = 1,
 };
 
 ONNX_API bool OperatorStatus_IsValid(int value);
 ONNX_API extern const uint32_t OperatorStatus_internal_data_[];
 constexpr OperatorStatus OperatorStatus_MIN = static_cast<OperatorStatus>(0);
 constexpr OperatorStatus OperatorStatus_MAX = static_cast<OperatorStatus>(1);
 constexpr int OperatorStatus_ARRAYSIZE = 1 + 1;
 ONNX_API const ::google::protobuf::EnumDescriptor*
 OperatorStatus_descriptor();
 template <typename T>
 const std::string& OperatorStatus_Name(T value) {
   static_assert(std::is_same<T, OperatorStatus>::value ||
                     std::is_integral<T>::value,
                 "Incorrect type passed to OperatorStatus_Name().");
   return OperatorStatus_Name(static_cast<OperatorStatus>(value));
 }
 template <>
 inline const std::string& OperatorStatus_Name(OperatorStatus value) {
   return ::google::protobuf::internal::NameOfDenseEnum<OperatorStatus_descriptor,
                                                  0, 1>(
       static_cast<int>(value));
 }
 inline bool OperatorStatus_Parse(absl::string_view name, OperatorStatus* value) {
   return ::google::protobuf::internal::ParseNamedEnum<OperatorStatus>(
       OperatorStatus_descriptor(), name, value);
 }
 
 // ===================================================================
 
 
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_Opaque final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Opaque) */ {
  public:
   inline TypeProto_Opaque() : TypeProto_Opaque(nullptr) {}
   ~TypeProto_Opaque() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_Opaque(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_Opaque(const TypeProto_Opaque& from) : TypeProto_Opaque(nullptr, from) {}
   inline TypeProto_Opaque(TypeProto_Opaque&& from) noexcept
       : TypeProto_Opaque(nullptr, std::move(from)) {}
   inline TypeProto_Opaque& operator=(const TypeProto_Opaque& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_Opaque& operator=(TypeProto_Opaque&& 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 TypeProto_Opaque& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_Opaque* internal_default_instance() {
     return reinterpret_cast<const TypeProto_Opaque*>(
         &_TypeProto_Opaque_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 18;
   friend void swap(TypeProto_Opaque& a, TypeProto_Opaque& b) { a.Swap(&b); }
   inline void Swap(TypeProto_Opaque* 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(TypeProto_Opaque* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_Opaque* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Opaque>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_Opaque& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_Opaque& from) { TypeProto_Opaque::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(TypeProto_Opaque* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Opaque"; }
 
  protected:
   explicit TypeProto_Opaque(::google::protobuf::Arena* arena);
   TypeProto_Opaque(::google::protobuf::Arena* arena, const TypeProto_Opaque& from);
   TypeProto_Opaque(::google::protobuf::Arena* arena, TypeProto_Opaque&& from) noexcept
       : TypeProto_Opaque(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 {
     kDomainFieldNumber = 1,
     kNameFieldNumber = 2,
   };
   // optional string domain = 1;
   bool has_domain() const;
   void clear_domain() ;
   const std::string& domain() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_domain(Arg_&& arg, Args_... args);
   std::string* mutable_domain();
   PROTOBUF_NODISCARD std::string* release_domain();
   void set_allocated_domain(std::string* value);
 
   private:
   const std::string& _internal_domain() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
       const std::string& value);
   std::string* _internal_mutable_domain();
 
   public:
   // optional string name = 2;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Opaque)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       1, 2, 0,
       40, 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 TypeProto_Opaque& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr domain_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TensorShapeProto_Dimension final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
  public:
   inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
   ~TensorShapeProto_Dimension() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TensorShapeProto_Dimension(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from) : TensorShapeProto_Dimension(nullptr, from) {}
   inline TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
       : TensorShapeProto_Dimension(nullptr, std::move(from)) {}
   inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
     CopyFrom(from);
     return *this;
   }
   inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& 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 TensorShapeProto_Dimension& default_instance() {
     return *internal_default_instance();
   }
   enum ValueCase {
     kDimValue = 1,
     kDimParam = 2,
     VALUE_NOT_SET = 0,
   };
   static inline const TensorShapeProto_Dimension* internal_default_instance() {
     return reinterpret_cast<const TensorShapeProto_Dimension*>(
         &_TensorShapeProto_Dimension_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 11;
   friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) { a.Swap(&b); }
   inline void Swap(TensorShapeProto_Dimension* 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(TensorShapeProto_Dimension* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TensorShapeProto_Dimension* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto_Dimension>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TensorShapeProto_Dimension& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TensorShapeProto_Dimension& from) { TensorShapeProto_Dimension::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(TensorShapeProto_Dimension* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto.Dimension"; }
 
  protected:
   explicit TensorShapeProto_Dimension(::google::protobuf::Arena* arena);
   TensorShapeProto_Dimension(::google::protobuf::Arena* arena, const TensorShapeProto_Dimension& from);
   TensorShapeProto_Dimension(::google::protobuf::Arena* arena, TensorShapeProto_Dimension&& from) noexcept
       : TensorShapeProto_Dimension(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 {
     kDenotationFieldNumber = 3,
     kDimValueFieldNumber = 1,
     kDimParamFieldNumber = 2,
   };
   // optional string denotation = 3;
   bool has_denotation() const;
   void clear_denotation() ;
   const std::string& denotation() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_denotation(Arg_&& arg, Args_... args);
   std::string* mutable_denotation();
   PROTOBUF_NODISCARD std::string* release_denotation();
   void set_allocated_denotation(std::string* value);
 
   private:
   const std::string& _internal_denotation() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(
       const std::string& value);
   std::string* _internal_mutable_denotation();
 
   public:
   // int64 dim_value = 1;
   bool has_dim_value() const;
   void clear_dim_value() ;
   ::int64_t dim_value() const;
   void set_dim_value(::int64_t value);
 
   private:
   ::int64_t _internal_dim_value() const;
   void _internal_set_dim_value(::int64_t value);
 
   public:
   // string dim_param = 2;
   bool has_dim_param() const;
   void clear_dim_param() ;
   const std::string& dim_param() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_dim_param(Arg_&& arg, Args_... args);
   std::string* mutable_dim_param();
   PROTOBUF_NODISCARD std::string* release_dim_param();
   void set_allocated_dim_param(std::string* value);
 
   private:
   const std::string& _internal_dim_param() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(
       const std::string& value);
   std::string* _internal_mutable_dim_param();
 
   public:
   void clear_value();
   ValueCase value_case() const;
   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
  private:
   class _Internal;
   void set_has_dim_value();
   void set_has_dim_param();
   inline bool has_value() const;
   inline void clear_has_value();
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       0, 3, 0,
       59, 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 TensorShapeProto_Dimension& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr denotation_;
     union ValueUnion {
       constexpr ValueUnion() : _constinit_{} {}
       ::google::protobuf::internal::ConstantInitialized _constinit_;
       ::int64_t dim_value_;
       ::google::protobuf::internal::ArenaStringPtr dim_param_;
     } value_;
     ::uint32_t _oneof_case_[1];
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TensorProto_Segment final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
  public:
   inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
   ~TensorProto_Segment() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TensorProto_Segment(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TensorProto_Segment(const TensorProto_Segment& from) : TensorProto_Segment(nullptr, from) {}
   inline TensorProto_Segment(TensorProto_Segment&& from) noexcept
       : TensorProto_Segment(nullptr, std::move(from)) {}
   inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
     CopyFrom(from);
     return *this;
   }
   inline TensorProto_Segment& operator=(TensorProto_Segment&& 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 TensorProto_Segment& default_instance() {
     return *internal_default_instance();
   }
   static inline const TensorProto_Segment* internal_default_instance() {
     return reinterpret_cast<const TensorProto_Segment*>(
         &_TensorProto_Segment_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 8;
   friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) { a.Swap(&b); }
   inline void Swap(TensorProto_Segment* 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(TensorProto_Segment* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TensorProto_Segment* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TensorProto_Segment>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TensorProto_Segment& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TensorProto_Segment& from) { TensorProto_Segment::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(TensorProto_Segment* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TensorProto.Segment"; }
 
  protected:
   explicit TensorProto_Segment(::google::protobuf::Arena* arena);
   TensorProto_Segment(::google::protobuf::Arena* arena, const TensorProto_Segment& from);
   TensorProto_Segment(::google::protobuf::Arena* arena, TensorProto_Segment&& from) noexcept
       : TensorProto_Segment(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 {
     kBeginFieldNumber = 1,
     kEndFieldNumber = 2,
   };
   // optional int64 begin = 1;
   bool has_begin() const;
   void clear_begin() ;
   ::int64_t begin() const;
   void set_begin(::int64_t value);
 
   private:
   ::int64_t _internal_begin() const;
   void _internal_set_begin(::int64_t value);
 
   public:
   // optional int64 end = 2;
   bool has_end() const;
   void clear_end() ;
   ::int64_t end() const;
   void set_end(::int64_t value);
 
   private:
   ::int64_t _internal_end() const;
   void _internal_set_end(::int64_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment)
  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 TensorProto_Segment& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::int64_t begin_;
     ::int64_t end_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API StringStringEntryProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
  public:
   inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
   ~StringStringEntryProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR StringStringEntryProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline StringStringEntryProto(const StringStringEntryProto& from) : StringStringEntryProto(nullptr, from) {}
   inline StringStringEntryProto(StringStringEntryProto&& from) noexcept
       : StringStringEntryProto(nullptr, std::move(from)) {}
   inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline StringStringEntryProto& operator=(StringStringEntryProto&& 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 StringStringEntryProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const StringStringEntryProto* internal_default_instance() {
     return reinterpret_cast<const StringStringEntryProto*>(
         &_StringStringEntryProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 5;
   friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) { a.Swap(&b); }
   inline void Swap(StringStringEntryProto* 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(StringStringEntryProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   StringStringEntryProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<StringStringEntryProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const StringStringEntryProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const StringStringEntryProto& from) { StringStringEntryProto::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(StringStringEntryProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.StringStringEntryProto"; }
 
  protected:
   explicit StringStringEntryProto(::google::protobuf::Arena* arena);
   StringStringEntryProto(::google::protobuf::Arena* arena, const StringStringEntryProto& from);
   StringStringEntryProto(::google::protobuf::Arena* arena, StringStringEntryProto&& from) noexcept
       : StringStringEntryProto(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 {
     kKeyFieldNumber = 1,
     kValueFieldNumber = 2,
   };
   // optional string key = 1;
   bool has_key() const;
   void clear_key() ;
   const std::string& key() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_key(Arg_&& arg, Args_... args);
   std::string* mutable_key();
   PROTOBUF_NODISCARD std::string* release_key();
   void set_allocated_key(std::string* value);
 
   private:
   const std::string& _internal_key() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
       const std::string& value);
   std::string* _internal_mutable_key();
 
   public:
   // optional string value = 2;
   bool has_value() const;
   void clear_value() ;
   const std::string& value() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_value(Arg_&& arg, Args_... args);
   std::string* mutable_value();
   PROTOBUF_NODISCARD std::string* release_value();
   void set_allocated_value(std::string* value);
 
   private:
   const std::string& _internal_value() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(
       const std::string& value);
   std::string* _internal_mutable_value();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       1, 2, 0,
       44, 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 StringStringEntryProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr key_;
     ::google::protobuf::internal::ArenaStringPtr value_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API OperatorSetIdProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
  public:
   inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
   ~OperatorSetIdProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR OperatorSetIdProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline OperatorSetIdProto(const OperatorSetIdProto& from) : OperatorSetIdProto(nullptr, from) {}
   inline OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
       : OperatorSetIdProto(nullptr, std::move(from)) {}
   inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline OperatorSetIdProto& operator=(OperatorSetIdProto&& 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 OperatorSetIdProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const OperatorSetIdProto* internal_default_instance() {
     return reinterpret_cast<const OperatorSetIdProto*>(
         &_OperatorSetIdProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 20;
   friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) { a.Swap(&b); }
   inline void Swap(OperatorSetIdProto* 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(OperatorSetIdProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   OperatorSetIdProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<OperatorSetIdProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const OperatorSetIdProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const OperatorSetIdProto& from) { OperatorSetIdProto::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(OperatorSetIdProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.OperatorSetIdProto"; }
 
  protected:
   explicit OperatorSetIdProto(::google::protobuf::Arena* arena);
   OperatorSetIdProto(::google::protobuf::Arena* arena, const OperatorSetIdProto& from);
   OperatorSetIdProto(::google::protobuf::Arena* arena, OperatorSetIdProto&& from) noexcept
       : OperatorSetIdProto(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 {
     kDomainFieldNumber = 1,
     kVersionFieldNumber = 2,
   };
   // optional string domain = 1;
   bool has_domain() const;
   void clear_domain() ;
   const std::string& domain() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_domain(Arg_&& arg, Args_... args);
   std::string* mutable_domain();
   PROTOBUF_NODISCARD std::string* release_domain();
   void set_allocated_domain(std::string* value);
 
   private:
   const std::string& _internal_domain() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
       const std::string& value);
   std::string* _internal_mutable_domain();
 
   public:
   // optional int64 version = 2;
   bool has_version() const;
   void clear_version() ;
   ::int64_t version() const;
   void set_version(::int64_t value);
 
   private:
   ::int64_t _internal_version() const;
   void _internal_set_version(::int64_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       1, 2, 0,
       38, 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 OperatorSetIdProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr domain_;
     ::int64_t version_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TensorShapeProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
  public:
   inline TensorShapeProto() : TensorShapeProto(nullptr) {}
   ~TensorShapeProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TensorShapeProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TensorShapeProto(const TensorShapeProto& from) : TensorShapeProto(nullptr, from) {}
   inline TensorShapeProto(TensorShapeProto&& from) noexcept
       : TensorShapeProto(nullptr, std::move(from)) {}
   inline TensorShapeProto& operator=(const TensorShapeProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline TensorShapeProto& operator=(TensorShapeProto&& 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 TensorShapeProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const TensorShapeProto* internal_default_instance() {
     return reinterpret_cast<const TensorShapeProto*>(
         &_TensorShapeProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 12;
   friend void swap(TensorShapeProto& a, TensorShapeProto& b) { a.Swap(&b); }
   inline void Swap(TensorShapeProto* 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(TensorShapeProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TensorShapeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TensorShapeProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TensorShapeProto& from) { TensorShapeProto::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(TensorShapeProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto"; }
 
  protected:
   explicit TensorShapeProto(::google::protobuf::Arena* arena);
   TensorShapeProto(::google::protobuf::Arena* arena, const TensorShapeProto& from);
   TensorShapeProto(::google::protobuf::Arena* arena, TensorShapeProto&& from) noexcept
       : TensorShapeProto(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 Dimension = TensorShapeProto_Dimension;
 
   // accessors -------------------------------------------------------
   enum : int {
     kDimFieldNumber = 1,
   };
   // repeated .onnx.TensorShapeProto.Dimension dim = 1;
   int dim_size() const;
   private:
   int _internal_dim_size() const;
 
   public:
   void clear_dim() ;
   ::onnx::TensorShapeProto_Dimension* mutable_dim(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* mutable_dim();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& _internal_dim() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* _internal_mutable_dim();
   public:
   const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
   ::onnx::TensorShapeProto_Dimension* add_dim();
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& dim() const;
   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       0, 1, 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 TensorShapeProto& from_msg);
     ::google::protobuf::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TensorProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
  public:
   inline TensorProto() : TensorProto(nullptr) {}
   ~TensorProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TensorProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TensorProto(const TensorProto& from) : TensorProto(nullptr, from) {}
   inline TensorProto(TensorProto&& from) noexcept
       : TensorProto(nullptr, std::move(from)) {}
   inline TensorProto& operator=(const TensorProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline TensorProto& operator=(TensorProto&& 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 TensorProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const TensorProto* internal_default_instance() {
     return reinterpret_cast<const TensorProto*>(
         &_TensorProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 9;
   friend void swap(TensorProto& a, TensorProto& b) { a.Swap(&b); }
   inline void Swap(TensorProto* 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(TensorProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TensorProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TensorProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TensorProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TensorProto& from) { TensorProto::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(TensorProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TensorProto"; }
 
  protected:
   explicit TensorProto(::google::protobuf::Arena* arena);
   TensorProto(::google::protobuf::Arena* arena, const TensorProto& from);
   TensorProto(::google::protobuf::Arena* arena, TensorProto&& from) noexcept
       : TensorProto(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 Segment = TensorProto_Segment;
   using DataType = TensorProto_DataType;
   static constexpr DataType UNDEFINED = TensorProto_DataType_UNDEFINED;
   static constexpr DataType FLOAT = TensorProto_DataType_FLOAT;
   static constexpr DataType UINT8 = TensorProto_DataType_UINT8;
   static constexpr DataType INT8 = TensorProto_DataType_INT8;
   static constexpr DataType UINT16 = TensorProto_DataType_UINT16;
   static constexpr DataType INT16 = TensorProto_DataType_INT16;
   static constexpr DataType INT32 = TensorProto_DataType_INT32;
   static constexpr DataType INT64 = TensorProto_DataType_INT64;
   static constexpr DataType STRING = TensorProto_DataType_STRING;
   static constexpr DataType BOOL = TensorProto_DataType_BOOL;
   static constexpr DataType FLOAT16 = TensorProto_DataType_FLOAT16;
   static constexpr DataType DOUBLE = TensorProto_DataType_DOUBLE;
   static constexpr DataType UINT32 = TensorProto_DataType_UINT32;
   static constexpr DataType UINT64 = TensorProto_DataType_UINT64;
   static constexpr DataType COMPLEX64 = TensorProto_DataType_COMPLEX64;
   static constexpr DataType COMPLEX128 = TensorProto_DataType_COMPLEX128;
   static constexpr DataType BFLOAT16 = TensorProto_DataType_BFLOAT16;
   static constexpr DataType FLOAT8E4M3FN = TensorProto_DataType_FLOAT8E4M3FN;
   static constexpr DataType FLOAT8E4M3FNUZ = TensorProto_DataType_FLOAT8E4M3FNUZ;
   static constexpr DataType FLOAT8E5M2 = TensorProto_DataType_FLOAT8E5M2;
   static constexpr DataType FLOAT8E5M2FNUZ = TensorProto_DataType_FLOAT8E5M2FNUZ;
   static inline bool DataType_IsValid(int value) {
     return TensorProto_DataType_IsValid(value);
   }
   static constexpr DataType DataType_MIN = TensorProto_DataType_DataType_MIN;
   static constexpr DataType DataType_MAX = TensorProto_DataType_DataType_MAX;
   static constexpr int DataType_ARRAYSIZE = TensorProto_DataType_DataType_ARRAYSIZE;
   static inline const ::google::protobuf::EnumDescriptor* DataType_descriptor() {
     return TensorProto_DataType_descriptor();
   }
   template <typename T>
   static inline const std::string& DataType_Name(T value) {
     return TensorProto_DataType_Name(value);
   }
   static inline bool DataType_Parse(absl::string_view name, DataType* value) {
     return TensorProto_DataType_Parse(name, value);
   }
   using DataLocation = TensorProto_DataLocation;
   static constexpr DataLocation DEFAULT = TensorProto_DataLocation_DEFAULT;
   static constexpr DataLocation EXTERNAL = TensorProto_DataLocation_EXTERNAL;
   static inline bool DataLocation_IsValid(int value) {
     return TensorProto_DataLocation_IsValid(value);
   }
   static constexpr DataLocation DataLocation_MIN = TensorProto_DataLocation_DataLocation_MIN;
   static constexpr DataLocation DataLocation_MAX = TensorProto_DataLocation_DataLocation_MAX;
   static constexpr int DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_ARRAYSIZE;
   static inline const ::google::protobuf::EnumDescriptor* DataLocation_descriptor() {
     return TensorProto_DataLocation_descriptor();
   }
   template <typename T>
   static inline const std::string& DataLocation_Name(T value) {
     return TensorProto_DataLocation_Name(value);
   }
   static inline bool DataLocation_Parse(absl::string_view name, DataLocation* value) {
     return TensorProto_DataLocation_Parse(name, value);
   }
 
   // accessors -------------------------------------------------------
   enum : int {
     kDimsFieldNumber = 1,
     kFloatDataFieldNumber = 4,
     kInt32DataFieldNumber = 5,
     kStringDataFieldNumber = 6,
     kInt64DataFieldNumber = 7,
     kDoubleDataFieldNumber = 10,
     kUint64DataFieldNumber = 11,
     kExternalDataFieldNumber = 13,
     kNameFieldNumber = 8,
     kRawDataFieldNumber = 9,
     kDocStringFieldNumber = 12,
     kSegmentFieldNumber = 3,
     kDataTypeFieldNumber = 2,
     kDataLocationFieldNumber = 14,
   };
   // repeated int64 dims = 1;
   int dims_size() const;
   private:
   int _internal_dims_size() const;
 
   public:
   void clear_dims() ;
   ::int64_t dims(int index) const;
   void set_dims(int index, ::int64_t value);
   void add_dims(::int64_t value);
   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
   ::google::protobuf::RepeatedField<::int64_t>* mutable_dims();
 
   private:
   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_dims();
 
   public:
   // repeated float float_data = 4 [packed = true];
   int float_data_size() const;
   private:
   int _internal_float_data_size() const;
 
   public:
   void clear_float_data() ;
   float float_data(int index) const;
   void set_float_data(int index, float value);
   void add_float_data(float value);
   const ::google::protobuf::RepeatedField<float>& float_data() const;
   ::google::protobuf::RepeatedField<float>* mutable_float_data();
 
   private:
   const ::google::protobuf::RepeatedField<float>& _internal_float_data() const;
   ::google::protobuf::RepeatedField<float>* _internal_mutable_float_data();
 
   public:
   // repeated int32 int32_data = 5 [packed = true];
   int int32_data_size() const;
   private:
   int _internal_int32_data_size() const;
 
   public:
   void clear_int32_data() ;
   ::int32_t int32_data(int index) const;
   void set_int32_data(int index, ::int32_t value);
   void add_int32_data(::int32_t value);
   const ::google::protobuf::RepeatedField<::int32_t>& int32_data() const;
   ::google::protobuf::RepeatedField<::int32_t>* mutable_int32_data();
 
   private:
   const ::google::protobuf::RepeatedField<::int32_t>& _internal_int32_data() const;
   ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_int32_data();
 
   public:
   // repeated bytes string_data = 6;
   int string_data_size() const;
   private:
   int _internal_string_data_size() const;
 
   public:
   void clear_string_data() ;
   const std::string& string_data(int index) const;
   std::string* mutable_string_data(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_string_data(int index, Arg_&& value, Args_... args);
   std::string* add_string_data();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_string_data(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& string_data() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_string_data();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_string_data() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_string_data();
 
   public:
   // repeated int64 int64_data = 7 [packed = true];
   int int64_data_size() const;
   private:
   int _internal_int64_data_size() const;
 
   public:
   void clear_int64_data() ;
   ::int64_t int64_data(int index) const;
   void set_int64_data(int index, ::int64_t value);
   void add_int64_data(::int64_t value);
   const ::google::protobuf::RepeatedField<::int64_t>& int64_data() const;
   ::google::protobuf::RepeatedField<::int64_t>* mutable_int64_data();
 
   private:
   const ::google::protobuf::RepeatedField<::int64_t>& _internal_int64_data() const;
   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_int64_data();
 
   public:
   // repeated double double_data = 10 [packed = true];
   int double_data_size() const;
   private:
   int _internal_double_data_size() const;
 
   public:
   void clear_double_data() ;
   double double_data(int index) const;
   void set_double_data(int index, double value);
   void add_double_data(double value);
   const ::google::protobuf::RepeatedField<double>& double_data() const;
   ::google::protobuf::RepeatedField<double>* mutable_double_data();
 
   private:
   const ::google::protobuf::RepeatedField<double>& _internal_double_data() const;
   ::google::protobuf::RepeatedField<double>* _internal_mutable_double_data();
 
   public:
   // repeated uint64 uint64_data = 11 [packed = true];
   int uint64_data_size() const;
   private:
   int _internal_uint64_data_size() const;
 
   public:
   void clear_uint64_data() ;
   ::uint64_t uint64_data(int index) const;
   void set_uint64_data(int index, ::uint64_t value);
   void add_uint64_data(::uint64_t value);
   const ::google::protobuf::RepeatedField<::uint64_t>& uint64_data() const;
   ::google::protobuf::RepeatedField<::uint64_t>* mutable_uint64_data();
 
   private:
   const ::google::protobuf::RepeatedField<::uint64_t>& _internal_uint64_data() const;
   ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_uint64_data();
 
   public:
   // repeated .onnx.StringStringEntryProto external_data = 13;
   int external_data_size() const;
   private:
   int _internal_external_data_size() const;
 
   public:
   void clear_external_data() ;
   ::onnx::StringStringEntryProto* mutable_external_data(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_external_data();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_external_data() const;
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_external_data();
   public:
   const ::onnx::StringStringEntryProto& external_data(int index) const;
   ::onnx::StringStringEntryProto* add_external_data();
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& external_data() const;
   // optional string name = 8;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional bytes raw_data = 9;
   bool has_raw_data() const;
   void clear_raw_data() ;
   const std::string& raw_data() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_raw_data(Arg_&& arg, Args_... args);
   std::string* mutable_raw_data();
   PROTOBUF_NODISCARD std::string* release_raw_data();
   void set_allocated_raw_data(std::string* value);
 
   private:
   const std::string& _internal_raw_data() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(
       const std::string& value);
   std::string* _internal_mutable_raw_data();
 
   public:
   // optional string doc_string = 12;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional .onnx.TensorProto.Segment segment = 3;
   bool has_segment() const;
   void clear_segment() ;
   const ::onnx::TensorProto_Segment& segment() const;
   PROTOBUF_NODISCARD ::onnx::TensorProto_Segment* release_segment();
   ::onnx::TensorProto_Segment* mutable_segment();
   void set_allocated_segment(::onnx::TensorProto_Segment* value);
   void unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* value);
   ::onnx::TensorProto_Segment* unsafe_arena_release_segment();
 
   private:
   const ::onnx::TensorProto_Segment& _internal_segment() const;
   ::onnx::TensorProto_Segment* _internal_mutable_segment();
 
   public:
   // optional int32 data_type = 2;
   bool has_data_type() const;
   void clear_data_type() ;
   ::int32_t data_type() const;
   void set_data_type(::int32_t value);
 
   private:
   ::int32_t _internal_data_type() const;
   void _internal_set_data_type(::int32_t value);
 
   public:
   // optional .onnx.TensorProto.DataLocation data_location = 14;
   bool has_data_location() const;
   void clear_data_location() ;
   ::onnx::TensorProto_DataLocation data_location() const;
   void set_data_location(::onnx::TensorProto_DataLocation value);
 
   private:
   ::onnx::TensorProto_DataLocation _internal_data_location() const;
   void _internal_set_data_location(::onnx::TensorProto_DataLocation value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TensorProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       4, 14, 3,
       47, 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 TensorProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedField<::int64_t> dims_;
     ::google::protobuf::RepeatedField<float> float_data_;
     ::google::protobuf::RepeatedField<::int32_t> int32_data_;
     mutable ::google::protobuf::internal::CachedSize _int32_data_cached_byte_size_;
     ::google::protobuf::RepeatedPtrField<std::string> string_data_;
     ::google::protobuf::RepeatedField<::int64_t> int64_data_;
     mutable ::google::protobuf::internal::CachedSize _int64_data_cached_byte_size_;
     ::google::protobuf::RepeatedField<double> double_data_;
     ::google::protobuf::RepeatedField<::uint64_t> uint64_data_;
     mutable ::google::protobuf::internal::CachedSize _uint64_data_cached_byte_size_;
     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr raw_data_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::onnx::TensorProto_Segment* segment_;
     ::int32_t data_type_;
     int data_location_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TensorAnnotation final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
  public:
   inline TensorAnnotation() : TensorAnnotation(nullptr) {}
   ~TensorAnnotation() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TensorAnnotation(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TensorAnnotation(const TensorAnnotation& from) : TensorAnnotation(nullptr, from) {}
   inline TensorAnnotation(TensorAnnotation&& from) noexcept
       : TensorAnnotation(nullptr, std::move(from)) {}
   inline TensorAnnotation& operator=(const TensorAnnotation& from) {
     CopyFrom(from);
     return *this;
   }
   inline TensorAnnotation& operator=(TensorAnnotation&& 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 TensorAnnotation& default_instance() {
     return *internal_default_instance();
   }
   static inline const TensorAnnotation* internal_default_instance() {
     return reinterpret_cast<const TensorAnnotation*>(
         &_TensorAnnotation_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 6;
   friend void swap(TensorAnnotation& a, TensorAnnotation& b) { a.Swap(&b); }
   inline void Swap(TensorAnnotation* 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(TensorAnnotation* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TensorAnnotation* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TensorAnnotation>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TensorAnnotation& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TensorAnnotation& from) { TensorAnnotation::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(TensorAnnotation* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TensorAnnotation"; }
 
  protected:
   explicit TensorAnnotation(::google::protobuf::Arena* arena);
   TensorAnnotation(::google::protobuf::Arena* arena, const TensorAnnotation& from);
   TensorAnnotation(::google::protobuf::Arena* arena, TensorAnnotation&& from) noexcept
       : TensorAnnotation(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 {
     kQuantParameterTensorNamesFieldNumber = 2,
     kTensorNameFieldNumber = 1,
   };
   // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
   int quant_parameter_tensor_names_size() const;
   private:
   int _internal_quant_parameter_tensor_names_size() const;
 
   public:
   void clear_quant_parameter_tensor_names() ;
   ::onnx::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_quant_parameter_tensor_names();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_quant_parameter_tensor_names() const;
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_quant_parameter_tensor_names();
   public:
   const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
   ::onnx::StringStringEntryProto* add_quant_parameter_tensor_names();
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& quant_parameter_tensor_names() const;
   // optional string tensor_name = 1;
   bool has_tensor_name() const;
   void clear_tensor_name() ;
   const std::string& tensor_name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_tensor_name(Arg_&& arg, Args_... args);
   std::string* mutable_tensor_name();
   PROTOBUF_NODISCARD std::string* release_tensor_name();
   void set_allocated_tensor_name(std::string* value);
 
   private:
   const std::string& _internal_tensor_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(
       const std::string& value);
   std::string* _internal_mutable_tensor_name();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       1, 2, 1,
       41, 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 TensorAnnotation& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
     ::google::protobuf::internal::ArenaStringPtr tensor_name_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_Tensor final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
  public:
   inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
   ~TypeProto_Tensor() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_Tensor(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_Tensor(const TypeProto_Tensor& from) : TypeProto_Tensor(nullptr, from) {}
   inline TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
       : TypeProto_Tensor(nullptr, std::move(from)) {}
   inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_Tensor& operator=(TypeProto_Tensor&& 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 TypeProto_Tensor& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_Tensor* internal_default_instance() {
     return reinterpret_cast<const TypeProto_Tensor*>(
         &_TypeProto_Tensor_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 13;
   friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) { a.Swap(&b); }
   inline void Swap(TypeProto_Tensor* 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(TypeProto_Tensor* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_Tensor* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Tensor>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_Tensor& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_Tensor& from) { TypeProto_Tensor::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(TypeProto_Tensor* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Tensor"; }
 
  protected:
   explicit TypeProto_Tensor(::google::protobuf::Arena* arena);
   TypeProto_Tensor(::google::protobuf::Arena* arena, const TypeProto_Tensor& from);
   TypeProto_Tensor(::google::protobuf::Arena* arena, TypeProto_Tensor&& from) noexcept
       : TypeProto_Tensor(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 {
     kShapeFieldNumber = 2,
     kElemTypeFieldNumber = 1,
   };
   // optional .onnx.TensorShapeProto shape = 2;
   bool has_shape() const;
   void clear_shape() ;
   const ::onnx::TensorShapeProto& shape() const;
   PROTOBUF_NODISCARD ::onnx::TensorShapeProto* release_shape();
   ::onnx::TensorShapeProto* mutable_shape();
   void set_allocated_shape(::onnx::TensorShapeProto* value);
   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value);
   ::onnx::TensorShapeProto* unsafe_arena_release_shape();
 
   private:
   const ::onnx::TensorShapeProto& _internal_shape() const;
   ::onnx::TensorShapeProto* _internal_mutable_shape();
 
   public:
   // optional int32 elem_type = 1;
   bool has_elem_type() const;
   void clear_elem_type() ;
   ::int32_t elem_type() const;
   void set_elem_type(::int32_t value);
 
   private:
   ::int32_t _internal_elem_type() const;
   void _internal_set_elem_type(::int32_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor)
  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 TypeProto_Tensor& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::onnx::TensorShapeProto* shape_;
     ::int32_t elem_type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_SparseTensor final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
  public:
   inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {}
   ~TypeProto_SparseTensor() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_SparseTensor(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_SparseTensor(const TypeProto_SparseTensor& from) : TypeProto_SparseTensor(nullptr, from) {}
   inline TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
       : TypeProto_SparseTensor(nullptr, std::move(from)) {}
   inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& 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 TypeProto_SparseTensor& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_SparseTensor* internal_default_instance() {
     return reinterpret_cast<const TypeProto_SparseTensor*>(
         &_TypeProto_SparseTensor_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 17;
   friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) { a.Swap(&b); }
   inline void Swap(TypeProto_SparseTensor* 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(TypeProto_SparseTensor* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_SparseTensor* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_SparseTensor>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_SparseTensor& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_SparseTensor& from) { TypeProto_SparseTensor::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(TypeProto_SparseTensor* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.SparseTensor"; }
 
  protected:
   explicit TypeProto_SparseTensor(::google::protobuf::Arena* arena);
   TypeProto_SparseTensor(::google::protobuf::Arena* arena, const TypeProto_SparseTensor& from);
   TypeProto_SparseTensor(::google::protobuf::Arena* arena, TypeProto_SparseTensor&& from) noexcept
       : TypeProto_SparseTensor(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 {
     kShapeFieldNumber = 2,
     kElemTypeFieldNumber = 1,
   };
   // optional .onnx.TensorShapeProto shape = 2;
   bool has_shape() const;
   void clear_shape() ;
   const ::onnx::TensorShapeProto& shape() const;
   PROTOBUF_NODISCARD ::onnx::TensorShapeProto* release_shape();
   ::onnx::TensorShapeProto* mutable_shape();
   void set_allocated_shape(::onnx::TensorShapeProto* value);
   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value);
   ::onnx::TensorShapeProto* unsafe_arena_release_shape();
 
   private:
   const ::onnx::TensorShapeProto& _internal_shape() const;
   ::onnx::TensorShapeProto* _internal_mutable_shape();
 
   public:
   // optional int32 elem_type = 1;
   bool has_elem_type() const;
   void clear_elem_type() ;
   ::int32_t elem_type() const;
   void set_elem_type(::int32_t value);
 
   private:
   ::int32_t _internal_elem_type() const;
   void _internal_set_elem_type(::int32_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor)
  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 TypeProto_SparseTensor& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::onnx::TensorShapeProto* shape_;
     ::int32_t elem_type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API SparseTensorProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
  public:
   inline SparseTensorProto() : SparseTensorProto(nullptr) {}
   ~SparseTensorProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR SparseTensorProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline SparseTensorProto(const SparseTensorProto& from) : SparseTensorProto(nullptr, from) {}
   inline SparseTensorProto(SparseTensorProto&& from) noexcept
       : SparseTensorProto(nullptr, std::move(from)) {}
   inline SparseTensorProto& operator=(const SparseTensorProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline SparseTensorProto& operator=(SparseTensorProto&& 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 SparseTensorProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const SparseTensorProto* internal_default_instance() {
     return reinterpret_cast<const SparseTensorProto*>(
         &_SparseTensorProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 10;
   friend void swap(SparseTensorProto& a, SparseTensorProto& b) { a.Swap(&b); }
   inline void Swap(SparseTensorProto* 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(SparseTensorProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   SparseTensorProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<SparseTensorProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const SparseTensorProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const SparseTensorProto& from) { SparseTensorProto::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(SparseTensorProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.SparseTensorProto"; }
 
  protected:
   explicit SparseTensorProto(::google::protobuf::Arena* arena);
   SparseTensorProto(::google::protobuf::Arena* arena, const SparseTensorProto& from);
   SparseTensorProto(::google::protobuf::Arena* arena, SparseTensorProto&& from) noexcept
       : SparseTensorProto(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 {
     kDimsFieldNumber = 3,
     kValuesFieldNumber = 1,
     kIndicesFieldNumber = 2,
   };
   // repeated int64 dims = 3;
   int dims_size() const;
   private:
   int _internal_dims_size() const;
 
   public:
   void clear_dims() ;
   ::int64_t dims(int index) const;
   void set_dims(int index, ::int64_t value);
   void add_dims(::int64_t value);
   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
   ::google::protobuf::RepeatedField<::int64_t>* mutable_dims();
 
   private:
   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_dims();
 
   public:
   // optional .onnx.TensorProto values = 1;
   bool has_values() const;
   void clear_values() ;
   const ::onnx::TensorProto& values() const;
   PROTOBUF_NODISCARD ::onnx::TensorProto* release_values();
   ::onnx::TensorProto* mutable_values();
   void set_allocated_values(::onnx::TensorProto* value);
   void unsafe_arena_set_allocated_values(::onnx::TensorProto* value);
   ::onnx::TensorProto* unsafe_arena_release_values();
 
   private:
   const ::onnx::TensorProto& _internal_values() const;
   ::onnx::TensorProto* _internal_mutable_values();
 
   public:
   // optional .onnx.TensorProto indices = 2;
   bool has_indices() const;
   void clear_indices() ;
   const ::onnx::TensorProto& indices() const;
   PROTOBUF_NODISCARD ::onnx::TensorProto* release_indices();
   ::onnx::TensorProto* mutable_indices();
   void set_allocated_indices(::onnx::TensorProto* value);
   void unsafe_arena_set_allocated_indices(::onnx::TensorProto* value);
   ::onnx::TensorProto* unsafe_arena_release_indices();
 
   private:
   const ::onnx::TensorProto& _internal_indices() const;
   ::onnx::TensorProto* _internal_mutable_indices();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       2, 3, 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 SparseTensorProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedField<::int64_t> dims_;
     ::onnx::TensorProto* values_;
     ::onnx::TensorProto* indices_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
  public:
   inline TypeProto() : TypeProto(nullptr) {}
   ~TypeProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto(const TypeProto& from) : TypeProto(nullptr, from) {}
   inline TypeProto(TypeProto&& from) noexcept
       : TypeProto(nullptr, std::move(from)) {}
   inline TypeProto& operator=(const TypeProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto& operator=(TypeProto&& 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 TypeProto& default_instance() {
     return *internal_default_instance();
   }
   enum ValueCase {
     kTensorType = 1,
     kSequenceType = 4,
     kMapType = 5,
     kOptionalType = 9,
     kSparseTensorType = 8,
     kOpaqueType = 7,
     VALUE_NOT_SET = 0,
   };
   static inline const TypeProto* internal_default_instance() {
     return reinterpret_cast<const TypeProto*>(
         &_TypeProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 19;
   friend void swap(TypeProto& a, TypeProto& b) { a.Swap(&b); }
   inline void Swap(TypeProto* 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(TypeProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto& from) { TypeProto::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(TypeProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto"; }
 
  protected:
   explicit TypeProto(::google::protobuf::Arena* arena);
   TypeProto(::google::protobuf::Arena* arena, const TypeProto& from);
   TypeProto(::google::protobuf::Arena* arena, TypeProto&& from) noexcept
       : TypeProto(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 Tensor = TypeProto_Tensor;
   using Sequence = TypeProto_Sequence;
   using Map = TypeProto_Map;
   using Optional = TypeProto_Optional;
   using SparseTensor = TypeProto_SparseTensor;
   using Opaque = TypeProto_Opaque;
 
   // accessors -------------------------------------------------------
   enum : int {
     kDenotationFieldNumber = 6,
     kTensorTypeFieldNumber = 1,
     kSequenceTypeFieldNumber = 4,
     kMapTypeFieldNumber = 5,
     kOptionalTypeFieldNumber = 9,
     kSparseTensorTypeFieldNumber = 8,
     kOpaqueTypeFieldNumber = 7,
   };
   // optional string denotation = 6;
   bool has_denotation() const;
   void clear_denotation() ;
   const std::string& denotation() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_denotation(Arg_&& arg, Args_... args);
   std::string* mutable_denotation();
   PROTOBUF_NODISCARD std::string* release_denotation();
   void set_allocated_denotation(std::string* value);
 
   private:
   const std::string& _internal_denotation() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(
       const std::string& value);
   std::string* _internal_mutable_denotation();
 
   public:
   // .onnx.TypeProto.Tensor tensor_type = 1;
   bool has_tensor_type() const;
   private:
   bool _internal_has_tensor_type() const;
 
   public:
   void clear_tensor_type() ;
   const ::onnx::TypeProto_Tensor& tensor_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_Tensor* release_tensor_type();
   ::onnx::TypeProto_Tensor* mutable_tensor_type();
   void set_allocated_tensor_type(::onnx::TypeProto_Tensor* value);
   void unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* value);
   ::onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
 
   private:
   const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
   ::onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
 
   public:
   // .onnx.TypeProto.Sequence sequence_type = 4;
   bool has_sequence_type() const;
   private:
   bool _internal_has_sequence_type() const;
 
   public:
   void clear_sequence_type() ;
   const ::onnx::TypeProto_Sequence& sequence_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_Sequence* release_sequence_type();
   ::onnx::TypeProto_Sequence* mutable_sequence_type();
   void set_allocated_sequence_type(::onnx::TypeProto_Sequence* value);
   void unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* value);
   ::onnx::TypeProto_Sequence* unsafe_arena_release_sequence_type();
 
   private:
   const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
   ::onnx::TypeProto_Sequence* _internal_mutable_sequence_type();
 
   public:
   // .onnx.TypeProto.Map map_type = 5;
   bool has_map_type() const;
   private:
   bool _internal_has_map_type() const;
 
   public:
   void clear_map_type() ;
   const ::onnx::TypeProto_Map& map_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_Map* release_map_type();
   ::onnx::TypeProto_Map* mutable_map_type();
   void set_allocated_map_type(::onnx::TypeProto_Map* value);
   void unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* value);
   ::onnx::TypeProto_Map* unsafe_arena_release_map_type();
 
   private:
   const ::onnx::TypeProto_Map& _internal_map_type() const;
   ::onnx::TypeProto_Map* _internal_mutable_map_type();
 
   public:
   // .onnx.TypeProto.Optional optional_type = 9;
   bool has_optional_type() const;
   private:
   bool _internal_has_optional_type() const;
 
   public:
   void clear_optional_type() ;
   const ::onnx::TypeProto_Optional& optional_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_Optional* release_optional_type();
   ::onnx::TypeProto_Optional* mutable_optional_type();
   void set_allocated_optional_type(::onnx::TypeProto_Optional* value);
   void unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* value);
   ::onnx::TypeProto_Optional* unsafe_arena_release_optional_type();
 
   private:
   const ::onnx::TypeProto_Optional& _internal_optional_type() const;
   ::onnx::TypeProto_Optional* _internal_mutable_optional_type();
 
   public:
   // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
   bool has_sparse_tensor_type() const;
   private:
   bool _internal_has_sparse_tensor_type() const;
 
   public:
   void clear_sparse_tensor_type() ;
   const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_SparseTensor* release_sparse_tensor_type();
   ::onnx::TypeProto_SparseTensor* mutable_sparse_tensor_type();
   void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value);
   void unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value);
   ::onnx::TypeProto_SparseTensor* unsafe_arena_release_sparse_tensor_type();
 
   private:
   const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
   ::onnx::TypeProto_SparseTensor* _internal_mutable_sparse_tensor_type();
 
   public:
   // .onnx.TypeProto.Opaque opaque_type = 7;
   bool has_opaque_type() const;
   private:
   bool _internal_has_opaque_type() const;
 
   public:
   void clear_opaque_type() ;
   const ::onnx::TypeProto_Opaque& opaque_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto_Opaque* release_opaque_type();
   ::onnx::TypeProto_Opaque* mutable_opaque_type();
   void set_allocated_opaque_type(::onnx::TypeProto_Opaque* value);
   void unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* value);
   ::onnx::TypeProto_Opaque* unsafe_arena_release_opaque_type();
 
   private:
   const ::onnx::TypeProto_Opaque& _internal_opaque_type() const;
   ::onnx::TypeProto_Opaque* _internal_mutable_opaque_type();
 
   public:
   void clear_value();
   ValueCase value_case() const;
   // @@protoc_insertion_point(class_scope:onnx.TypeProto)
  private:
   class _Internal;
   void set_has_tensor_type();
   void set_has_sequence_type();
   void set_has_map_type();
   void set_has_optional_type();
   void set_has_sparse_tensor_type();
   void set_has_opaque_type();
   inline bool has_value() const;
   inline void clear_has_value();
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       0, 7, 6,
       33, 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 TypeProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr denotation_;
     union ValueUnion {
       constexpr ValueUnion() : _constinit_{} {}
       ::google::protobuf::internal::ConstantInitialized _constinit_;
       ::onnx::TypeProto_Tensor* tensor_type_;
       ::onnx::TypeProto_Sequence* sequence_type_;
       ::onnx::TypeProto_Map* map_type_;
       ::onnx::TypeProto_Optional* optional_type_;
       ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
       ::onnx::TypeProto_Opaque* opaque_type_;
     } value_;
     ::uint32_t _oneof_case_[1];
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_Map final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
  public:
   inline TypeProto_Map() : TypeProto_Map(nullptr) {}
   ~TypeProto_Map() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_Map(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_Map(const TypeProto_Map& from) : TypeProto_Map(nullptr, from) {}
   inline TypeProto_Map(TypeProto_Map&& from) noexcept
       : TypeProto_Map(nullptr, std::move(from)) {}
   inline TypeProto_Map& operator=(const TypeProto_Map& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_Map& operator=(TypeProto_Map&& 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 TypeProto_Map& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_Map* internal_default_instance() {
     return reinterpret_cast<const TypeProto_Map*>(
         &_TypeProto_Map_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 15;
   friend void swap(TypeProto_Map& a, TypeProto_Map& b) { a.Swap(&b); }
   inline void Swap(TypeProto_Map* 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(TypeProto_Map* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_Map* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Map>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_Map& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_Map& from) { TypeProto_Map::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(TypeProto_Map* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Map"; }
 
  protected:
   explicit TypeProto_Map(::google::protobuf::Arena* arena);
   TypeProto_Map(::google::protobuf::Arena* arena, const TypeProto_Map& from);
   TypeProto_Map(::google::protobuf::Arena* arena, TypeProto_Map&& from) noexcept
       : TypeProto_Map(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 {
     kValueTypeFieldNumber = 2,
     kKeyTypeFieldNumber = 1,
   };
   // optional .onnx.TypeProto value_type = 2;
   bool has_value_type() const;
   void clear_value_type() ;
   const ::onnx::TypeProto& value_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto* release_value_type();
   ::onnx::TypeProto* mutable_value_type();
   void set_allocated_value_type(::onnx::TypeProto* value);
   void unsafe_arena_set_allocated_value_type(::onnx::TypeProto* value);
   ::onnx::TypeProto* unsafe_arena_release_value_type();
 
   private:
   const ::onnx::TypeProto& _internal_value_type() const;
   ::onnx::TypeProto* _internal_mutable_value_type();
 
   public:
   // optional int32 key_type = 1;
   bool has_key_type() const;
   void clear_key_type() ;
   ::int32_t key_type() const;
   void set_key_type(::int32_t value);
 
   private:
   ::int32_t _internal_key_type() const;
   void _internal_set_key_type(::int32_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map)
  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 TypeProto_Map& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::onnx::TypeProto* value_type_;
     ::int32_t key_type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_Optional final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
  public:
   inline TypeProto_Optional() : TypeProto_Optional(nullptr) {}
   ~TypeProto_Optional() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_Optional(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_Optional(const TypeProto_Optional& from) : TypeProto_Optional(nullptr, from) {}
   inline TypeProto_Optional(TypeProto_Optional&& from) noexcept
       : TypeProto_Optional(nullptr, std::move(from)) {}
   inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_Optional& operator=(TypeProto_Optional&& 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 TypeProto_Optional& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_Optional* internal_default_instance() {
     return reinterpret_cast<const TypeProto_Optional*>(
         &_TypeProto_Optional_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 16;
   friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) { a.Swap(&b); }
   inline void Swap(TypeProto_Optional* 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(TypeProto_Optional* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_Optional* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Optional>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_Optional& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_Optional& from) { TypeProto_Optional::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(TypeProto_Optional* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Optional"; }
 
  protected:
   explicit TypeProto_Optional(::google::protobuf::Arena* arena);
   TypeProto_Optional(::google::protobuf::Arena* arena, const TypeProto_Optional& from);
   TypeProto_Optional(::google::protobuf::Arena* arena, TypeProto_Optional&& from) noexcept
       : TypeProto_Optional(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 {
     kElemTypeFieldNumber = 1,
   };
   // optional .onnx.TypeProto elem_type = 1;
   bool has_elem_type() const;
   void clear_elem_type() ;
   const ::onnx::TypeProto& elem_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto* release_elem_type();
   ::onnx::TypeProto* mutable_elem_type();
   void set_allocated_elem_type(::onnx::TypeProto* value);
   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value);
   ::onnx::TypeProto* unsafe_arena_release_elem_type();
 
   private:
   const ::onnx::TypeProto& _internal_elem_type() const;
   ::onnx::TypeProto* _internal_mutable_elem_type();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       0, 1, 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 TypeProto_Optional& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::onnx::TypeProto* elem_type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TypeProto_Sequence final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
  public:
   inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {}
   ~TypeProto_Sequence() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TypeProto_Sequence(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TypeProto_Sequence(const TypeProto_Sequence& from) : TypeProto_Sequence(nullptr, from) {}
   inline TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
       : TypeProto_Sequence(nullptr, std::move(from)) {}
   inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
     CopyFrom(from);
     return *this;
   }
   inline TypeProto_Sequence& operator=(TypeProto_Sequence&& 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 TypeProto_Sequence& default_instance() {
     return *internal_default_instance();
   }
   static inline const TypeProto_Sequence* internal_default_instance() {
     return reinterpret_cast<const TypeProto_Sequence*>(
         &_TypeProto_Sequence_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 14;
   friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) { a.Swap(&b); }
   inline void Swap(TypeProto_Sequence* 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(TypeProto_Sequence* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TypeProto_Sequence* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Sequence>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TypeProto_Sequence& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TypeProto_Sequence& from) { TypeProto_Sequence::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(TypeProto_Sequence* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Sequence"; }
 
  protected:
   explicit TypeProto_Sequence(::google::protobuf::Arena* arena);
   TypeProto_Sequence(::google::protobuf::Arena* arena, const TypeProto_Sequence& from);
   TypeProto_Sequence(::google::protobuf::Arena* arena, TypeProto_Sequence&& from) noexcept
       : TypeProto_Sequence(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 {
     kElemTypeFieldNumber = 1,
   };
   // optional .onnx.TypeProto elem_type = 1;
   bool has_elem_type() const;
   void clear_elem_type() ;
   const ::onnx::TypeProto& elem_type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto* release_elem_type();
   ::onnx::TypeProto* mutable_elem_type();
   void set_allocated_elem_type(::onnx::TypeProto* value);
   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value);
   ::onnx::TypeProto* unsafe_arena_release_elem_type();
 
   private:
   const ::onnx::TypeProto& _internal_elem_type() const;
   ::onnx::TypeProto* _internal_mutable_elem_type();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       0, 1, 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 TypeProto_Sequence& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::onnx::TypeProto* elem_type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API ValueInfoProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
  public:
   inline ValueInfoProto() : ValueInfoProto(nullptr) {}
   ~ValueInfoProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR ValueInfoProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline ValueInfoProto(const ValueInfoProto& from) : ValueInfoProto(nullptr, from) {}
   inline ValueInfoProto(ValueInfoProto&& from) noexcept
       : ValueInfoProto(nullptr, std::move(from)) {}
   inline ValueInfoProto& operator=(const ValueInfoProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline ValueInfoProto& operator=(ValueInfoProto&& 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 ValueInfoProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const ValueInfoProto* internal_default_instance() {
     return reinterpret_cast<const ValueInfoProto*>(
         &_ValueInfoProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 1;
   friend void swap(ValueInfoProto& a, ValueInfoProto& b) { a.Swap(&b); }
   inline void Swap(ValueInfoProto* 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(ValueInfoProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   ValueInfoProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<ValueInfoProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const ValueInfoProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const ValueInfoProto& from) { ValueInfoProto::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(ValueInfoProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.ValueInfoProto"; }
 
  protected:
   explicit ValueInfoProto(::google::protobuf::Arena* arena);
   ValueInfoProto(::google::protobuf::Arena* arena, const ValueInfoProto& from);
   ValueInfoProto(::google::protobuf::Arena* arena, ValueInfoProto&& from) noexcept
       : ValueInfoProto(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 {
     kNameFieldNumber = 1,
     kDocStringFieldNumber = 3,
     kTypeFieldNumber = 2,
   };
   // optional string name = 1;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional string doc_string = 3;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional .onnx.TypeProto type = 2;
   bool has_type() const;
   void clear_type() ;
   const ::onnx::TypeProto& type() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto* release_type();
   ::onnx::TypeProto* mutable_type();
   void set_allocated_type(::onnx::TypeProto* value);
   void unsafe_arena_set_allocated_type(::onnx::TypeProto* value);
   ::onnx::TypeProto* unsafe_arena_release_type();
 
   private:
   const ::onnx::TypeProto& _internal_type() const;
   ::onnx::TypeProto* _internal_mutable_type();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       2, 3, 1,
       42, 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 ValueInfoProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::onnx::TypeProto* type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API AttributeProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
  public:
   inline AttributeProto() : AttributeProto(nullptr) {}
   ~AttributeProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR AttributeProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline AttributeProto(const AttributeProto& from) : AttributeProto(nullptr, from) {}
   inline AttributeProto(AttributeProto&& from) noexcept
       : AttributeProto(nullptr, std::move(from)) {}
   inline AttributeProto& operator=(const AttributeProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline AttributeProto& operator=(AttributeProto&& 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 AttributeProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const AttributeProto* internal_default_instance() {
     return reinterpret_cast<const AttributeProto*>(
         &_AttributeProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 0;
   friend void swap(AttributeProto& a, AttributeProto& b) { a.Swap(&b); }
   inline void Swap(AttributeProto* 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(AttributeProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   AttributeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<AttributeProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const AttributeProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const AttributeProto& from) { AttributeProto::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(AttributeProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.AttributeProto"; }
 
  protected:
   explicit AttributeProto(::google::protobuf::Arena* arena);
   AttributeProto(::google::protobuf::Arena* arena, const AttributeProto& from);
   AttributeProto(::google::protobuf::Arena* arena, AttributeProto&& from) noexcept
       : AttributeProto(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 AttributeType = AttributeProto_AttributeType;
   static constexpr AttributeType UNDEFINED = AttributeProto_AttributeType_UNDEFINED;
   static constexpr AttributeType FLOAT = AttributeProto_AttributeType_FLOAT;
   static constexpr AttributeType INT = AttributeProto_AttributeType_INT;
   static constexpr AttributeType STRING = AttributeProto_AttributeType_STRING;
   static constexpr AttributeType TENSOR = AttributeProto_AttributeType_TENSOR;
   static constexpr AttributeType GRAPH = AttributeProto_AttributeType_GRAPH;
   static constexpr AttributeType SPARSE_TENSOR = AttributeProto_AttributeType_SPARSE_TENSOR;
   static constexpr AttributeType TYPE_PROTO = AttributeProto_AttributeType_TYPE_PROTO;
   static constexpr AttributeType FLOATS = AttributeProto_AttributeType_FLOATS;
   static constexpr AttributeType INTS = AttributeProto_AttributeType_INTS;
   static constexpr AttributeType STRINGS = AttributeProto_AttributeType_STRINGS;
   static constexpr AttributeType TENSORS = AttributeProto_AttributeType_TENSORS;
   static constexpr AttributeType GRAPHS = AttributeProto_AttributeType_GRAPHS;
   static constexpr AttributeType SPARSE_TENSORS = AttributeProto_AttributeType_SPARSE_TENSORS;
   static constexpr AttributeType TYPE_PROTOS = AttributeProto_AttributeType_TYPE_PROTOS;
   static inline bool AttributeType_IsValid(int value) {
     return AttributeProto_AttributeType_IsValid(value);
   }
   static constexpr AttributeType AttributeType_MIN = AttributeProto_AttributeType_AttributeType_MIN;
   static constexpr AttributeType AttributeType_MAX = AttributeProto_AttributeType_AttributeType_MAX;
   static constexpr int AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
   static inline const ::google::protobuf::EnumDescriptor* AttributeType_descriptor() {
     return AttributeProto_AttributeType_descriptor();
   }
   template <typename T>
   static inline const std::string& AttributeType_Name(T value) {
     return AttributeProto_AttributeType_Name(value);
   }
   static inline bool AttributeType_Parse(absl::string_view name, AttributeType* value) {
     return AttributeProto_AttributeType_Parse(name, value);
   }
 
   // accessors -------------------------------------------------------
   enum : int {
     kFloatsFieldNumber = 7,
     kIntsFieldNumber = 8,
     kStringsFieldNumber = 9,
     kTensorsFieldNumber = 10,
     kGraphsFieldNumber = 11,
     kTypeProtosFieldNumber = 15,
     kSparseTensorsFieldNumber = 23,
     kNameFieldNumber = 1,
     kSFieldNumber = 4,
     kDocStringFieldNumber = 13,
     kRefAttrNameFieldNumber = 21,
     kTFieldNumber = 5,
     kGFieldNumber = 6,
     kTpFieldNumber = 14,
     kSparseTensorFieldNumber = 22,
     kIFieldNumber = 3,
     kFFieldNumber = 2,
     kTypeFieldNumber = 20,
   };
   // repeated float floats = 7;
   int floats_size() const;
   private:
   int _internal_floats_size() const;
 
   public:
   void clear_floats() ;
   float floats(int index) const;
   void set_floats(int index, float value);
   void add_floats(float value);
   const ::google::protobuf::RepeatedField<float>& floats() const;
   ::google::protobuf::RepeatedField<float>* mutable_floats();
 
   private:
   const ::google::protobuf::RepeatedField<float>& _internal_floats() const;
   ::google::protobuf::RepeatedField<float>* _internal_mutable_floats();
 
   public:
   // repeated int64 ints = 8;
   int ints_size() const;
   private:
   int _internal_ints_size() const;
 
   public:
   void clear_ints() ;
   ::int64_t ints(int index) const;
   void set_ints(int index, ::int64_t value);
   void add_ints(::int64_t value);
   const ::google::protobuf::RepeatedField<::int64_t>& ints() const;
   ::google::protobuf::RepeatedField<::int64_t>* mutable_ints();
 
   private:
   const ::google::protobuf::RepeatedField<::int64_t>& _internal_ints() const;
   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_ints();
 
   public:
   // repeated bytes strings = 9;
   int strings_size() const;
   private:
   int _internal_strings_size() const;
 
   public:
   void clear_strings() ;
   const std::string& strings(int index) const;
   std::string* mutable_strings(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_strings(int index, Arg_&& value, Args_... args);
   std::string* add_strings();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_strings(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& strings() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_strings();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_strings() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_strings();
 
   public:
   // repeated .onnx.TensorProto tensors = 10;
   int tensors_size() const;
   private:
   int _internal_tensors_size() const;
 
   public:
   void clear_tensors() ;
   ::onnx::TensorProto* mutable_tensors(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* mutable_tensors();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensors() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* _internal_mutable_tensors();
   public:
   const ::onnx::TensorProto& tensors(int index) const;
   ::onnx::TensorProto* add_tensors();
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensors() const;
   // repeated .onnx.GraphProto graphs = 11;
   int graphs_size() const;
   private:
   int _internal_graphs_size() const;
 
   public:
   void clear_graphs() ;
   ::onnx::GraphProto* mutable_graphs(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* mutable_graphs();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& _internal_graphs() const;
   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* _internal_mutable_graphs();
   public:
   const ::onnx::GraphProto& graphs(int index) const;
   ::onnx::GraphProto* add_graphs();
   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& graphs() const;
   // repeated .onnx.TypeProto type_protos = 15;
   int type_protos_size() const;
   private:
   int _internal_type_protos_size() const;
 
   public:
   void clear_type_protos() ;
   ::onnx::TypeProto* mutable_type_protos(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* mutable_type_protos();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& _internal_type_protos() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* _internal_mutable_type_protos();
   public:
   const ::onnx::TypeProto& type_protos(int index) const;
   ::onnx::TypeProto* add_type_protos();
   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& type_protos() const;
   // repeated .onnx.SparseTensorProto sparse_tensors = 23;
   int sparse_tensors_size() const;
   private:
   int _internal_sparse_tensors_size() const;
 
   public:
   void clear_sparse_tensors() ;
   ::onnx::SparseTensorProto* mutable_sparse_tensors(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* mutable_sparse_tensors();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensors() const;
   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* _internal_mutable_sparse_tensors();
   public:
   const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
   ::onnx::SparseTensorProto* add_sparse_tensors();
   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensors() const;
   // optional string name = 1;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional bytes s = 4;
   bool has_s() const;
   void clear_s() ;
   const std::string& s() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_s(Arg_&& arg, Args_... args);
   std::string* mutable_s();
   PROTOBUF_NODISCARD std::string* release_s();
   void set_allocated_s(std::string* value);
 
   private:
   const std::string& _internal_s() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(
       const std::string& value);
   std::string* _internal_mutable_s();
 
   public:
   // optional string doc_string = 13;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional string ref_attr_name = 21;
   bool has_ref_attr_name() const;
   void clear_ref_attr_name() ;
   const std::string& ref_attr_name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_ref_attr_name(Arg_&& arg, Args_... args);
   std::string* mutable_ref_attr_name();
   PROTOBUF_NODISCARD std::string* release_ref_attr_name();
   void set_allocated_ref_attr_name(std::string* value);
 
   private:
   const std::string& _internal_ref_attr_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(
       const std::string& value);
   std::string* _internal_mutable_ref_attr_name();
 
   public:
   // optional .onnx.TensorProto t = 5;
   bool has_t() const;
   void clear_t() ;
   const ::onnx::TensorProto& t() const;
   PROTOBUF_NODISCARD ::onnx::TensorProto* release_t();
   ::onnx::TensorProto* mutable_t();
   void set_allocated_t(::onnx::TensorProto* value);
   void unsafe_arena_set_allocated_t(::onnx::TensorProto* value);
   ::onnx::TensorProto* unsafe_arena_release_t();
 
   private:
   const ::onnx::TensorProto& _internal_t() const;
   ::onnx::TensorProto* _internal_mutable_t();
 
   public:
   // optional .onnx.GraphProto g = 6;
   bool has_g() const;
   void clear_g() ;
   const ::onnx::GraphProto& g() const;
   PROTOBUF_NODISCARD ::onnx::GraphProto* release_g();
   ::onnx::GraphProto* mutable_g();
   void set_allocated_g(::onnx::GraphProto* value);
   void unsafe_arena_set_allocated_g(::onnx::GraphProto* value);
   ::onnx::GraphProto* unsafe_arena_release_g();
 
   private:
   const ::onnx::GraphProto& _internal_g() const;
   ::onnx::GraphProto* _internal_mutable_g();
 
   public:
   // optional .onnx.TypeProto tp = 14;
   bool has_tp() const;
   void clear_tp() ;
   const ::onnx::TypeProto& tp() const;
   PROTOBUF_NODISCARD ::onnx::TypeProto* release_tp();
   ::onnx::TypeProto* mutable_tp();
   void set_allocated_tp(::onnx::TypeProto* value);
   void unsafe_arena_set_allocated_tp(::onnx::TypeProto* value);
   ::onnx::TypeProto* unsafe_arena_release_tp();
 
   private:
   const ::onnx::TypeProto& _internal_tp() const;
   ::onnx::TypeProto* _internal_mutable_tp();
 
   public:
   // optional .onnx.SparseTensorProto sparse_tensor = 22;
   bool has_sparse_tensor() const;
   void clear_sparse_tensor() ;
   const ::onnx::SparseTensorProto& sparse_tensor() const;
   PROTOBUF_NODISCARD ::onnx::SparseTensorProto* release_sparse_tensor();
   ::onnx::SparseTensorProto* mutable_sparse_tensor();
   void set_allocated_sparse_tensor(::onnx::SparseTensorProto* value);
   void unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* value);
   ::onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor();
 
   private:
   const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
   ::onnx::SparseTensorProto* _internal_mutable_sparse_tensor();
 
   public:
   // optional int64 i = 3;
   bool has_i() const;
   void clear_i() ;
   ::int64_t i() const;
   void set_i(::int64_t value);
 
   private:
   ::int64_t _internal_i() const;
   void _internal_set_i(::int64_t value);
 
   public:
   // optional float f = 2;
   bool has_f() const;
   void clear_f() ;
   float f() const;
   void set_f(float value);
 
   private:
   float _internal_f() const;
   void _internal_set_f(float value);
 
   public:
   // optional .onnx.AttributeProto.AttributeType type = 20;
   bool has_type() const;
   void clear_type() ;
   ::onnx::AttributeProto_AttributeType type() const;
   void set_type(::onnx::AttributeProto_AttributeType value);
 
   private:
   ::onnx::AttributeProto_AttributeType _internal_type() const;
   void _internal_set_type(::onnx::AttributeProto_AttributeType value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       5, 18, 9,
       71, 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 AttributeProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedField<float> floats_;
     ::google::protobuf::RepeatedField<::int64_t> ints_;
     ::google::protobuf::RepeatedPtrField<std::string> strings_;
     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensors_;
     ::google::protobuf::RepeatedPtrField< ::onnx::GraphProto > graphs_;
     ::google::protobuf::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr s_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
     ::onnx::TensorProto* t_;
     ::onnx::GraphProto* g_;
     ::onnx::TypeProto* tp_;
     ::onnx::SparseTensorProto* sparse_tensor_;
     ::int64_t i_;
     float f_;
     int type_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API GraphProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
  public:
   inline GraphProto() : GraphProto(nullptr) {}
   ~GraphProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR GraphProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline GraphProto(const GraphProto& from) : GraphProto(nullptr, from) {}
   inline GraphProto(GraphProto&& from) noexcept
       : GraphProto(nullptr, std::move(from)) {}
   inline GraphProto& operator=(const GraphProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline GraphProto& operator=(GraphProto&& 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 GraphProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const GraphProto* internal_default_instance() {
     return reinterpret_cast<const GraphProto*>(
         &_GraphProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 7;
   friend void swap(GraphProto& a, GraphProto& b) { a.Swap(&b); }
   inline void Swap(GraphProto* 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(GraphProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   GraphProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<GraphProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const GraphProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const GraphProto& from) { GraphProto::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(GraphProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.GraphProto"; }
 
  protected:
   explicit GraphProto(::google::protobuf::Arena* arena);
   GraphProto(::google::protobuf::Arena* arena, const GraphProto& from);
   GraphProto(::google::protobuf::Arena* arena, GraphProto&& from) noexcept
       : GraphProto(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 {
     kNodeFieldNumber = 1,
     kInitializerFieldNumber = 5,
     kInputFieldNumber = 11,
     kOutputFieldNumber = 12,
     kValueInfoFieldNumber = 13,
     kQuantizationAnnotationFieldNumber = 14,
     kSparseInitializerFieldNumber = 15,
     kNameFieldNumber = 2,
     kDocStringFieldNumber = 10,
   };
   // repeated .onnx.NodeProto node = 1;
   int node_size() const;
   private:
   int _internal_node_size() const;
 
   public:
   void clear_node() ;
   ::onnx::NodeProto* mutable_node(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* mutable_node();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* _internal_mutable_node();
   public:
   const ::onnx::NodeProto& node(int index) const;
   ::onnx::NodeProto* add_node();
   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
   // repeated .onnx.TensorProto initializer = 5;
   int initializer_size() const;
   private:
   int _internal_initializer_size() const;
 
   public:
   void clear_initializer() ;
   ::onnx::TensorProto* mutable_initializer(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* mutable_initializer();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_initializer() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* _internal_mutable_initializer();
   public:
   const ::onnx::TensorProto& initializer(int index) const;
   ::onnx::TensorProto* add_initializer();
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& initializer() const;
   // repeated .onnx.ValueInfoProto input = 11;
   int input_size() const;
   private:
   int _internal_input_size() const;
 
   public:
   void clear_input() ;
   ::onnx::ValueInfoProto* mutable_input(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_input();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_input() const;
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_input();
   public:
   const ::onnx::ValueInfoProto& input(int index) const;
   ::onnx::ValueInfoProto* add_input();
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& input() const;
   // repeated .onnx.ValueInfoProto output = 12;
   int output_size() const;
   private:
   int _internal_output_size() const;
 
   public:
   void clear_output() ;
   ::onnx::ValueInfoProto* mutable_output(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_output();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_output() const;
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_output();
   public:
   const ::onnx::ValueInfoProto& output(int index) const;
   ::onnx::ValueInfoProto* add_output();
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& output() const;
   // repeated .onnx.ValueInfoProto value_info = 13;
   int value_info_size() const;
   private:
   int _internal_value_info_size() const;
 
   public:
   void clear_value_info() ;
   ::onnx::ValueInfoProto* mutable_value_info(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_value_info();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_value_info();
   public:
   const ::onnx::ValueInfoProto& value_info(int index) const;
   ::onnx::ValueInfoProto* add_value_info();
   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info() const;
   // repeated .onnx.TensorAnnotation quantization_annotation = 14;
   int quantization_annotation_size() const;
   private:
   int _internal_quantization_annotation_size() const;
 
   public:
   void clear_quantization_annotation() ;
   ::onnx::TensorAnnotation* mutable_quantization_annotation(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* mutable_quantization_annotation();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& _internal_quantization_annotation() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* _internal_mutable_quantization_annotation();
   public:
   const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
   ::onnx::TensorAnnotation* add_quantization_annotation();
   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& quantization_annotation() const;
   // repeated .onnx.SparseTensorProto sparse_initializer = 15;
   int sparse_initializer_size() const;
   private:
   int _internal_sparse_initializer_size() const;
 
   public:
   void clear_sparse_initializer() ;
   ::onnx::SparseTensorProto* mutable_sparse_initializer(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* mutable_sparse_initializer();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_initializer() const;
   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* _internal_mutable_sparse_initializer();
   public:
   const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
   ::onnx::SparseTensorProto* add_sparse_initializer();
   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_initializer() const;
   // optional string name = 2;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional string doc_string = 10;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.GraphProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       4, 9, 7,
       46, 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 GraphProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > initializer_;
     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
     ::google::protobuf::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API NodeProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
  public:
   inline NodeProto() : NodeProto(nullptr) {}
   ~NodeProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR NodeProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline NodeProto(const NodeProto& from) : NodeProto(nullptr, from) {}
   inline NodeProto(NodeProto&& from) noexcept
       : NodeProto(nullptr, std::move(from)) {}
   inline NodeProto& operator=(const NodeProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline NodeProto& operator=(NodeProto&& 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 NodeProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const NodeProto* internal_default_instance() {
     return reinterpret_cast<const NodeProto*>(
         &_NodeProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 2;
   friend void swap(NodeProto& a, NodeProto& b) { a.Swap(&b); }
   inline void Swap(NodeProto* 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(NodeProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   NodeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<NodeProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const NodeProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const NodeProto& from) { NodeProto::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(NodeProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.NodeProto"; }
 
  protected:
   explicit NodeProto(::google::protobuf::Arena* arena);
   NodeProto(::google::protobuf::Arena* arena, const NodeProto& from);
   NodeProto(::google::protobuf::Arena* arena, NodeProto&& from) noexcept
       : NodeProto(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 {
     kInputFieldNumber = 1,
     kOutputFieldNumber = 2,
     kAttributeFieldNumber = 5,
     kNameFieldNumber = 3,
     kOpTypeFieldNumber = 4,
     kDocStringFieldNumber = 6,
     kDomainFieldNumber = 7,
   };
   // repeated string input = 1;
   int input_size() const;
   private:
   int _internal_input_size() const;
 
   public:
   void clear_input() ;
   const std::string& input(int index) const;
   std::string* mutable_input(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_input(int index, Arg_&& value, Args_... args);
   std::string* add_input();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_input(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& input() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_input();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_input() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_input();
 
   public:
   // repeated string output = 2;
   int output_size() const;
   private:
   int _internal_output_size() const;
 
   public:
   void clear_output() ;
   const std::string& output(int index) const;
   std::string* mutable_output(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_output(int index, Arg_&& value, Args_... args);
   std::string* add_output();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_output(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& output() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_output();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_output() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_output();
 
   public:
   // repeated .onnx.AttributeProto attribute = 5;
   int attribute_size() const;
   private:
   int _internal_attribute_size() const;
 
   public:
   void clear_attribute() ;
   ::onnx::AttributeProto* mutable_attribute(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* mutable_attribute();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute() const;
   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* _internal_mutable_attribute();
   public:
   const ::onnx::AttributeProto& attribute(int index) const;
   ::onnx::AttributeProto* add_attribute();
   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute() const;
   // optional string name = 3;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional string op_type = 4;
   bool has_op_type() const;
   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:
   // optional string doc_string = 6;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional string domain = 7;
   bool has_domain() const;
   void clear_domain() ;
   const std::string& domain() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_domain(Arg_&& arg, Args_... args);
   std::string* mutable_domain();
   PROTOBUF_NODISCARD std::string* release_domain();
   void set_allocated_domain(std::string* value);
 
   private:
   const std::string& _internal_domain() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
       const std::string& value);
   std::string* _internal_mutable_domain();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.NodeProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       3, 7, 1,
       61, 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 NodeProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField<std::string> input_;
     ::google::protobuf::RepeatedPtrField<std::string> output_;
     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr op_type_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::google::protobuf::internal::ArenaStringPtr domain_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API TrainingInfoProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
  public:
   inline TrainingInfoProto() : TrainingInfoProto(nullptr) {}
   ~TrainingInfoProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR TrainingInfoProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline TrainingInfoProto(const TrainingInfoProto& from) : TrainingInfoProto(nullptr, from) {}
   inline TrainingInfoProto(TrainingInfoProto&& from) noexcept
       : TrainingInfoProto(nullptr, std::move(from)) {}
   inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline TrainingInfoProto& operator=(TrainingInfoProto&& 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 TrainingInfoProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const TrainingInfoProto* internal_default_instance() {
     return reinterpret_cast<const TrainingInfoProto*>(
         &_TrainingInfoProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 3;
   friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) { a.Swap(&b); }
   inline void Swap(TrainingInfoProto* 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(TrainingInfoProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   TrainingInfoProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<TrainingInfoProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const TrainingInfoProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const TrainingInfoProto& from) { TrainingInfoProto::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(TrainingInfoProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.TrainingInfoProto"; }
 
  protected:
   explicit TrainingInfoProto(::google::protobuf::Arena* arena);
   TrainingInfoProto(::google::protobuf::Arena* arena, const TrainingInfoProto& from);
   TrainingInfoProto(::google::protobuf::Arena* arena, TrainingInfoProto&& from) noexcept
       : TrainingInfoProto(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 {
     kInitializationBindingFieldNumber = 3,
     kUpdateBindingFieldNumber = 4,
     kInitializationFieldNumber = 1,
     kAlgorithmFieldNumber = 2,
   };
   // repeated .onnx.StringStringEntryProto initialization_binding = 3;
   int initialization_binding_size() const;
   private:
   int _internal_initialization_binding_size() const;
 
   public:
   void clear_initialization_binding() ;
   ::onnx::StringStringEntryProto* mutable_initialization_binding(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_initialization_binding();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_initialization_binding() const;
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_initialization_binding();
   public:
   const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
   ::onnx::StringStringEntryProto* add_initialization_binding();
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& initialization_binding() const;
   // repeated .onnx.StringStringEntryProto update_binding = 4;
   int update_binding_size() const;
   private:
   int _internal_update_binding_size() const;
 
   public:
   void clear_update_binding() ;
   ::onnx::StringStringEntryProto* mutable_update_binding(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_update_binding();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_update_binding() const;
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_update_binding();
   public:
   const ::onnx::StringStringEntryProto& update_binding(int index) const;
   ::onnx::StringStringEntryProto* add_update_binding();
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& update_binding() const;
   // optional .onnx.GraphProto initialization = 1;
   bool has_initialization() const;
   void clear_initialization() ;
   const ::onnx::GraphProto& initialization() const;
   PROTOBUF_NODISCARD ::onnx::GraphProto* release_initialization();
   ::onnx::GraphProto* mutable_initialization();
   void set_allocated_initialization(::onnx::GraphProto* value);
   void unsafe_arena_set_allocated_initialization(::onnx::GraphProto* value);
   ::onnx::GraphProto* unsafe_arena_release_initialization();
 
   private:
   const ::onnx::GraphProto& _internal_initialization() const;
   ::onnx::GraphProto* _internal_mutable_initialization();
 
   public:
   // optional .onnx.GraphProto algorithm = 2;
   bool has_algorithm() const;
   void clear_algorithm() ;
   const ::onnx::GraphProto& algorithm() const;
   PROTOBUF_NODISCARD ::onnx::GraphProto* release_algorithm();
   ::onnx::GraphProto* mutable_algorithm();
   void set_allocated_algorithm(::onnx::GraphProto* value);
   void unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* value);
   ::onnx::GraphProto* unsafe_arena_release_algorithm();
 
   private:
   const ::onnx::GraphProto& _internal_algorithm() const;
   ::onnx::GraphProto* _internal_mutable_algorithm();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       2, 4, 4,
       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 TrainingInfoProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
     ::onnx::GraphProto* initialization_;
     ::onnx::GraphProto* algorithm_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API FunctionProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
  public:
   inline FunctionProto() : FunctionProto(nullptr) {}
   ~FunctionProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR FunctionProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline FunctionProto(const FunctionProto& from) : FunctionProto(nullptr, from) {}
   inline FunctionProto(FunctionProto&& from) noexcept
       : FunctionProto(nullptr, std::move(from)) {}
   inline FunctionProto& operator=(const FunctionProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline FunctionProto& operator=(FunctionProto&& 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 FunctionProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const FunctionProto* internal_default_instance() {
     return reinterpret_cast<const FunctionProto*>(
         &_FunctionProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 21;
   friend void swap(FunctionProto& a, FunctionProto& b) { a.Swap(&b); }
   inline void Swap(FunctionProto* 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(FunctionProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   FunctionProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<FunctionProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const FunctionProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const FunctionProto& from) { FunctionProto::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(FunctionProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.FunctionProto"; }
 
  protected:
   explicit FunctionProto(::google::protobuf::Arena* arena);
   FunctionProto(::google::protobuf::Arena* arena, const FunctionProto& from);
   FunctionProto(::google::protobuf::Arena* arena, FunctionProto&& from) noexcept
       : FunctionProto(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 {
     kInputFieldNumber = 4,
     kOutputFieldNumber = 5,
     kAttributeFieldNumber = 6,
     kNodeFieldNumber = 7,
     kOpsetImportFieldNumber = 9,
     kAttributeProtoFieldNumber = 11,
     kNameFieldNumber = 1,
     kDocStringFieldNumber = 8,
     kDomainFieldNumber = 10,
   };
   // repeated string input = 4;
   int input_size() const;
   private:
   int _internal_input_size() const;
 
   public:
   void clear_input() ;
   const std::string& input(int index) const;
   std::string* mutable_input(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_input(int index, Arg_&& value, Args_... args);
   std::string* add_input();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_input(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& input() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_input();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_input() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_input();
 
   public:
   // repeated string output = 5;
   int output_size() const;
   private:
   int _internal_output_size() const;
 
   public:
   void clear_output() ;
   const std::string& output(int index) const;
   std::string* mutable_output(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_output(int index, Arg_&& value, Args_... args);
   std::string* add_output();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_output(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& output() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_output();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_output() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_output();
 
   public:
   // repeated string attribute = 6;
   int attribute_size() const;
   private:
   int _internal_attribute_size() const;
 
   public:
   void clear_attribute() ;
   const std::string& attribute(int index) const;
   std::string* mutable_attribute(int index);
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_attribute(int index, Arg_&& value, Args_... args);
   std::string* add_attribute();
   template <typename Arg_ = const std::string&, typename... Args_>
   void add_attribute(Arg_&& value, Args_... args);
   const ::google::protobuf::RepeatedPtrField<std::string>& attribute() const;
   ::google::protobuf::RepeatedPtrField<std::string>* mutable_attribute();
 
   private:
   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_attribute() const;
   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_attribute();
 
   public:
   // repeated .onnx.NodeProto node = 7;
   int node_size() const;
   private:
   int _internal_node_size() const;
 
   public:
   void clear_node() ;
   ::onnx::NodeProto* mutable_node(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* mutable_node();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* _internal_mutable_node();
   public:
   const ::onnx::NodeProto& node(int index) const;
   ::onnx::NodeProto* add_node();
   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
   // repeated .onnx.OperatorSetIdProto opset_import = 9;
   int opset_import_size() const;
   private:
   int _internal_opset_import_size() const;
 
   public:
   void clear_opset_import() ;
   ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* mutable_opset_import();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* _internal_mutable_opset_import();
   public:
   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
   ::onnx::OperatorSetIdProto* add_opset_import();
   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
   // repeated .onnx.AttributeProto attribute_proto = 11;
   int attribute_proto_size() const;
   private:
   int _internal_attribute_proto_size() const;
 
   public:
   void clear_attribute_proto() ;
   ::onnx::AttributeProto* mutable_attribute_proto(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* mutable_attribute_proto();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute_proto() const;
   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* _internal_mutable_attribute_proto();
   public:
   const ::onnx::AttributeProto& attribute_proto(int index) const;
   ::onnx::AttributeProto* add_attribute_proto();
   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute_proto() const;
   // optional string name = 1;
   bool has_name() const;
   void clear_name() ;
   const std::string& name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_name(Arg_&& arg, Args_... args);
   std::string* mutable_name();
   PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* value);
 
   private:
   const std::string& _internal_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
       const std::string& value);
   std::string* _internal_mutable_name();
 
   public:
   // optional string doc_string = 8;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional string domain = 10;
   bool has_domain() const;
   void clear_domain() ;
   const std::string& domain() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_domain(Arg_&& arg, Args_... args);
   std::string* mutable_domain();
   PROTOBUF_NODISCARD std::string* release_domain();
   void set_allocated_domain(std::string* value);
 
   private:
   const std::string& _internal_domain() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
       const std::string& value);
   std::string* _internal_mutable_domain();
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       4, 9, 3,
       75, 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 FunctionProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField<std::string> input_;
     ::google::protobuf::RepeatedPtrField<std::string> output_;
     ::google::protobuf::RepeatedPtrField<std::string> attribute_;
     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
     ::google::protobuf::internal::ArenaStringPtr name_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::google::protobuf::internal::ArenaStringPtr domain_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 // -------------------------------------------------------------------
 
 class ONNX_API ModelProto final : public ::google::protobuf::Message
 /* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
  public:
   inline ModelProto() : ModelProto(nullptr) {}
   ~ModelProto() PROTOBUF_FINAL;
   template <typename = void>
   explicit PROTOBUF_CONSTEXPR ModelProto(
       ::google::protobuf::internal::ConstantInitialized);
 
   inline ModelProto(const ModelProto& from) : ModelProto(nullptr, from) {}
   inline ModelProto(ModelProto&& from) noexcept
       : ModelProto(nullptr, std::move(from)) {}
   inline ModelProto& operator=(const ModelProto& from) {
     CopyFrom(from);
     return *this;
   }
   inline ModelProto& operator=(ModelProto&& 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 ModelProto& default_instance() {
     return *internal_default_instance();
   }
   static inline const ModelProto* internal_default_instance() {
     return reinterpret_cast<const ModelProto*>(
         &_ModelProto_default_instance_);
   }
   static constexpr int kIndexInFileMessages = 4;
   friend void swap(ModelProto& a, ModelProto& b) { a.Swap(&b); }
   inline void Swap(ModelProto* 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(ModelProto* other) {
     if (other == this) return;
     ABSL_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
   ModelProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
     return ::google::protobuf::Message::DefaultConstruct<ModelProto>(arena);
   }
   using ::google::protobuf::Message::CopyFrom;
   void CopyFrom(const ModelProto& from);
   using ::google::protobuf::Message::MergeFrom;
   void MergeFrom(const ModelProto& from) { ModelProto::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(ModelProto* other);
  private:
   friend class ::google::protobuf::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() { return "onnx.ModelProto"; }
 
  protected:
   explicit ModelProto(::google::protobuf::Arena* arena);
   ModelProto(::google::protobuf::Arena* arena, const ModelProto& from);
   ModelProto(::google::protobuf::Arena* arena, ModelProto&& from) noexcept
       : ModelProto(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 {
     kOpsetImportFieldNumber = 8,
     kMetadataPropsFieldNumber = 14,
     kTrainingInfoFieldNumber = 20,
     kFunctionsFieldNumber = 25,
     kProducerNameFieldNumber = 2,
     kProducerVersionFieldNumber = 3,
     kDomainFieldNumber = 4,
     kDocStringFieldNumber = 6,
     kGraphFieldNumber = 7,
     kIrVersionFieldNumber = 1,
     kModelVersionFieldNumber = 5,
   };
   // repeated .onnx.OperatorSetIdProto opset_import = 8;
   int opset_import_size() const;
   private:
   int _internal_opset_import_size() const;
 
   public:
   void clear_opset_import() ;
   ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* mutable_opset_import();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* _internal_mutable_opset_import();
   public:
   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
   ::onnx::OperatorSetIdProto* add_opset_import();
   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
   // repeated .onnx.StringStringEntryProto metadata_props = 14;
   int metadata_props_size() const;
   private:
   int _internal_metadata_props_size() const;
 
   public:
   void clear_metadata_props() ;
   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
   public:
   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
   ::onnx::StringStringEntryProto* add_metadata_props();
   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
   // repeated .onnx.TrainingInfoProto training_info = 20;
   int training_info_size() const;
   private:
   int _internal_training_info_size() const;
 
   public:
   void clear_training_info() ;
   ::onnx::TrainingInfoProto* mutable_training_info(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* mutable_training_info();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& _internal_training_info() const;
   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* _internal_mutable_training_info();
   public:
   const ::onnx::TrainingInfoProto& training_info(int index) const;
   ::onnx::TrainingInfoProto* add_training_info();
   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& training_info() const;
   // repeated .onnx.FunctionProto functions = 25;
   int functions_size() const;
   private:
   int _internal_functions_size() const;
 
   public:
   void clear_functions() ;
   ::onnx::FunctionProto* mutable_functions(int index);
   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* mutable_functions();
 
   private:
   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& _internal_functions() const;
   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* _internal_mutable_functions();
   public:
   const ::onnx::FunctionProto& functions(int index) const;
   ::onnx::FunctionProto* add_functions();
   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& functions() const;
   // optional string producer_name = 2;
   bool has_producer_name() const;
   void clear_producer_name() ;
   const std::string& producer_name() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_producer_name(Arg_&& arg, Args_... args);
   std::string* mutable_producer_name();
   PROTOBUF_NODISCARD std::string* release_producer_name();
   void set_allocated_producer_name(std::string* value);
 
   private:
   const std::string& _internal_producer_name() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(
       const std::string& value);
   std::string* _internal_mutable_producer_name();
 
   public:
   // optional string producer_version = 3;
   bool has_producer_version() const;
   void clear_producer_version() ;
   const std::string& producer_version() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_producer_version(Arg_&& arg, Args_... args);
   std::string* mutable_producer_version();
   PROTOBUF_NODISCARD std::string* release_producer_version();
   void set_allocated_producer_version(std::string* value);
 
   private:
   const std::string& _internal_producer_version() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(
       const std::string& value);
   std::string* _internal_mutable_producer_version();
 
   public:
   // optional string domain = 4;
   bool has_domain() const;
   void clear_domain() ;
   const std::string& domain() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_domain(Arg_&& arg, Args_... args);
   std::string* mutable_domain();
   PROTOBUF_NODISCARD std::string* release_domain();
   void set_allocated_domain(std::string* value);
 
   private:
   const std::string& _internal_domain() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
       const std::string& value);
   std::string* _internal_mutable_domain();
 
   public:
   // optional string doc_string = 6;
   bool has_doc_string() const;
   void clear_doc_string() ;
   const std::string& doc_string() const;
   template <typename Arg_ = const std::string&, typename... Args_>
   void set_doc_string(Arg_&& arg, Args_... args);
   std::string* mutable_doc_string();
   PROTOBUF_NODISCARD std::string* release_doc_string();
   void set_allocated_doc_string(std::string* value);
 
   private:
   const std::string& _internal_doc_string() const;
   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
       const std::string& value);
   std::string* _internal_mutable_doc_string();
 
   public:
   // optional .onnx.GraphProto graph = 7;
   bool has_graph() const;
   void clear_graph() ;
   const ::onnx::GraphProto& graph() const;
   PROTOBUF_NODISCARD ::onnx::GraphProto* release_graph();
   ::onnx::GraphProto* mutable_graph();
   void set_allocated_graph(::onnx::GraphProto* value);
   void unsafe_arena_set_allocated_graph(::onnx::GraphProto* value);
   ::onnx::GraphProto* unsafe_arena_release_graph();
 
   private:
   const ::onnx::GraphProto& _internal_graph() const;
   ::onnx::GraphProto* _internal_mutable_graph();
 
   public:
   // optional int64 ir_version = 1;
   bool has_ir_version() const;
   void clear_ir_version() ;
   ::int64_t ir_version() const;
   void set_ir_version(::int64_t value);
 
   private:
   ::int64_t _internal_ir_version() const;
   void _internal_set_ir_version(::int64_t value);
 
   public:
   // optional int64 model_version = 5;
   bool has_model_version() const;
   void clear_model_version() ;
   ::int64_t model_version() const;
   void set_model_version(::int64_t value);
 
   private:
   ::int64_t _internal_model_version() const;
   void _internal_set_model_version(::int64_t value);
 
   public:
   // @@protoc_insertion_point(class_scope:onnx.ModelProto)
  private:
   class _Internal;
   friend class ::google::protobuf::internal::TcParser;
   static const ::google::protobuf::internal::TcParseTable<
       4, 11, 5,
       77, 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 ModelProto& from_msg);
     ::google::protobuf::internal::HasBits<1> _has_bits_;
     mutable ::google::protobuf::internal::CachedSize _cached_size_;
     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
     ::google::protobuf::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
     ::google::protobuf::RepeatedPtrField< ::onnx::FunctionProto > functions_;
     ::google::protobuf::internal::ArenaStringPtr producer_name_;
     ::google::protobuf::internal::ArenaStringPtr producer_version_;
     ::google::protobuf::internal::ArenaStringPtr domain_;
     ::google::protobuf::internal::ArenaStringPtr doc_string_;
     ::onnx::GraphProto* graph_;
     ::int64_t ir_version_;
     ::int64_t model_version_;
     PROTOBUF_TSAN_DECLARE_MEMBER
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
 };
 
 // ===================================================================
 
 
 
 
 // ===================================================================
 
 
 #ifdef __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
 // AttributeProto
 
 // optional string name = 1;
 inline bool AttributeProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void AttributeProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& AttributeProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
 }
 inline std::string* AttributeProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
   return _s;
 }
 inline const std::string& AttributeProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void AttributeProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* AttributeProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* AttributeProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void AttributeProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
 }
 
 // optional string ref_attr_name = 21;
 inline bool AttributeProto::has_ref_attr_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline void AttributeProto::clear_ref_attr_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.ref_attr_name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000008u;
 }
 inline const std::string& AttributeProto::ref_attr_name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
   return _internal_ref_attr_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_ref_attr_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.ref_attr_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
 }
 inline std::string* AttributeProto::mutable_ref_attr_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_ref_attr_name();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
   return _s;
 }
 inline const std::string& AttributeProto::_internal_ref_attr_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.ref_attr_name_.Get();
 }
 inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.ref_attr_name_.Set(value, GetArena());
 }
 inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   return _impl_.ref_attr_name_.Mutable( GetArena());
 }
 inline std::string* AttributeProto::release_ref_attr_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000008u;
   auto* released = _impl_.ref_attr_name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.ref_attr_name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void AttributeProto::set_allocated_ref_attr_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000008u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000008u;
   }
   _impl_.ref_attr_name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.ref_attr_name_.IsDefault()) {
           _impl_.ref_attr_name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
 }
 
 // optional string doc_string = 13;
 inline bool AttributeProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline void AttributeProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const std::string& AttributeProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
 }
 inline std::string* AttributeProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
   return _s;
 }
 inline const std::string& AttributeProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* AttributeProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* AttributeProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000004u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void AttributeProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
 }
 
 // optional .onnx.AttributeProto.AttributeType type = 20;
 inline bool AttributeProto::has_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
   return value;
 }
 inline void AttributeProto::clear_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000400u;
 }
 inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
   return _internal_type();
 }
 inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
   _internal_set_type(value);
   _impl_._has_bits_[0] |= 0x00000400u;
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
 }
 inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return static_cast<::onnx::AttributeProto_AttributeType>(_impl_.type_);
 }
 inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   assert(::onnx::AttributeProto_AttributeType_IsValid(value));
   _impl_.type_ = value;
 }
 
 // optional float f = 2;
 inline bool AttributeProto::has_f() const {
   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
   return value;
 }
 inline void AttributeProto::clear_f() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.f_ = 0;
   _impl_._has_bits_[0] &= ~0x00000200u;
 }
 inline float AttributeProto::f() const {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
   return _internal_f();
 }
 inline void AttributeProto::set_f(float value) {
   _internal_set_f(value);
   _impl_._has_bits_[0] |= 0x00000200u;
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
 }
 inline float AttributeProto::_internal_f() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.f_;
 }
 inline void AttributeProto::_internal_set_f(float value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.f_ = value;
 }
 
 // optional int64 i = 3;
 inline bool AttributeProto::has_i() const {
   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
   return value;
 }
 inline void AttributeProto::clear_i() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.i_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000100u;
 }
 inline ::int64_t AttributeProto::i() const {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
   return _internal_i();
 }
 inline void AttributeProto::set_i(::int64_t value) {
   _internal_set_i(value);
   _impl_._has_bits_[0] |= 0x00000100u;
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
 }
 inline ::int64_t AttributeProto::_internal_i() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.i_;
 }
 inline void AttributeProto::_internal_set_i(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.i_ = value;
 }
 
 // optional bytes s = 4;
 inline bool AttributeProto::has_s() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void AttributeProto::clear_s() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.s_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& AttributeProto::s() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
   return _internal_s();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_s(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.s_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
 }
 inline std::string* AttributeProto::mutable_s() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_s();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
   return _s;
 }
 inline const std::string& AttributeProto::_internal_s() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.s_.Get();
 }
 inline void AttributeProto::_internal_set_s(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.s_.Set(value, GetArena());
 }
 inline std::string* AttributeProto::_internal_mutable_s() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.s_.Mutable( GetArena());
 }
 inline std::string* AttributeProto::release_s() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.s_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.s_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void AttributeProto::set_allocated_s(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.s_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.s_.IsDefault()) {
           _impl_.s_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
 }
 
 // optional .onnx.TensorProto t = 5;
 inline bool AttributeProto::has_t() const {
   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.t_ != nullptr);
   return value;
 }
 inline void AttributeProto::clear_t() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.t_ != nullptr) _impl_.t_->Clear();
   _impl_._has_bits_[0] &= ~0x00000010u;
 }
 inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorProto* p = _impl_.t_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
 }
 inline const ::onnx::TensorProto& AttributeProto::t() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
   return _internal_t();
 }
 inline void AttributeProto::unsafe_arena_set_allocated_t(::onnx::TensorProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
   }
   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000010u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000010u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
 }
 inline ::onnx::TensorProto* AttributeProto::release_t() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000010u;
   ::onnx::TensorProto* released = _impl_.t_;
   _impl_.t_ = 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 ::onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)
 
   _impl_._has_bits_[0] &= ~0x00000010u;
   ::onnx::TensorProto* temp = _impl_.t_;
   _impl_.t_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorProto* AttributeProto::_internal_mutable_t() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.t_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
     _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(p);
   }
   return _impl_.t_;
 }
 inline ::onnx::TensorProto* AttributeProto::mutable_t() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000010u;
   ::onnx::TensorProto* _msg = _internal_mutable_t();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
   return _msg;
 }
 inline void AttributeProto::set_allocated_t(::onnx::TensorProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.t_);
   }
 
   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] |= 0x00000010u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000010u;
   }
 
   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
 }
 
 // optional .onnx.GraphProto g = 6;
 inline bool AttributeProto::has_g() const {
   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.g_ != nullptr);
   return value;
 }
 inline void AttributeProto::clear_g() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.g_ != nullptr) _impl_.g_->Clear();
   _impl_._has_bits_[0] &= ~0x00000020u;
 }
 inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::GraphProto* p = _impl_.g_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
 }
 inline const ::onnx::GraphProto& AttributeProto::g() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
   return _internal_g();
 }
 inline void AttributeProto::unsafe_arena_set_allocated_g(::onnx::GraphProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
   }
   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000020u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000020u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
 }
 inline ::onnx::GraphProto* AttributeProto::release_g() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000020u;
   ::onnx::GraphProto* released = _impl_.g_;
   _impl_.g_ = 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 ::onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)
 
   _impl_._has_bits_[0] &= ~0x00000020u;
   ::onnx::GraphProto* temp = _impl_.g_;
   _impl_.g_ = nullptr;
   return temp;
 }
 inline ::onnx::GraphProto* AttributeProto::_internal_mutable_g() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.g_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
     _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(p);
   }
   return _impl_.g_;
 }
 inline ::onnx::GraphProto* AttributeProto::mutable_g() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000020u;
   ::onnx::GraphProto* _msg = _internal_mutable_g();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
   return _msg;
 }
 inline void AttributeProto::set_allocated_g(::onnx::GraphProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.g_);
   }
 
   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] |= 0x00000020u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000020u;
   }
 
   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
 }
 
 // optional .onnx.SparseTensorProto sparse_tensor = 22;
 inline bool AttributeProto::has_sparse_tensor() const {
   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_ != nullptr);
   return value;
 }
 inline void AttributeProto::clear_sparse_tensor() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.sparse_tensor_ != nullptr) _impl_.sparse_tensor_->Clear();
   _impl_._has_bits_[0] &= ~0x00000080u;
 }
 inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
 }
 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
   return _internal_sparse_tensor();
 }
 inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
   }
   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000080u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000080u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
 }
 inline ::onnx::SparseTensorProto* AttributeProto::release_sparse_tensor() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000080u;
   ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_;
   _impl_.sparse_tensor_ = 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 ::onnx::SparseTensorProto* AttributeProto::unsafe_arena_release_sparse_tensor() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)
 
   _impl_._has_bits_[0] &= ~0x00000080u;
   ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_;
   _impl_.sparse_tensor_ = nullptr;
   return temp;
 }
 inline ::onnx::SparseTensorProto* AttributeProto::_internal_mutable_sparse_tensor() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.sparse_tensor_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
     _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
   }
   return _impl_.sparse_tensor_;
 }
 inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000080u;
   ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
   return _msg;
 }
 inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.sparse_tensor_);
   }
 
   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] |= 0x00000080u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000080u;
   }
 
   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
 }
 
 // optional .onnx.TypeProto tp = 14;
 inline bool AttributeProto::has_tp() const {
   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.tp_ != nullptr);
   return value;
 }
 inline void AttributeProto::clear_tp() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.tp_ != nullptr) _impl_.tp_->Clear();
   _impl_._has_bits_[0] &= ~0x00000040u;
 }
 inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TypeProto* p = _impl_.tp_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
 }
 inline const ::onnx::TypeProto& AttributeProto::tp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
   return _internal_tp();
 }
 inline void AttributeProto::unsafe_arena_set_allocated_tp(::onnx::TypeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
   }
   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000040u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000040u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
 }
 inline ::onnx::TypeProto* AttributeProto::release_tp() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000040u;
   ::onnx::TypeProto* released = _impl_.tp_;
   _impl_.tp_ = 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 ::onnx::TypeProto* AttributeProto::unsafe_arena_release_tp() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)
 
   _impl_._has_bits_[0] &= ~0x00000040u;
   ::onnx::TypeProto* temp = _impl_.tp_;
   _impl_.tp_ = nullptr;
   return temp;
 }
 inline ::onnx::TypeProto* AttributeProto::_internal_mutable_tp() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.tp_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
     _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(p);
   }
   return _impl_.tp_;
 }
 inline ::onnx::TypeProto* AttributeProto::mutable_tp() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000040u;
   ::onnx::TypeProto* _msg = _internal_mutable_tp();
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
   return _msg;
 }
 inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.tp_);
   }
 
   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] |= 0x00000040u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000040u;
   }
 
   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
 }
 
 // repeated float floats = 7;
 inline int AttributeProto::_internal_floats_size() const {
   return _internal_floats().size();
 }
 inline int AttributeProto::floats_size() const {
   return _internal_floats_size();
 }
 inline void AttributeProto::clear_floats() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.floats_.Clear();
 }
 inline float AttributeProto::floats(int index) const {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
   return _internal_floats().Get(index);
 }
 inline void AttributeProto::set_floats(int index, float value) {
   _internal_mutable_floats()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
 }
 inline void AttributeProto::add_floats(float value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_floats()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
 }
 inline const ::google::protobuf::RepeatedField<float>& AttributeProto::floats() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
   return _internal_floats();
 }
 inline ::google::protobuf::RepeatedField<float>* AttributeProto::mutable_floats()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_floats();
 }
 inline const ::google::protobuf::RepeatedField<float>&
 AttributeProto::_internal_floats() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.floats_;
 }
 inline ::google::protobuf::RepeatedField<float>* AttributeProto::_internal_mutable_floats() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.floats_;
 }
 
 // repeated int64 ints = 8;
 inline int AttributeProto::_internal_ints_size() const {
   return _internal_ints().size();
 }
 inline int AttributeProto::ints_size() const {
   return _internal_ints_size();
 }
 inline void AttributeProto::clear_ints() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.ints_.Clear();
 }
 inline ::int64_t AttributeProto::ints(int index) const {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
   return _internal_ints().Get(index);
 }
 inline void AttributeProto::set_ints(int index, ::int64_t value) {
   _internal_mutable_ints()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
 }
 inline void AttributeProto::add_ints(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_ints()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>& AttributeProto::ints() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
   return _internal_ints();
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* AttributeProto::mutable_ints()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_ints();
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>&
 AttributeProto::_internal_ints() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.ints_;
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* AttributeProto::_internal_mutable_ints() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.ints_;
 }
 
 // repeated bytes strings = 9;
 inline int AttributeProto::_internal_strings_size() const {
   return _internal_strings().size();
 }
 inline int AttributeProto::strings_size() const {
   return _internal_strings_size();
 }
 inline void AttributeProto::clear_strings() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.strings_.Clear();
 }
 inline std::string* AttributeProto::add_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_strings()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
   return _s;
 }
 inline const std::string& AttributeProto::strings(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
   return _internal_strings().Get(index);
 }
 inline std::string* AttributeProto::mutable_strings(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
   return _internal_mutable_strings()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void AttributeProto::set_strings(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_strings()->Mutable(index),
       std::forward<Arg_>(value), args... , ::google::protobuf::internal::BytesTag{});
   // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
 }
 template <typename Arg_, typename... Args_>
 inline void AttributeProto::add_strings(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_strings(),
                                std::forward<Arg_>(value),
                                args... , ::google::protobuf::internal::BytesTag{});
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 AttributeProto::strings() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
   return _internal_strings();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 AttributeProto::mutable_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_strings();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 AttributeProto::_internal_strings() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.strings_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 AttributeProto::_internal_mutable_strings() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.strings_;
 }
 
 // repeated .onnx.TensorProto tensors = 10;
 inline int AttributeProto::_internal_tensors_size() const {
   return _internal_tensors().size();
 }
 inline int AttributeProto::tensors_size() const {
   return _internal_tensors_size();
 }
 inline void AttributeProto::clear_tensors() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.tensors_.Clear();
 }
 inline ::onnx::TensorProto* AttributeProto::mutable_tensors(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
   return _internal_mutable_tensors()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* AttributeProto::mutable_tensors()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_tensors();
 }
 inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
   return _internal_tensors().Get(index);
 }
 inline ::onnx::TensorProto* AttributeProto::add_tensors() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TensorProto* _add = _internal_mutable_tensors()->Add();
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& AttributeProto::tensors() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
   return _internal_tensors();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
 AttributeProto::_internal_tensors() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.tensors_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>*
 AttributeProto::_internal_mutable_tensors() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.tensors_;
 }
 
 // repeated .onnx.GraphProto graphs = 11;
 inline int AttributeProto::_internal_graphs_size() const {
   return _internal_graphs().size();
 }
 inline int AttributeProto::graphs_size() const {
   return _internal_graphs_size();
 }
 inline void AttributeProto::clear_graphs() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.graphs_.Clear();
 }
 inline ::onnx::GraphProto* AttributeProto::mutable_graphs(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
   return _internal_mutable_graphs()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* AttributeProto::mutable_graphs()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_graphs();
 }
 inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
   return _internal_graphs().Get(index);
 }
 inline ::onnx::GraphProto* AttributeProto::add_graphs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::GraphProto* _add = _internal_mutable_graphs()->Add();
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& AttributeProto::graphs() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
   return _internal_graphs();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>&
 AttributeProto::_internal_graphs() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.graphs_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>*
 AttributeProto::_internal_mutable_graphs() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.graphs_;
 }
 
 // repeated .onnx.SparseTensorProto sparse_tensors = 23;
 inline int AttributeProto::_internal_sparse_tensors_size() const {
   return _internal_sparse_tensors().size();
 }
 inline int AttributeProto::sparse_tensors_size() const {
   return _internal_sparse_tensors_size();
 }
 inline void AttributeProto::clear_sparse_tensors() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.sparse_tensors_.Clear();
 }
 inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensors(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
   return _internal_mutable_sparse_tensors()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* AttributeProto::mutable_sparse_tensors()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_sparse_tensors();
 }
 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
   return _internal_sparse_tensors().Get(index);
 }
 inline ::onnx::SparseTensorProto* AttributeProto::add_sparse_tensors() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_tensors()->Add();
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& AttributeProto::sparse_tensors() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
   return _internal_sparse_tensors();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
 AttributeProto::_internal_sparse_tensors() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.sparse_tensors_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>*
 AttributeProto::_internal_mutable_sparse_tensors() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.sparse_tensors_;
 }
 
 // repeated .onnx.TypeProto type_protos = 15;
 inline int AttributeProto::_internal_type_protos_size() const {
   return _internal_type_protos().size();
 }
 inline int AttributeProto::type_protos_size() const {
   return _internal_type_protos_size();
 }
 inline void AttributeProto::clear_type_protos() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.type_protos_.Clear();
 }
 inline ::onnx::TypeProto* AttributeProto::mutable_type_protos(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
   return _internal_mutable_type_protos()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* AttributeProto::mutable_type_protos()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_type_protos();
 }
 inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
   return _internal_type_protos().Get(index);
 }
 inline ::onnx::TypeProto* AttributeProto::add_type_protos() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TypeProto* _add = _internal_mutable_type_protos()->Add();
   // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& AttributeProto::type_protos() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
   return _internal_type_protos();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>&
 AttributeProto::_internal_type_protos() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.type_protos_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>*
 AttributeProto::_internal_mutable_type_protos() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.type_protos_;
 }
 
 // -------------------------------------------------------------------
 
 // ValueInfoProto
 
 // optional string name = 1;
 inline bool ValueInfoProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void ValueInfoProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& ValueInfoProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
 }
 inline std::string* ValueInfoProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
   return _s;
 }
 inline const std::string& ValueInfoProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void ValueInfoProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* ValueInfoProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* ValueInfoProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ValueInfoProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
 }
 
 // optional .onnx.TypeProto type = 2;
 inline bool ValueInfoProto::has_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.type_ != nullptr);
   return value;
 }
 inline void ValueInfoProto::clear_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.type_ != nullptr) _impl_.type_->Clear();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TypeProto* p = _impl_.type_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
 }
 inline const ::onnx::TypeProto& ValueInfoProto::type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
   return _internal_type();
 }
 inline void ValueInfoProto::unsafe_arena_set_allocated_type(::onnx::TypeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
   }
   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
 }
 inline ::onnx::TypeProto* ValueInfoProto::release_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000004u;
   ::onnx::TypeProto* released = _impl_.type_;
   _impl_.type_ = 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 ::onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)
 
   _impl_._has_bits_[0] &= ~0x00000004u;
   ::onnx::TypeProto* temp = _impl_.type_;
   _impl_.type_ = nullptr;
   return temp;
 }
 inline ::onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.type_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
     _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(p);
   }
   return _impl_.type_;
 }
 inline ::onnx::TypeProto* ValueInfoProto::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000004u;
   ::onnx::TypeProto* _msg = _internal_mutable_type();
   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
   return _msg;
 }
 inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.type_);
   }
 
   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] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
 
   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
 }
 
 // optional string doc_string = 3;
 inline bool ValueInfoProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void ValueInfoProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& ValueInfoProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
 }
 inline std::string* ValueInfoProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
   return _s;
 }
 inline const std::string& ValueInfoProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* ValueInfoProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ValueInfoProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
 }
 
 // -------------------------------------------------------------------
 
 // NodeProto
 
 // repeated string input = 1;
 inline int NodeProto::_internal_input_size() const {
   return _internal_input().size();
 }
 inline int NodeProto::input_size() const {
   return _internal_input_size();
 }
 inline void NodeProto::clear_input() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.input_.Clear();
 }
 inline std::string* NodeProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_input()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
   return _s;
 }
 inline const std::string& NodeProto::input(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
   return _internal_input().Get(index);
 }
 inline std::string* NodeProto::mutable_input(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
   return _internal_mutable_input()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void NodeProto::set_input(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_input()->Mutable(index),
       std::forward<Arg_>(value), args... );
   // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
 }
 template <typename Arg_, typename... Args_>
 inline void NodeProto::add_input(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
                                std::forward<Arg_>(value),
                                args... );
   // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 NodeProto::input() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
   return _internal_input();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 NodeProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_input();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 NodeProto::_internal_input() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.input_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 NodeProto::_internal_mutable_input() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.input_;
 }
 
 // repeated string output = 2;
 inline int NodeProto::_internal_output_size() const {
   return _internal_output().size();
 }
 inline int NodeProto::output_size() const {
   return _internal_output_size();
 }
 inline void NodeProto::clear_output() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.output_.Clear();
 }
 inline std::string* NodeProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_output()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
   return _s;
 }
 inline const std::string& NodeProto::output(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
   return _internal_output().Get(index);
 }
 inline std::string* NodeProto::mutable_output(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
   return _internal_mutable_output()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void NodeProto::set_output(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_output()->Mutable(index),
       std::forward<Arg_>(value), args... );
   // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
 }
 template <typename Arg_, typename... Args_>
 inline void NodeProto::add_output(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
                                std::forward<Arg_>(value),
                                args... );
   // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 NodeProto::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
   return _internal_output();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 NodeProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_output();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 NodeProto::_internal_output() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.output_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 NodeProto::_internal_mutable_output() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.output_;
 }
 
 // optional string name = 3;
 inline bool NodeProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void NodeProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& NodeProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
 }
 inline std::string* NodeProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
   return _s;
 }
 inline const std::string& NodeProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void NodeProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* NodeProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* NodeProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void NodeProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
 }
 
 // optional string op_type = 4;
 inline bool NodeProto::has_op_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void NodeProto::clear_op_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.op_type_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& NodeProto::op_type() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
   return _internal_op_type();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_op_type(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
 }
 inline std::string* NodeProto::mutable_op_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_op_type();
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
   return _s;
 }
 inline const std::string& NodeProto::_internal_op_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.op_type_.Get();
 }
 inline void NodeProto::_internal_set_op_type(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.op_type_.Set(value, GetArena());
 }
 inline std::string* NodeProto::_internal_mutable_op_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.op_type_.Mutable( GetArena());
 }
 inline std::string* NodeProto::release_op_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.op_type_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.op_type_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void NodeProto::set_allocated_op_type(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _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:onnx.NodeProto.op_type)
 }
 
 // optional string domain = 7;
 inline bool NodeProto::has_domain() const {
   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline void NodeProto::clear_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.domain_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000008u;
 }
 inline const std::string& NodeProto::domain() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
   return _internal_domain();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_domain(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
 }
 inline std::string* NodeProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_domain();
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
   return _s;
 }
 inline const std::string& NodeProto::_internal_domain() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.domain_.Get();
 }
 inline void NodeProto::_internal_set_domain(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.domain_.Set(value, GetArena());
 }
 inline std::string* NodeProto::_internal_mutable_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   return _impl_.domain_.Mutable( GetArena());
 }
 inline std::string* NodeProto::release_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000008u;
   auto* released = _impl_.domain_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.domain_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void NodeProto::set_allocated_domain(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000008u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000008u;
   }
   _impl_.domain_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.domain_.IsDefault()) {
           _impl_.domain_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
 }
 
 // repeated .onnx.AttributeProto attribute = 5;
 inline int NodeProto::_internal_attribute_size() const {
   return _internal_attribute().size();
 }
 inline int NodeProto::attribute_size() const {
   return _internal_attribute_size();
 }
 inline void NodeProto::clear_attribute() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.attribute_.Clear();
 }
 inline ::onnx::AttributeProto* NodeProto::mutable_attribute(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
   return _internal_mutable_attribute()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* NodeProto::mutable_attribute()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_attribute();
 }
 inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
   return _internal_attribute().Get(index);
 }
 inline ::onnx::AttributeProto* NodeProto::add_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::AttributeProto* _add = _internal_mutable_attribute()->Add();
   // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& NodeProto::attribute() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
   return _internal_attribute();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
 NodeProto::_internal_attribute() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.attribute_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>*
 NodeProto::_internal_mutable_attribute() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.attribute_;
 }
 
 // optional string doc_string = 6;
 inline bool NodeProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline void NodeProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const std::string& NodeProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
 }
 inline std::string* NodeProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
   return _s;
 }
 inline const std::string& NodeProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void NodeProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* NodeProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* NodeProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000004u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void NodeProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
 }
 
 // -------------------------------------------------------------------
 
 // TrainingInfoProto
 
 // optional .onnx.GraphProto initialization = 1;
 inline bool TrainingInfoProto::has_initialization() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.initialization_ != nullptr);
   return value;
 }
 inline void TrainingInfoProto::clear_initialization() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.initialization_ != nullptr) _impl_.initialization_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::GraphProto* p = _impl_.initialization_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
 }
 inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
   return _internal_initialization();
 }
 inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(::onnx::GraphProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
   }
   _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
 }
 inline ::onnx::GraphProto* TrainingInfoProto::release_initialization() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::GraphProto* released = _impl_.initialization_;
   _impl_.initialization_ = 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 ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_initialization() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::GraphProto* temp = _impl_.initialization_;
   _impl_.initialization_ = nullptr;
   return temp;
 }
 inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_initialization() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.initialization_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
     _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(p);
   }
   return _impl_.initialization_;
 }
 inline ::onnx::GraphProto* TrainingInfoProto::mutable_initialization() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::GraphProto* _msg = _internal_mutable_initialization();
   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
   return _msg;
 }
 inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.initialization_);
   }
 
   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_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
 }
 
 // optional .onnx.GraphProto algorithm = 2;
 inline bool TrainingInfoProto::has_algorithm() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.algorithm_ != nullptr);
   return value;
 }
 inline void TrainingInfoProto::clear_algorithm() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.algorithm_ != nullptr) _impl_.algorithm_->Clear();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::GraphProto* p = _impl_.algorithm_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
 }
 inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
   return _internal_algorithm();
 }
 inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
   }
   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
 }
 inline ::onnx::GraphProto* TrainingInfoProto::release_algorithm() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000002u;
   ::onnx::GraphProto* released = _impl_.algorithm_;
   _impl_.algorithm_ = 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 ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_algorithm() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)
 
   _impl_._has_bits_[0] &= ~0x00000002u;
   ::onnx::GraphProto* temp = _impl_.algorithm_;
   _impl_.algorithm_ = nullptr;
   return temp;
 }
 inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_algorithm() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.algorithm_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
     _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(p);
   }
   return _impl_.algorithm_;
 }
 inline ::onnx::GraphProto* TrainingInfoProto::mutable_algorithm() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000002u;
   ::onnx::GraphProto* _msg = _internal_mutable_algorithm();
   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
   return _msg;
 }
 inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.algorithm_);
   }
 
   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] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
 
   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
 }
 
 // repeated .onnx.StringStringEntryProto initialization_binding = 3;
 inline int TrainingInfoProto::_internal_initialization_binding_size() const {
   return _internal_initialization_binding().size();
 }
 inline int TrainingInfoProto::initialization_binding_size() const {
   return _internal_initialization_binding_size();
 }
 inline void TrainingInfoProto::clear_initialization_binding() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.initialization_binding_.Clear();
 }
 inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_initialization_binding(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
   return _internal_mutable_initialization_binding()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TrainingInfoProto::mutable_initialization_binding()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_initialization_binding();
 }
 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
   return _internal_initialization_binding().Get(index);
 }
 inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_initialization_binding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::StringStringEntryProto* _add = _internal_mutable_initialization_binding()->Add();
   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::initialization_binding() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
   return _internal_initialization_binding();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
 TrainingInfoProto::_internal_initialization_binding() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.initialization_binding_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
 TrainingInfoProto::_internal_mutable_initialization_binding() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.initialization_binding_;
 }
 
 // repeated .onnx.StringStringEntryProto update_binding = 4;
 inline int TrainingInfoProto::_internal_update_binding_size() const {
   return _internal_update_binding().size();
 }
 inline int TrainingInfoProto::update_binding_size() const {
   return _internal_update_binding_size();
 }
 inline void TrainingInfoProto::clear_update_binding() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.update_binding_.Clear();
 }
 inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_update_binding(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
   return _internal_mutable_update_binding()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TrainingInfoProto::mutable_update_binding()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_update_binding();
 }
 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
   return _internal_update_binding().Get(index);
 }
 inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_update_binding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::StringStringEntryProto* _add = _internal_mutable_update_binding()->Add();
   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::update_binding() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
   return _internal_update_binding();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
 TrainingInfoProto::_internal_update_binding() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.update_binding_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
 TrainingInfoProto::_internal_mutable_update_binding() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.update_binding_;
 }
 
 // -------------------------------------------------------------------
 
 // ModelProto
 
 // optional int64 ir_version = 1;
 inline bool ModelProto::has_ir_version() const {
   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline void ModelProto::clear_ir_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.ir_version_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000020u;
 }
 inline ::int64_t ModelProto::ir_version() const {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
   return _internal_ir_version();
 }
 inline void ModelProto::set_ir_version(::int64_t value) {
   _internal_set_ir_version(value);
   _impl_._has_bits_[0] |= 0x00000020u;
   // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
 }
 inline ::int64_t ModelProto::_internal_ir_version() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.ir_version_;
 }
 inline void ModelProto::_internal_set_ir_version(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.ir_version_ = value;
 }
 
 // repeated .onnx.OperatorSetIdProto opset_import = 8;
 inline int ModelProto::_internal_opset_import_size() const {
   return _internal_opset_import().size();
 }
 inline int ModelProto::opset_import_size() const {
   return _internal_opset_import_size();
 }
 inline void ModelProto::clear_opset_import() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.opset_import_.Clear();
 }
 inline ::onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
   return _internal_mutable_opset_import()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* ModelProto::mutable_opset_import()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_opset_import();
 }
 inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
   return _internal_opset_import().Get(index);
 }
 inline ::onnx::OperatorSetIdProto* ModelProto::add_opset_import() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
   // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& ModelProto::opset_import() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
   return _internal_opset_import();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
 ModelProto::_internal_opset_import() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.opset_import_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>*
 ModelProto::_internal_mutable_opset_import() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.opset_import_;
 }
 
 // optional string producer_name = 2;
 inline bool ModelProto::has_producer_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void ModelProto::clear_producer_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.producer_name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& ModelProto::producer_name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
   return _internal_producer_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.producer_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
 }
 inline std::string* ModelProto::mutable_producer_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_producer_name();
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
   return _s;
 }
 inline const std::string& ModelProto::_internal_producer_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.producer_name_.Get();
 }
 inline void ModelProto::_internal_set_producer_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.producer_name_.Set(value, GetArena());
 }
 inline std::string* ModelProto::_internal_mutable_producer_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.producer_name_.Mutable( GetArena());
 }
 inline std::string* ModelProto::release_producer_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.producer_name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.producer_name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ModelProto::set_allocated_producer_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.producer_name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.producer_name_.IsDefault()) {
           _impl_.producer_name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
 }
 
 // optional string producer_version = 3;
 inline bool ModelProto::has_producer_version() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void ModelProto::clear_producer_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.producer_version_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& ModelProto::producer_version() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
   return _internal_producer_version();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_version(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.producer_version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
 }
 inline std::string* ModelProto::mutable_producer_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_producer_version();
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
   return _s;
 }
 inline const std::string& ModelProto::_internal_producer_version() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.producer_version_.Get();
 }
 inline void ModelProto::_internal_set_producer_version(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.producer_version_.Set(value, GetArena());
 }
 inline std::string* ModelProto::_internal_mutable_producer_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.producer_version_.Mutable( GetArena());
 }
 inline std::string* ModelProto::release_producer_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.producer_version_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.producer_version_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ModelProto::set_allocated_producer_version(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.producer_version_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.producer_version_.IsDefault()) {
           _impl_.producer_version_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
 }
 
 // optional string domain = 4;
 inline bool ModelProto::has_domain() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline void ModelProto::clear_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.domain_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const std::string& ModelProto::domain() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
   return _internal_domain();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_domain(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
 }
 inline std::string* ModelProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_domain();
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
   return _s;
 }
 inline const std::string& ModelProto::_internal_domain() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.domain_.Get();
 }
 inline void ModelProto::_internal_set_domain(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.domain_.Set(value, GetArena());
 }
 inline std::string* ModelProto::_internal_mutable_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   return _impl_.domain_.Mutable( GetArena());
 }
 inline std::string* ModelProto::release_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000004u;
   auto* released = _impl_.domain_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.domain_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ModelProto::set_allocated_domain(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   _impl_.domain_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.domain_.IsDefault()) {
           _impl_.domain_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
 }
 
 // optional int64 model_version = 5;
 inline bool ModelProto::has_model_version() const {
   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
   return value;
 }
 inline void ModelProto::clear_model_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.model_version_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000040u;
 }
 inline ::int64_t ModelProto::model_version() const {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
   return _internal_model_version();
 }
 inline void ModelProto::set_model_version(::int64_t value) {
   _internal_set_model_version(value);
   _impl_._has_bits_[0] |= 0x00000040u;
   // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
 }
 inline ::int64_t ModelProto::_internal_model_version() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.model_version_;
 }
 inline void ModelProto::_internal_set_model_version(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.model_version_ = value;
 }
 
 // optional string doc_string = 6;
 inline bool ModelProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline void ModelProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000008u;
 }
 inline const std::string& ModelProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
 }
 inline std::string* ModelProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
   return _s;
 }
 inline const std::string& ModelProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void ModelProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* ModelProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000008u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* ModelProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000008u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void ModelProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000008u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000008u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
 }
 
 // optional .onnx.GraphProto graph = 7;
 inline bool ModelProto::has_graph() const {
   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.graph_ != nullptr);
   return value;
 }
 inline void ModelProto::clear_graph() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.graph_ != nullptr) _impl_.graph_->Clear();
   _impl_._has_bits_[0] &= ~0x00000010u;
 }
 inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::GraphProto* p = _impl_.graph_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
 }
 inline const ::onnx::GraphProto& ModelProto::graph() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
   return _internal_graph();
 }
 inline void ModelProto::unsafe_arena_set_allocated_graph(::onnx::GraphProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
   }
   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000010u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000010u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
 }
 inline ::onnx::GraphProto* ModelProto::release_graph() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000010u;
   ::onnx::GraphProto* released = _impl_.graph_;
   _impl_.graph_ = 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 ::onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)
 
   _impl_._has_bits_[0] &= ~0x00000010u;
   ::onnx::GraphProto* temp = _impl_.graph_;
   _impl_.graph_ = nullptr;
   return temp;
 }
 inline ::onnx::GraphProto* ModelProto::_internal_mutable_graph() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.graph_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
     _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(p);
   }
   return _impl_.graph_;
 }
 inline ::onnx::GraphProto* ModelProto::mutable_graph() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000010u;
   ::onnx::GraphProto* _msg = _internal_mutable_graph();
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
   return _msg;
 }
 inline void ModelProto::set_allocated_graph(::onnx::GraphProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.graph_);
   }
 
   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] |= 0x00000010u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000010u;
   }
 
   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
 }
 
 // repeated .onnx.StringStringEntryProto metadata_props = 14;
 inline int ModelProto::_internal_metadata_props_size() const {
   return _internal_metadata_props().size();
 }
 inline int ModelProto::metadata_props_size() const {
   return _internal_metadata_props_size();
 }
 inline void ModelProto::clear_metadata_props() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.metadata_props_.Clear();
 }
 inline ::onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
   return _internal_mutable_metadata_props()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* ModelProto::mutable_metadata_props()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_metadata_props();
 }
 inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
   return _internal_metadata_props().Get(index);
 }
 inline ::onnx::StringStringEntryProto* ModelProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
   // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ModelProto::metadata_props() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
   return _internal_metadata_props();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
 ModelProto::_internal_metadata_props() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.metadata_props_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
 ModelProto::_internal_mutable_metadata_props() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.metadata_props_;
 }
 
 // repeated .onnx.TrainingInfoProto training_info = 20;
 inline int ModelProto::_internal_training_info_size() const {
   return _internal_training_info().size();
 }
 inline int ModelProto::training_info_size() const {
   return _internal_training_info_size();
 }
 inline void ModelProto::clear_training_info() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.training_info_.Clear();
 }
 inline ::onnx::TrainingInfoProto* ModelProto::mutable_training_info(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
   return _internal_mutable_training_info()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* ModelProto::mutable_training_info()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_training_info();
 }
 inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
   return _internal_training_info().Get(index);
 }
 inline ::onnx::TrainingInfoProto* ModelProto::add_training_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TrainingInfoProto* _add = _internal_mutable_training_info()->Add();
   // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& ModelProto::training_info() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
   return _internal_training_info();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>&
 ModelProto::_internal_training_info() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.training_info_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>*
 ModelProto::_internal_mutable_training_info() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.training_info_;
 }
 
 // repeated .onnx.FunctionProto functions = 25;
 inline int ModelProto::_internal_functions_size() const {
   return _internal_functions().size();
 }
 inline int ModelProto::functions_size() const {
   return _internal_functions_size();
 }
 inline void ModelProto::clear_functions() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.functions_.Clear();
 }
 inline ::onnx::FunctionProto* ModelProto::mutable_functions(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
   return _internal_mutable_functions()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* ModelProto::mutable_functions()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_functions();
 }
 inline const ::onnx::FunctionProto& ModelProto::functions(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
   return _internal_functions().Get(index);
 }
 inline ::onnx::FunctionProto* ModelProto::add_functions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::FunctionProto* _add = _internal_mutable_functions()->Add();
   // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& ModelProto::functions() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
   return _internal_functions();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>&
 ModelProto::_internal_functions() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.functions_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>*
 ModelProto::_internal_mutable_functions() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.functions_;
 }
 
 // -------------------------------------------------------------------
 
 // StringStringEntryProto
 
 // optional string key = 1;
 inline bool StringStringEntryProto::has_key() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void StringStringEntryProto::clear_key() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.key_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& StringStringEntryProto::key() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
   return _internal_key();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_key(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
 }
 inline std::string* StringStringEntryProto::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_key();
   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
   return _s;
 }
 inline const std::string& StringStringEntryProto::_internal_key() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.key_.Get();
 }
 inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.key_.Set(value, GetArena());
 }
 inline std::string* StringStringEntryProto::_internal_mutable_key() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.key_.Mutable( GetArena());
 }
 inline std::string* StringStringEntryProto::release_key() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.key_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.key_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void StringStringEntryProto::set_allocated_key(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.key_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.key_.IsDefault()) {
           _impl_.key_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
 }
 
 // optional string value = 2;
 inline bool StringStringEntryProto::has_value() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void StringStringEntryProto::clear_value() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.value_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& StringStringEntryProto::value() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
   return _internal_value();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_value(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
 }
 inline std::string* StringStringEntryProto::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_value();
   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
   return _s;
 }
 inline const std::string& StringStringEntryProto::_internal_value() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.value_.Get();
 }
 inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.value_.Set(value, GetArena());
 }
 inline std::string* StringStringEntryProto::_internal_mutable_value() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.value_.Mutable( GetArena());
 }
 inline std::string* StringStringEntryProto::release_value() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.value_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.value_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void StringStringEntryProto::set_allocated_value(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.value_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.value_.IsDefault()) {
           _impl_.value_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
 }
 
 // -------------------------------------------------------------------
 
 // TensorAnnotation
 
 // optional string tensor_name = 1;
 inline bool TensorAnnotation::has_tensor_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TensorAnnotation::clear_tensor_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.tensor_name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& TensorAnnotation::tensor_name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
   return _internal_tensor_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorAnnotation::set_tensor_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.tensor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
 }
 inline std::string* TensorAnnotation::mutable_tensor_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_tensor_name();
   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
   return _s;
 }
 inline const std::string& TensorAnnotation::_internal_tensor_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.tensor_name_.Get();
 }
 inline void TensorAnnotation::_internal_set_tensor_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.tensor_name_.Set(value, GetArena());
 }
 inline std::string* TensorAnnotation::_internal_mutable_tensor_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.tensor_name_.Mutable( GetArena());
 }
 inline std::string* TensorAnnotation::release_tensor_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.tensor_name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.tensor_name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TensorAnnotation::set_allocated_tensor_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.tensor_name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.tensor_name_.IsDefault()) {
           _impl_.tensor_name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
 }
 
 // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
 inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
   return _internal_quant_parameter_tensor_names().size();
 }
 inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
   return _internal_quant_parameter_tensor_names_size();
 }
 inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.quant_parameter_tensor_names_.Clear();
 }
 inline ::onnx::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
   return _internal_mutable_quant_parameter_tensor_names()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TensorAnnotation::mutable_quant_parameter_tensor_names()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_quant_parameter_tensor_names();
 }
 inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
   return _internal_quant_parameter_tensor_names().Get(index);
 }
 inline ::onnx::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::StringStringEntryProto* _add = _internal_mutable_quant_parameter_tensor_names()->Add();
   // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorAnnotation::quant_parameter_tensor_names() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
   return _internal_quant_parameter_tensor_names();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
 TensorAnnotation::_internal_quant_parameter_tensor_names() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.quant_parameter_tensor_names_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
 TensorAnnotation::_internal_mutable_quant_parameter_tensor_names() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.quant_parameter_tensor_names_;
 }
 
 // -------------------------------------------------------------------
 
 // GraphProto
 
 // repeated .onnx.NodeProto node = 1;
 inline int GraphProto::_internal_node_size() const {
   return _internal_node().size();
 }
 inline int GraphProto::node_size() const {
   return _internal_node_size();
 }
 inline void GraphProto::clear_node() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.node_.Clear();
 }
 inline ::onnx::NodeProto* GraphProto::mutable_node(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
   return _internal_mutable_node()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* GraphProto::mutable_node()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_node();
 }
 inline const ::onnx::NodeProto& GraphProto::node(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
   return _internal_node().Get(index);
 }
 inline ::onnx::NodeProto* GraphProto::add_node() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& GraphProto::node() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
   return _internal_node();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
 GraphProto::_internal_node() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.node_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>*
 GraphProto::_internal_mutable_node() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.node_;
 }
 
 // optional string name = 2;
 inline bool GraphProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void GraphProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& GraphProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
 }
 inline std::string* GraphProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
   return _s;
 }
 inline const std::string& GraphProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void GraphProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* GraphProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* GraphProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void GraphProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
 }
 
 // repeated .onnx.TensorProto initializer = 5;
 inline int GraphProto::_internal_initializer_size() const {
   return _internal_initializer().size();
 }
 inline int GraphProto::initializer_size() const {
   return _internal_initializer_size();
 }
 inline void GraphProto::clear_initializer() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.initializer_.Clear();
 }
 inline ::onnx::TensorProto* GraphProto::mutable_initializer(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
   return _internal_mutable_initializer()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* GraphProto::mutable_initializer()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_initializer();
 }
 inline const ::onnx::TensorProto& GraphProto::initializer(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
   return _internal_initializer().Get(index);
 }
 inline ::onnx::TensorProto* GraphProto::add_initializer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TensorProto* _add = _internal_mutable_initializer()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& GraphProto::initializer() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
   return _internal_initializer();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
 GraphProto::_internal_initializer() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.initializer_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>*
 GraphProto::_internal_mutable_initializer() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.initializer_;
 }
 
 // repeated .onnx.SparseTensorProto sparse_initializer = 15;
 inline int GraphProto::_internal_sparse_initializer_size() const {
   return _internal_sparse_initializer().size();
 }
 inline int GraphProto::sparse_initializer_size() const {
   return _internal_sparse_initializer_size();
 }
 inline void GraphProto::clear_sparse_initializer() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.sparse_initializer_.Clear();
 }
 inline ::onnx::SparseTensorProto* GraphProto::mutable_sparse_initializer(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
   return _internal_mutable_sparse_initializer()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* GraphProto::mutable_sparse_initializer()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_sparse_initializer();
 }
 inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
   return _internal_sparse_initializer().Get(index);
 }
 inline ::onnx::SparseTensorProto* GraphProto::add_sparse_initializer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_initializer()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& GraphProto::sparse_initializer() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
   return _internal_sparse_initializer();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
 GraphProto::_internal_sparse_initializer() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.sparse_initializer_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>*
 GraphProto::_internal_mutable_sparse_initializer() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.sparse_initializer_;
 }
 
 // optional string doc_string = 10;
 inline bool GraphProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void GraphProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& GraphProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
 }
 inline std::string* GraphProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
   return _s;
 }
 inline const std::string& GraphProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void GraphProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* GraphProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* GraphProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void GraphProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
 }
 
 // repeated .onnx.ValueInfoProto input = 11;
 inline int GraphProto::_internal_input_size() const {
   return _internal_input().size();
 }
 inline int GraphProto::input_size() const {
   return _internal_input_size();
 }
 inline void GraphProto::clear_input() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.input_.Clear();
 }
 inline ::onnx::ValueInfoProto* GraphProto::mutable_input(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
   return _internal_mutable_input()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_input()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_input();
 }
 inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
   return _internal_input().Get(index);
 }
 inline ::onnx::ValueInfoProto* GraphProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::ValueInfoProto* _add = _internal_mutable_input()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::input() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
   return _internal_input();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
 GraphProto::_internal_input() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.input_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
 GraphProto::_internal_mutable_input() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.input_;
 }
 
 // repeated .onnx.ValueInfoProto output = 12;
 inline int GraphProto::_internal_output_size() const {
   return _internal_output().size();
 }
 inline int GraphProto::output_size() const {
   return _internal_output_size();
 }
 inline void GraphProto::clear_output() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.output_.Clear();
 }
 inline ::onnx::ValueInfoProto* GraphProto::mutable_output(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
   return _internal_mutable_output()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_output()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_output();
 }
 inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
   return _internal_output().Get(index);
 }
 inline ::onnx::ValueInfoProto* GraphProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::ValueInfoProto* _add = _internal_mutable_output()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::output() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
   return _internal_output();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
 GraphProto::_internal_output() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.output_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
 GraphProto::_internal_mutable_output() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.output_;
 }
 
 // repeated .onnx.ValueInfoProto value_info = 13;
 inline int GraphProto::_internal_value_info_size() const {
   return _internal_value_info().size();
 }
 inline int GraphProto::value_info_size() const {
   return _internal_value_info_size();
 }
 inline void GraphProto::clear_value_info() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.value_info_.Clear();
 }
 inline ::onnx::ValueInfoProto* GraphProto::mutable_value_info(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
   return _internal_mutable_value_info()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_value_info()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_value_info();
 }
 inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
   return _internal_value_info().Get(index);
 }
 inline ::onnx::ValueInfoProto* GraphProto::add_value_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::ValueInfoProto* _add = _internal_mutable_value_info()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::value_info() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
   return _internal_value_info();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
 GraphProto::_internal_value_info() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.value_info_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
 GraphProto::_internal_mutable_value_info() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.value_info_;
 }
 
 // repeated .onnx.TensorAnnotation quantization_annotation = 14;
 inline int GraphProto::_internal_quantization_annotation_size() const {
   return _internal_quantization_annotation().size();
 }
 inline int GraphProto::quantization_annotation_size() const {
   return _internal_quantization_annotation_size();
 }
 inline void GraphProto::clear_quantization_annotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.quantization_annotation_.Clear();
 }
 inline ::onnx::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
   return _internal_mutable_quantization_annotation()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* GraphProto::mutable_quantization_annotation()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_quantization_annotation();
 }
 inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
   return _internal_quantization_annotation().Get(index);
 }
 inline ::onnx::TensorAnnotation* GraphProto::add_quantization_annotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TensorAnnotation* _add = _internal_mutable_quantization_annotation()->Add();
   // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& GraphProto::quantization_annotation() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
   return _internal_quantization_annotation();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>&
 GraphProto::_internal_quantization_annotation() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.quantization_annotation_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>*
 GraphProto::_internal_mutable_quantization_annotation() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.quantization_annotation_;
 }
 
 // -------------------------------------------------------------------
 
 // TensorProto_Segment
 
 // optional int64 begin = 1;
 inline bool TensorProto_Segment::has_begin() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TensorProto_Segment::clear_begin() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.begin_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline ::int64_t TensorProto_Segment::begin() const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
   return _internal_begin();
 }
 inline void TensorProto_Segment::set_begin(::int64_t value) {
   _internal_set_begin(value);
   _impl_._has_bits_[0] |= 0x00000001u;
   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
 }
 inline ::int64_t TensorProto_Segment::_internal_begin() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.begin_;
 }
 inline void TensorProto_Segment::_internal_set_begin(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.begin_ = value;
 }
 
 // optional int64 end = 2;
 inline bool TensorProto_Segment::has_end() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TensorProto_Segment::clear_end() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.end_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline ::int64_t TensorProto_Segment::end() const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
   return _internal_end();
 }
 inline void TensorProto_Segment::set_end(::int64_t value) {
   _internal_set_end(value);
   _impl_._has_bits_[0] |= 0x00000002u;
   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
 }
 inline ::int64_t TensorProto_Segment::_internal_end() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.end_;
 }
 inline void TensorProto_Segment::_internal_set_end(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.end_ = value;
 }
 
 // -------------------------------------------------------------------
 
 // TensorProto
 
 // repeated int64 dims = 1;
 inline int TensorProto::_internal_dims_size() const {
   return _internal_dims().size();
 }
 inline int TensorProto::dims_size() const {
   return _internal_dims_size();
 }
 inline void TensorProto::clear_dims() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.dims_.Clear();
 }
 inline ::int64_t TensorProto::dims(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
   return _internal_dims().Get(index);
 }
 inline void TensorProto::set_dims(int index, ::int64_t value) {
   _internal_mutable_dims()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
 }
 inline void TensorProto::add_dims(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_dims()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::dims() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
   return _internal_dims();
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::mutable_dims()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_dims();
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>&
 TensorProto::_internal_dims() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.dims_;
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::_internal_mutable_dims() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.dims_;
 }
 
 // optional int32 data_type = 2;
 inline bool TensorProto::has_data_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
   return value;
 }
 inline void TensorProto::clear_data_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.data_type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000010u;
 }
 inline ::int32_t TensorProto::data_type() const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
   return _internal_data_type();
 }
 inline void TensorProto::set_data_type(::int32_t value) {
   _internal_set_data_type(value);
   _impl_._has_bits_[0] |= 0x00000010u;
   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
 }
 inline ::int32_t TensorProto::_internal_data_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.data_type_;
 }
 inline void TensorProto::_internal_set_data_type(::int32_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.data_type_ = value;
 }
 
 // optional .onnx.TensorProto.Segment segment = 3;
 inline bool TensorProto::has_segment() const {
   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.segment_ != nullptr);
   return value;
 }
 inline void TensorProto::clear_segment() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.segment_ != nullptr) _impl_.segment_->Clear();
   _impl_._has_bits_[0] &= ~0x00000008u;
 }
 inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorProto_Segment* p = _impl_.segment_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto_Segment&>(::onnx::_TensorProto_Segment_default_instance_);
 }
 inline const ::onnx::TensorProto_Segment& TensorProto::segment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
   return _internal_segment();
 }
 inline void TensorProto::unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
   }
   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000008u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000008u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
 }
 inline ::onnx::TensorProto_Segment* TensorProto::release_segment() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000008u;
   ::onnx::TensorProto_Segment* released = _impl_.segment_;
   _impl_.segment_ = 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 ::onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)
 
   _impl_._has_bits_[0] &= ~0x00000008u;
   ::onnx::TensorProto_Segment* temp = _impl_.segment_;
   _impl_.segment_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.segment_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto_Segment>(GetArena());
     _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(p);
   }
   return _impl_.segment_;
 }
 inline ::onnx::TensorProto_Segment* TensorProto::mutable_segment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000008u;
   ::onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
   return _msg;
 }
 inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.segment_);
   }
 
   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] |= 0x00000008u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000008u;
   }
 
   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
 }
 
 // repeated float float_data = 4 [packed = true];
 inline int TensorProto::_internal_float_data_size() const {
   return _internal_float_data().size();
 }
 inline int TensorProto::float_data_size() const {
   return _internal_float_data_size();
 }
 inline void TensorProto::clear_float_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.float_data_.Clear();
 }
 inline float TensorProto::float_data(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
   return _internal_float_data().Get(index);
 }
 inline void TensorProto::set_float_data(int index, float value) {
   _internal_mutable_float_data()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
 }
 inline void TensorProto::add_float_data(float value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_float_data()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
 }
 inline const ::google::protobuf::RepeatedField<float>& TensorProto::float_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
   return _internal_float_data();
 }
 inline ::google::protobuf::RepeatedField<float>* TensorProto::mutable_float_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_float_data();
 }
 inline const ::google::protobuf::RepeatedField<float>&
 TensorProto::_internal_float_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.float_data_;
 }
 inline ::google::protobuf::RepeatedField<float>* TensorProto::_internal_mutable_float_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.float_data_;
 }
 
 // repeated int32 int32_data = 5 [packed = true];
 inline int TensorProto::_internal_int32_data_size() const {
   return _internal_int32_data().size();
 }
 inline int TensorProto::int32_data_size() const {
   return _internal_int32_data_size();
 }
 inline void TensorProto::clear_int32_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.int32_data_.Clear();
 }
 inline ::int32_t TensorProto::int32_data(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
   return _internal_int32_data().Get(index);
 }
 inline void TensorProto::set_int32_data(int index, ::int32_t value) {
   _internal_mutable_int32_data()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
 }
 inline void TensorProto::add_int32_data(::int32_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_int32_data()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
 }
 inline const ::google::protobuf::RepeatedField<::int32_t>& TensorProto::int32_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
   return _internal_int32_data();
 }
 inline ::google::protobuf::RepeatedField<::int32_t>* TensorProto::mutable_int32_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_int32_data();
 }
 inline const ::google::protobuf::RepeatedField<::int32_t>&
 TensorProto::_internal_int32_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.int32_data_;
 }
 inline ::google::protobuf::RepeatedField<::int32_t>* TensorProto::_internal_mutable_int32_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.int32_data_;
 }
 
 // repeated bytes string_data = 6;
 inline int TensorProto::_internal_string_data_size() const {
   return _internal_string_data().size();
 }
 inline int TensorProto::string_data_size() const {
   return _internal_string_data_size();
 }
 inline void TensorProto::clear_string_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.string_data_.Clear();
 }
 inline std::string* TensorProto::add_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_string_data()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
   return _s;
 }
 inline const std::string& TensorProto::string_data(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
   return _internal_string_data().Get(index);
 }
 inline std::string* TensorProto::mutable_string_data(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
   return _internal_mutable_string_data()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void TensorProto::set_string_data(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_string_data()->Mutable(index),
       std::forward<Arg_>(value), args... , ::google::protobuf::internal::BytesTag{});
   // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
 }
 template <typename Arg_, typename... Args_>
 inline void TensorProto::add_string_data(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_string_data(),
                                std::forward<Arg_>(value),
                                args... , ::google::protobuf::internal::BytesTag{});
   // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 TensorProto::string_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
   return _internal_string_data();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 TensorProto::mutable_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_string_data();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 TensorProto::_internal_string_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.string_data_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 TensorProto::_internal_mutable_string_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.string_data_;
 }
 
 // repeated int64 int64_data = 7 [packed = true];
 inline int TensorProto::_internal_int64_data_size() const {
   return _internal_int64_data().size();
 }
 inline int TensorProto::int64_data_size() const {
   return _internal_int64_data_size();
 }
 inline void TensorProto::clear_int64_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.int64_data_.Clear();
 }
 inline ::int64_t TensorProto::int64_data(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
   return _internal_int64_data().Get(index);
 }
 inline void TensorProto::set_int64_data(int index, ::int64_t value) {
   _internal_mutable_int64_data()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
 }
 inline void TensorProto::add_int64_data(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_int64_data()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::int64_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
   return _internal_int64_data();
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::mutable_int64_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_int64_data();
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>&
 TensorProto::_internal_int64_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.int64_data_;
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::_internal_mutable_int64_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.int64_data_;
 }
 
 // optional string name = 8;
 inline bool TensorProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TensorProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& TensorProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
 }
 inline std::string* TensorProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
   return _s;
 }
 inline const std::string& TensorProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void TensorProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* TensorProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* TensorProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TensorProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
 }
 
 // optional string doc_string = 12;
 inline bool TensorProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline void TensorProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const std::string& TensorProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
 }
 inline std::string* TensorProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
   return _s;
 }
 inline const std::string& TensorProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void TensorProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* TensorProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* TensorProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000004u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TensorProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
 }
 
 // optional bytes raw_data = 9;
 inline bool TensorProto::has_raw_data() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TensorProto::clear_raw_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.raw_data_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& TensorProto::raw_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
   return _internal_raw_data();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_raw_data(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.raw_data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
 }
 inline std::string* TensorProto::mutable_raw_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_raw_data();
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
   return _s;
 }
 inline const std::string& TensorProto::_internal_raw_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.raw_data_.Get();
 }
 inline void TensorProto::_internal_set_raw_data(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.raw_data_.Set(value, GetArena());
 }
 inline std::string* TensorProto::_internal_mutable_raw_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.raw_data_.Mutable( GetArena());
 }
 inline std::string* TensorProto::release_raw_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.raw_data_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.raw_data_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TensorProto::set_allocated_raw_data(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.raw_data_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.raw_data_.IsDefault()) {
           _impl_.raw_data_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
 }
 
 // repeated .onnx.StringStringEntryProto external_data = 13;
 inline int TensorProto::_internal_external_data_size() const {
   return _internal_external_data().size();
 }
 inline int TensorProto::external_data_size() const {
   return _internal_external_data_size();
 }
 inline void TensorProto::clear_external_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.external_data_.Clear();
 }
 inline ::onnx::StringStringEntryProto* TensorProto::mutable_external_data(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
   return _internal_mutable_external_data()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TensorProto::mutable_external_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_external_data();
 }
 inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
   return _internal_external_data().Get(index);
 }
 inline ::onnx::StringStringEntryProto* TensorProto::add_external_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::StringStringEntryProto* _add = _internal_mutable_external_data()->Add();
   // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::external_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
   return _internal_external_data();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
 TensorProto::_internal_external_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.external_data_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
 TensorProto::_internal_mutable_external_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.external_data_;
 }
 
 // optional .onnx.TensorProto.DataLocation data_location = 14;
 inline bool TensorProto::has_data_location() const {
   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline void TensorProto::clear_data_location() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.data_location_ = 0;
   _impl_._has_bits_[0] &= ~0x00000020u;
 }
 inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
   return _internal_data_location();
 }
 inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
   _internal_set_data_location(value);
   _impl_._has_bits_[0] |= 0x00000020u;
   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
 }
 inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return static_cast<::onnx::TensorProto_DataLocation>(_impl_.data_location_);
 }
 inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   assert(::onnx::TensorProto_DataLocation_IsValid(value));
   _impl_.data_location_ = value;
 }
 
 // repeated double double_data = 10 [packed = true];
 inline int TensorProto::_internal_double_data_size() const {
   return _internal_double_data().size();
 }
 inline int TensorProto::double_data_size() const {
   return _internal_double_data_size();
 }
 inline void TensorProto::clear_double_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.double_data_.Clear();
 }
 inline double TensorProto::double_data(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
   return _internal_double_data().Get(index);
 }
 inline void TensorProto::set_double_data(int index, double value) {
   _internal_mutable_double_data()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
 }
 inline void TensorProto::add_double_data(double value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_double_data()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
 }
 inline const ::google::protobuf::RepeatedField<double>& TensorProto::double_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
   return _internal_double_data();
 }
 inline ::google::protobuf::RepeatedField<double>* TensorProto::mutable_double_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_double_data();
 }
 inline const ::google::protobuf::RepeatedField<double>&
 TensorProto::_internal_double_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.double_data_;
 }
 inline ::google::protobuf::RepeatedField<double>* TensorProto::_internal_mutable_double_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.double_data_;
 }
 
 // repeated uint64 uint64_data = 11 [packed = true];
 inline int TensorProto::_internal_uint64_data_size() const {
   return _internal_uint64_data().size();
 }
 inline int TensorProto::uint64_data_size() const {
   return _internal_uint64_data_size();
 }
 inline void TensorProto::clear_uint64_data() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.uint64_data_.Clear();
 }
 inline ::uint64_t TensorProto::uint64_data(int index) const {
   // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
   return _internal_uint64_data().Get(index);
 }
 inline void TensorProto::set_uint64_data(int index, ::uint64_t value) {
   _internal_mutable_uint64_data()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
 }
 inline void TensorProto::add_uint64_data(::uint64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_uint64_data()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
 }
 inline const ::google::protobuf::RepeatedField<::uint64_t>& TensorProto::uint64_data() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
   return _internal_uint64_data();
 }
 inline ::google::protobuf::RepeatedField<::uint64_t>* TensorProto::mutable_uint64_data()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_uint64_data();
 }
 inline const ::google::protobuf::RepeatedField<::uint64_t>&
 TensorProto::_internal_uint64_data() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.uint64_data_;
 }
 inline ::google::protobuf::RepeatedField<::uint64_t>* TensorProto::_internal_mutable_uint64_data() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.uint64_data_;
 }
 
 // -------------------------------------------------------------------
 
 // SparseTensorProto
 
 // optional .onnx.TensorProto values = 1;
 inline bool SparseTensorProto::has_values() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
   return value;
 }
 inline void SparseTensorProto::clear_values() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.values_ != nullptr) _impl_.values_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorProto* p = _impl_.values_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
 }
 inline const ::onnx::TensorProto& SparseTensorProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
   return _internal_values();
 }
 inline void SparseTensorProto::unsafe_arena_set_allocated_values(::onnx::TensorProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
   }
   _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
 }
 inline ::onnx::TensorProto* SparseTensorProto::release_values() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorProto* released = _impl_.values_;
   _impl_.values_ = 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 ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_values() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorProto* temp = _impl_.values_;
   _impl_.values_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_values() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.values_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
     _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(p);
   }
   return _impl_.values_;
 }
 inline ::onnx::TensorProto* SparseTensorProto::mutable_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TensorProto* _msg = _internal_mutable_values();
   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
   return _msg;
 }
 inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.values_);
   }
 
   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_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
 }
 
 // optional .onnx.TensorProto indices = 2;
 inline bool SparseTensorProto::has_indices() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.indices_ != nullptr);
   return value;
 }
 inline void SparseTensorProto::clear_indices() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.indices_ != nullptr) _impl_.indices_->Clear();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorProto* p = _impl_.indices_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
 }
 inline const ::onnx::TensorProto& SparseTensorProto::indices() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
   return _internal_indices();
 }
 inline void SparseTensorProto::unsafe_arena_set_allocated_indices(::onnx::TensorProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
   }
   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
 }
 inline ::onnx::TensorProto* SparseTensorProto::release_indices() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000002u;
   ::onnx::TensorProto* released = _impl_.indices_;
   _impl_.indices_ = 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 ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_indices() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)
 
   _impl_._has_bits_[0] &= ~0x00000002u;
   ::onnx::TensorProto* temp = _impl_.indices_;
   _impl_.indices_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_indices() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.indices_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
     _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(p);
   }
   return _impl_.indices_;
 }
 inline ::onnx::TensorProto* SparseTensorProto::mutable_indices() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000002u;
   ::onnx::TensorProto* _msg = _internal_mutable_indices();
   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
   return _msg;
 }
 inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.indices_);
   }
 
   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] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
 
   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
 }
 
 // repeated int64 dims = 3;
 inline int SparseTensorProto::_internal_dims_size() const {
   return _internal_dims().size();
 }
 inline int SparseTensorProto::dims_size() const {
   return _internal_dims_size();
 }
 inline void SparseTensorProto::clear_dims() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.dims_.Clear();
 }
 inline ::int64_t SparseTensorProto::dims(int index) const {
   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
   return _internal_dims().Get(index);
 }
 inline void SparseTensorProto::set_dims(int index, ::int64_t value) {
   _internal_mutable_dims()->Set(index, value);
   // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
 }
 inline void SparseTensorProto::add_dims(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _internal_mutable_dims()->Add(value);
   // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>& SparseTensorProto::dims() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
   return _internal_dims();
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* SparseTensorProto::mutable_dims()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_dims();
 }
 inline const ::google::protobuf::RepeatedField<::int64_t>&
 SparseTensorProto::_internal_dims() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.dims_;
 }
 inline ::google::protobuf::RepeatedField<::int64_t>* SparseTensorProto::_internal_mutable_dims() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.dims_;
 }
 
 // -------------------------------------------------------------------
 
 // TensorShapeProto_Dimension
 
 // int64 dim_value = 1;
 inline bool TensorShapeProto_Dimension::has_dim_value() const {
   return value_case() == kDimValue;
 }
 inline void TensorShapeProto_Dimension::set_has_dim_value() {
   _impl_._oneof_case_[0] = kDimValue;
 }
 inline void TensorShapeProto_Dimension::clear_dim_value() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kDimValue) {
     _impl_.value_.dim_value_ = ::int64_t{0};
     clear_has_value();
   }
 }
 inline ::int64_t TensorShapeProto_Dimension::dim_value() const {
   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
   return _internal_dim_value();
 }
 inline void TensorShapeProto_Dimension::set_dim_value(::int64_t value) {
   if (value_case() != kDimValue) {
     clear_value();
     set_has_dim_value();
   }
   _impl_.value_.dim_value_ = value;
   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
 }
 inline ::int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
   if (value_case() == kDimValue) {
     return _impl_.value_.dim_value_;
   }
   return ::int64_t{0};
 }
 
 // string dim_param = 2;
 inline bool TensorShapeProto_Dimension::has_dim_param() const {
   return value_case() == kDimParam;
 }
 inline void TensorShapeProto_Dimension::set_has_dim_param() {
   _impl_._oneof_case_[0] = kDimParam;
 }
 inline void TensorShapeProto_Dimension::clear_dim_param() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kDimParam) {
     _impl_.value_.dim_param_.Destroy();
     clear_has_value();
   }
 }
 inline const std::string& TensorShapeProto_Dimension::dim_param() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
   return _internal_dim_param();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_dim_param(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() != kDimParam) {
     clear_value();
 
     set_has_dim_param();
     _impl_.value_.dim_param_.InitDefault();
   }
   _impl_.value_.dim_param_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
 }
 inline std::string* TensorShapeProto_Dimension::mutable_dim_param() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_dim_param();
   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
   return _s;
 }
 inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   if (value_case() != kDimParam) {
     return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
   }
   return _impl_.value_.dim_param_.Get();
 }
 inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() != kDimParam) {
     clear_value();
 
     set_has_dim_param();
     _impl_.value_.dim_param_.InitDefault();
   }
   _impl_.value_.dim_param_.Set(value, GetArena());
 }
 inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() != kDimParam) {
     clear_value();
 
     set_has_dim_param();
     _impl_.value_.dim_param_.InitDefault();
   }
   return _impl_.value_.dim_param_.Mutable( GetArena());
 }
 inline std::string* TensorShapeProto_Dimension::release_dim_param() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
   if (value_case() != kDimParam) {
     return nullptr;
   }
   clear_has_value();
   return _impl_.value_.dim_param_.Release();
 }
 inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (has_value()) {
     clear_value();
   }
   if (value != nullptr) {
     set_has_dim_param();
     _impl_.value_.dim_param_.InitAllocated(value, GetArena());
   }
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
 }
 
 // optional string denotation = 3;
 inline bool TensorShapeProto_Dimension::has_denotation() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TensorShapeProto_Dimension::clear_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.denotation_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& TensorShapeProto_Dimension::denotation() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
   return _internal_denotation();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_denotation(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
 }
 inline std::string* TensorShapeProto_Dimension::mutable_denotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_denotation();
   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
   return _s;
 }
 inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.denotation_.Get();
 }
 inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.denotation_.Set(value, GetArena());
 }
 inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.denotation_.Mutable( GetArena());
 }
 inline std::string* TensorShapeProto_Dimension::release_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.denotation_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.denotation_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.denotation_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.denotation_.IsDefault()) {
           _impl_.denotation_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
 }
 
 inline bool TensorShapeProto_Dimension::has_value() const {
   return value_case() != VALUE_NOT_SET;
 }
 inline void TensorShapeProto_Dimension::clear_has_value() {
   _impl_._oneof_case_[0] = VALUE_NOT_SET;
 }
 inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
   return TensorShapeProto_Dimension::ValueCase(_impl_._oneof_case_[0]);
 }
 // -------------------------------------------------------------------
 
 // TensorShapeProto
 
 // repeated .onnx.TensorShapeProto.Dimension dim = 1;
 inline int TensorShapeProto::_internal_dim_size() const {
   return _internal_dim().size();
 }
 inline int TensorShapeProto::dim_size() const {
   return _internal_dim_size();
 }
 inline void TensorShapeProto::clear_dim() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.dim_.Clear();
 }
 inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
   return _internal_mutable_dim()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* TensorShapeProto::mutable_dim()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_dim();
 }
 inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
   return _internal_dim().Get(index);
 }
 inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::TensorShapeProto_Dimension* _add = _internal_mutable_dim()->Add();
   // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& TensorShapeProto::dim() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
   return _internal_dim();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>&
 TensorShapeProto::_internal_dim() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.dim_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>*
 TensorShapeProto::_internal_mutable_dim() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.dim_;
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_Tensor
 
 // optional int32 elem_type = 1;
 inline bool TypeProto_Tensor::has_elem_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TypeProto_Tensor::clear_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.elem_type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline ::int32_t TypeProto_Tensor::elem_type() const {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
   return _internal_elem_type();
 }
 inline void TypeProto_Tensor::set_elem_type(::int32_t value) {
   _internal_set_elem_type(value);
   _impl_._has_bits_[0] |= 0x00000002u;
   // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
 }
 inline ::int32_t TypeProto_Tensor::_internal_elem_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.elem_type_;
 }
 inline void TypeProto_Tensor::_internal_set_elem_type(::int32_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.elem_type_ = value;
 }
 
 // optional .onnx.TensorShapeProto shape = 2;
 inline bool TypeProto_Tensor::has_shape() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
   return value;
 }
 inline void TypeProto_Tensor::clear_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorShapeProto* p = _impl_.shape_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
 }
 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
   return _internal_shape();
 }
 inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
   }
   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
 }
 inline ::onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorShapeProto* released = _impl_.shape_;
   _impl_.shape_ = 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 ::onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorShapeProto* temp = _impl_.shape_;
   _impl_.shape_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.shape_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
   }
   return _impl_.shape_;
 }
 inline ::onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
   return _msg;
 }
 inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.shape_);
   }
 
   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_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_Sequence
 
 // optional .onnx.TypeProto elem_type = 1;
 inline bool TypeProto_Sequence::has_elem_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
   return value;
 }
 inline void TypeProto_Sequence::clear_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TypeProto* p = _impl_.elem_type_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
 }
 inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
   return _internal_elem_type();
 }
 inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
   }
   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
 }
 inline ::onnx::TypeProto* TypeProto_Sequence::release_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* released = _impl_.elem_type_;
   _impl_.elem_type_ = 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 ::onnx::TypeProto* TypeProto_Sequence::unsafe_arena_release_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* temp = _impl_.elem_type_;
   _impl_.elem_type_ = nullptr;
   return temp;
 }
 inline ::onnx::TypeProto* TypeProto_Sequence::_internal_mutable_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.elem_type_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
   }
   return _impl_.elem_type_;
 }
 inline ::onnx::TypeProto* TypeProto_Sequence::mutable_elem_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
   return _msg;
 }
 inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.elem_type_);
   }
 
   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_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_Map
 
 // optional int32 key_type = 1;
 inline bool TypeProto_Map::has_key_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TypeProto_Map::clear_key_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.key_type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline ::int32_t TypeProto_Map::key_type() const {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
   return _internal_key_type();
 }
 inline void TypeProto_Map::set_key_type(::int32_t value) {
   _internal_set_key_type(value);
   _impl_._has_bits_[0] |= 0x00000002u;
   // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
 }
 inline ::int32_t TypeProto_Map::_internal_key_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.key_type_;
 }
 inline void TypeProto_Map::_internal_set_key_type(::int32_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.key_type_ = value;
 }
 
 // optional .onnx.TypeProto value_type = 2;
 inline bool TypeProto_Map::has_value_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.value_type_ != nullptr);
   return value;
 }
 inline void TypeProto_Map::clear_value_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.value_type_ != nullptr) _impl_.value_type_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TypeProto* p = _impl_.value_type_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
 }
 inline const ::onnx::TypeProto& TypeProto_Map::value_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
   return _internal_value_type();
 }
 inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(::onnx::TypeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
   }
   _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
 }
 inline ::onnx::TypeProto* TypeProto_Map::release_value_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* released = _impl_.value_type_;
   _impl_.value_type_ = 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 ::onnx::TypeProto* TypeProto_Map::unsafe_arena_release_value_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* temp = _impl_.value_type_;
   _impl_.value_type_ = nullptr;
   return temp;
 }
 inline ::onnx::TypeProto* TypeProto_Map::_internal_mutable_value_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.value_type_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
     _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
   }
   return _impl_.value_type_;
 }
 inline ::onnx::TypeProto* TypeProto_Map::mutable_value_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TypeProto* _msg = _internal_mutable_value_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
   return _msg;
 }
 inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.value_type_);
   }
 
   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_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_Optional
 
 // optional .onnx.TypeProto elem_type = 1;
 inline bool TypeProto_Optional::has_elem_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
   return value;
 }
 inline void TypeProto_Optional::clear_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TypeProto* p = _impl_.elem_type_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
 }
 inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
   return _internal_elem_type();
 }
 inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
   }
   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
 }
 inline ::onnx::TypeProto* TypeProto_Optional::release_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* released = _impl_.elem_type_;
   _impl_.elem_type_ = 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 ::onnx::TypeProto* TypeProto_Optional::unsafe_arena_release_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TypeProto* temp = _impl_.elem_type_;
   _impl_.elem_type_ = nullptr;
   return temp;
 }
 inline ::onnx::TypeProto* TypeProto_Optional::_internal_mutable_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.elem_type_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
   }
   return _impl_.elem_type_;
 }
 inline ::onnx::TypeProto* TypeProto_Optional::mutable_elem_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
   return _msg;
 }
 inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.elem_type_);
   }
 
   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_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_SparseTensor
 
 // optional int32 elem_type = 1;
 inline bool TypeProto_SparseTensor::has_elem_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TypeProto_SparseTensor::clear_elem_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.elem_type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline ::int32_t TypeProto_SparseTensor::elem_type() const {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
   return _internal_elem_type();
 }
 inline void TypeProto_SparseTensor::set_elem_type(::int32_t value) {
   _internal_set_elem_type(value);
   _impl_._has_bits_[0] |= 0x00000002u;
   // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
 }
 inline ::int32_t TypeProto_SparseTensor::_internal_elem_type() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.elem_type_;
 }
 inline void TypeProto_SparseTensor::_internal_set_elem_type(::int32_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.elem_type_ = value;
 }
 
 // optional .onnx.TensorShapeProto shape = 2;
 inline bool TypeProto_SparseTensor::has_shape() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
   return value;
 }
 inline void TypeProto_SparseTensor::clear_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   const ::onnx::TensorShapeProto* p = _impl_.shape_;
   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
 }
 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
   return _internal_shape();
 }
 inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (GetArena() == nullptr) {
     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
   }
   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
 }
 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorShapeProto* released = _impl_.shape_;
   _impl_.shape_ = 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 ::onnx::TensorShapeProto* TypeProto_SparseTensor::unsafe_arena_release_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)
 
   _impl_._has_bits_[0] &= ~0x00000001u;
   ::onnx::TensorShapeProto* temp = _impl_.shape_;
   _impl_.shape_ = nullptr;
   return temp;
 }
 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::_internal_mutable_shape() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (_impl_.shape_ == nullptr) {
     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
   }
   return _impl_.shape_;
 }
 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   _impl_._has_bits_[0] |= 0x00000001u;
   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
   return _msg;
 }
 inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* value) {
   ::google::protobuf::Arena* message_arena = GetArena();
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (message_arena == nullptr) {
     delete (_impl_.shape_);
   }
 
   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_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto_Opaque
 
 // optional string domain = 1;
 inline bool TypeProto_Opaque::has_domain() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TypeProto_Opaque::clear_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.domain_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& TypeProto_Opaque::domain() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.domain)
   return _internal_domain();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_domain(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.domain)
 }
 inline std::string* TypeProto_Opaque::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_domain();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.domain)
   return _s;
 }
 inline const std::string& TypeProto_Opaque::_internal_domain() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.domain_.Get();
 }
 inline void TypeProto_Opaque::_internal_set_domain(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.domain_.Set(value, GetArena());
 }
 inline std::string* TypeProto_Opaque::_internal_mutable_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.domain_.Mutable( GetArena());
 }
 inline std::string* TypeProto_Opaque::release_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.domain)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.domain_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.domain_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TypeProto_Opaque::set_allocated_domain(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.domain_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.domain_.IsDefault()) {
           _impl_.domain_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.domain)
 }
 
 // optional string name = 2;
 inline bool TypeProto_Opaque::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void TypeProto_Opaque::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& TypeProto_Opaque::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.name)
 }
 inline std::string* TypeProto_Opaque::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.name)
   return _s;
 }
 inline const std::string& TypeProto_Opaque::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void TypeProto_Opaque::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* TypeProto_Opaque::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* TypeProto_Opaque::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.name)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TypeProto_Opaque::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.name)
 }
 
 // -------------------------------------------------------------------
 
 // TypeProto
 
 // .onnx.TypeProto.Tensor tensor_type = 1;
 inline bool TypeProto::has_tensor_type() const {
   return value_case() == kTensorType;
 }
 inline bool TypeProto::_internal_has_tensor_type() const {
   return value_case() == kTensorType;
 }
 inline void TypeProto::set_has_tensor_type() {
   _impl_._oneof_case_[0] = kTensorType;
 }
 inline void TypeProto::clear_tensor_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kTensorType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.tensor_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.tensor_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
   if (value_case() == kTensorType) {
     clear_has_value();
     auto* temp = _impl_.value_.tensor_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.tensor_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
   return value_case() == kTensorType ? *_impl_.value_.tensor_type_ : reinterpret_cast<::onnx::TypeProto_Tensor&>(::onnx::_TypeProto_Tensor_default_instance_);
 }
 inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
   return _internal_tensor_type();
 }
 inline ::onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
   if (value_case() == kTensorType) {
     clear_has_value();
     auto* temp = _impl_.value_.tensor_type_;
     _impl_.value_.tensor_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_tensor_type();
     _impl_.value_.tensor_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
 }
 inline ::onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
   if (value_case() != kTensorType) {
     clear_value();
     set_has_tensor_type();
     _impl_.value_.tensor_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Tensor>(GetArena());
   }
   return _impl_.value_.tensor_type_;
 }
 inline ::onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
   return _msg;
 }
 
 // .onnx.TypeProto.Sequence sequence_type = 4;
 inline bool TypeProto::has_sequence_type() const {
   return value_case() == kSequenceType;
 }
 inline bool TypeProto::_internal_has_sequence_type() const {
   return value_case() == kSequenceType;
 }
 inline void TypeProto::set_has_sequence_type() {
   _impl_._oneof_case_[0] = kSequenceType;
 }
 inline void TypeProto::clear_sequence_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kSequenceType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.sequence_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sequence_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_Sequence* TypeProto::release_sequence_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
   if (value_case() == kSequenceType) {
     clear_has_value();
     auto* temp = _impl_.value_.sequence_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.sequence_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
   return value_case() == kSequenceType ? *_impl_.value_.sequence_type_ : reinterpret_cast<::onnx::TypeProto_Sequence&>(::onnx::_TypeProto_Sequence_default_instance_);
 }
 inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
   return _internal_sequence_type();
 }
 inline ::onnx::TypeProto_Sequence* TypeProto::unsafe_arena_release_sequence_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
   if (value_case() == kSequenceType) {
     clear_has_value();
     auto* temp = _impl_.value_.sequence_type_;
     _impl_.value_.sequence_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_sequence_type();
     _impl_.value_.sequence_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
 }
 inline ::onnx::TypeProto_Sequence* TypeProto::_internal_mutable_sequence_type() {
   if (value_case() != kSequenceType) {
     clear_value();
     set_has_sequence_type();
     _impl_.value_.sequence_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Sequence>(GetArena());
   }
   return _impl_.value_.sequence_type_;
 }
 inline ::onnx::TypeProto_Sequence* TypeProto::mutable_sequence_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_Sequence* _msg = _internal_mutable_sequence_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
   return _msg;
 }
 
 // .onnx.TypeProto.Map map_type = 5;
 inline bool TypeProto::has_map_type() const {
   return value_case() == kMapType;
 }
 inline bool TypeProto::_internal_has_map_type() const {
   return value_case() == kMapType;
 }
 inline void TypeProto::set_has_map_type() {
   _impl_._oneof_case_[0] = kMapType;
 }
 inline void TypeProto::clear_map_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kMapType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.map_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.map_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_Map* TypeProto::release_map_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
   if (value_case() == kMapType) {
     clear_has_value();
     auto* temp = _impl_.value_.map_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.map_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
   return value_case() == kMapType ? *_impl_.value_.map_type_ : reinterpret_cast<::onnx::TypeProto_Map&>(::onnx::_TypeProto_Map_default_instance_);
 }
 inline const ::onnx::TypeProto_Map& TypeProto::map_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
   return _internal_map_type();
 }
 inline ::onnx::TypeProto_Map* TypeProto::unsafe_arena_release_map_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
   if (value_case() == kMapType) {
     clear_has_value();
     auto* temp = _impl_.value_.map_type_;
     _impl_.value_.map_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_map_type();
     _impl_.value_.map_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
 }
 inline ::onnx::TypeProto_Map* TypeProto::_internal_mutable_map_type() {
   if (value_case() != kMapType) {
     clear_value();
     set_has_map_type();
     _impl_.value_.map_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Map>(GetArena());
   }
   return _impl_.value_.map_type_;
 }
 inline ::onnx::TypeProto_Map* TypeProto::mutable_map_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_Map* _msg = _internal_mutable_map_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
   return _msg;
 }
 
 // .onnx.TypeProto.Optional optional_type = 9;
 inline bool TypeProto::has_optional_type() const {
   return value_case() == kOptionalType;
 }
 inline bool TypeProto::_internal_has_optional_type() const {
   return value_case() == kOptionalType;
 }
 inline void TypeProto::set_has_optional_type() {
   _impl_._oneof_case_[0] = kOptionalType;
 }
 inline void TypeProto::clear_optional_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kOptionalType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.optional_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.optional_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_Optional* TypeProto::release_optional_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
   if (value_case() == kOptionalType) {
     clear_has_value();
     auto* temp = _impl_.value_.optional_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.optional_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
   return value_case() == kOptionalType ? *_impl_.value_.optional_type_ : reinterpret_cast<::onnx::TypeProto_Optional&>(::onnx::_TypeProto_Optional_default_instance_);
 }
 inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
   return _internal_optional_type();
 }
 inline ::onnx::TypeProto_Optional* TypeProto::unsafe_arena_release_optional_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
   if (value_case() == kOptionalType) {
     clear_has_value();
     auto* temp = _impl_.value_.optional_type_;
     _impl_.value_.optional_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_optional_type();
     _impl_.value_.optional_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
 }
 inline ::onnx::TypeProto_Optional* TypeProto::_internal_mutable_optional_type() {
   if (value_case() != kOptionalType) {
     clear_value();
     set_has_optional_type();
     _impl_.value_.optional_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Optional>(GetArena());
   }
   return _impl_.value_.optional_type_;
 }
 inline ::onnx::TypeProto_Optional* TypeProto::mutable_optional_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_Optional* _msg = _internal_mutable_optional_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
   return _msg;
 }
 
 // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
 inline bool TypeProto::has_sparse_tensor_type() const {
   return value_case() == kSparseTensorType;
 }
 inline bool TypeProto::_internal_has_sparse_tensor_type() const {
   return value_case() == kSparseTensorType;
 }
 inline void TypeProto::set_has_sparse_tensor_type() {
   _impl_._oneof_case_[0] = kSparseTensorType;
 }
 inline void TypeProto::clear_sparse_tensor_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kSparseTensorType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.sparse_tensor_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sparse_tensor_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
   if (value_case() == kSparseTensorType) {
     clear_has_value();
     auto* temp = _impl_.value_.sparse_tensor_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.sparse_tensor_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
   return value_case() == kSparseTensorType ? *_impl_.value_.sparse_tensor_type_ : reinterpret_cast<::onnx::TypeProto_SparseTensor&>(::onnx::_TypeProto_SparseTensor_default_instance_);
 }
 inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
   return _internal_sparse_tensor_type();
 }
 inline ::onnx::TypeProto_SparseTensor* TypeProto::unsafe_arena_release_sparse_tensor_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
   if (value_case() == kSparseTensorType) {
     clear_has_value();
     auto* temp = _impl_.value_.sparse_tensor_type_;
     _impl_.value_.sparse_tensor_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_sparse_tensor_type();
     _impl_.value_.sparse_tensor_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
 }
 inline ::onnx::TypeProto_SparseTensor* TypeProto::_internal_mutable_sparse_tensor_type() {
   if (value_case() != kSparseTensorType) {
     clear_value();
     set_has_sparse_tensor_type();
     _impl_.value_.sparse_tensor_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_SparseTensor>(GetArena());
   }
   return _impl_.value_.sparse_tensor_type_;
 }
 inline ::onnx::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_SparseTensor* _msg = _internal_mutable_sparse_tensor_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
   return _msg;
 }
 
 // .onnx.TypeProto.Opaque opaque_type = 7;
 inline bool TypeProto::has_opaque_type() const {
   return value_case() == kOpaqueType;
 }
 inline bool TypeProto::_internal_has_opaque_type() const {
   return value_case() == kOpaqueType;
 }
 inline void TypeProto::set_has_opaque_type() {
   _impl_._oneof_case_[0] = kOpaqueType;
 }
 inline void TypeProto::clear_opaque_type() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value_case() == kOpaqueType) {
     if (GetArena() == nullptr) {
       delete _impl_.value_.opaque_type_;
     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.opaque_type_);
     }
     clear_has_value();
   }
 }
 inline ::onnx::TypeProto_Opaque* TypeProto::release_opaque_type() {
   // @@protoc_insertion_point(field_release:onnx.TypeProto.opaque_type)
   if (value_case() == kOpaqueType) {
     clear_has_value();
     auto* temp = _impl_.value_.opaque_type_;
     if (GetArena() != nullptr) {
       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
     }
     _impl_.value_.opaque_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline const ::onnx::TypeProto_Opaque& TypeProto::_internal_opaque_type() const {
   return value_case() == kOpaqueType ? *_impl_.value_.opaque_type_ : reinterpret_cast<::onnx::TypeProto_Opaque&>(::onnx::_TypeProto_Opaque_default_instance_);
 }
 inline const ::onnx::TypeProto_Opaque& TypeProto::opaque_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.opaque_type)
   return _internal_opaque_type();
 }
 inline ::onnx::TypeProto_Opaque* TypeProto::unsafe_arena_release_opaque_type() {
   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.opaque_type)
   if (value_case() == kOpaqueType) {
     clear_has_value();
     auto* temp = _impl_.value_.opaque_type_;
     _impl_.value_.opaque_type_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
 inline void TypeProto::unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* value) {
   // We rely on the oneof clear method to free the earlier contents
   // of this oneof. We can directly use the pointer we're given to
   // set the new value.
   clear_value();
   if (value) {
     set_has_opaque_type();
     _impl_.value_.opaque_type_ = value;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.opaque_type)
 }
 inline ::onnx::TypeProto_Opaque* TypeProto::_internal_mutable_opaque_type() {
   if (value_case() != kOpaqueType) {
     clear_value();
     set_has_opaque_type();
     _impl_.value_.opaque_type_ =
         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Opaque>(GetArena());
   }
   return _impl_.value_.opaque_type_;
 }
 inline ::onnx::TypeProto_Opaque* TypeProto::mutable_opaque_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::onnx::TypeProto_Opaque* _msg = _internal_mutable_opaque_type();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.opaque_type)
   return _msg;
 }
 
 // optional string denotation = 6;
 inline bool TypeProto::has_denotation() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void TypeProto::clear_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.denotation_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& TypeProto::denotation() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
   return _internal_denotation();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void TypeProto::set_denotation(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
 }
 inline std::string* TypeProto::mutable_denotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_denotation();
   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
   return _s;
 }
 inline const std::string& TypeProto::_internal_denotation() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.denotation_.Get();
 }
 inline void TypeProto::_internal_set_denotation(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.denotation_.Set(value, GetArena());
 }
 inline std::string* TypeProto::_internal_mutable_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.denotation_.Mutable( GetArena());
 }
 inline std::string* TypeProto::release_denotation() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.denotation_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.denotation_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void TypeProto::set_allocated_denotation(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.denotation_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.denotation_.IsDefault()) {
           _impl_.denotation_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
 }
 
 inline bool TypeProto::has_value() const {
   return value_case() != VALUE_NOT_SET;
 }
 inline void TypeProto::clear_has_value() {
   _impl_._oneof_case_[0] = VALUE_NOT_SET;
 }
 inline TypeProto::ValueCase TypeProto::value_case() const {
   return TypeProto::ValueCase(_impl_._oneof_case_[0]);
 }
 // -------------------------------------------------------------------
 
 // OperatorSetIdProto
 
 // optional string domain = 1;
 inline bool OperatorSetIdProto::has_domain() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void OperatorSetIdProto::clear_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.domain_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& OperatorSetIdProto::domain() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
   return _internal_domain();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void OperatorSetIdProto::set_domain(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
 }
 inline std::string* OperatorSetIdProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_domain();
   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
   return _s;
 }
 inline const std::string& OperatorSetIdProto::_internal_domain() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.domain_.Get();
 }
 inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.domain_.Set(value, GetArena());
 }
 inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.domain_.Mutable( GetArena());
 }
 inline std::string* OperatorSetIdProto::release_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.domain_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.domain_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void OperatorSetIdProto::set_allocated_domain(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.domain_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.domain_.IsDefault()) {
           _impl_.domain_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
 }
 
 // optional int64 version = 2;
 inline bool OperatorSetIdProto::has_version() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void OperatorSetIdProto::clear_version() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.version_ = ::int64_t{0};
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline ::int64_t OperatorSetIdProto::version() const {
   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
   return _internal_version();
 }
 inline void OperatorSetIdProto::set_version(::int64_t value) {
   _internal_set_version(value);
   _impl_._has_bits_[0] |= 0x00000002u;
   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
 }
 inline ::int64_t OperatorSetIdProto::_internal_version() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.version_;
 }
 inline void OperatorSetIdProto::_internal_set_version(::int64_t value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.version_ = value;
 }
 
 // -------------------------------------------------------------------
 
 // FunctionProto
 
 // optional string name = 1;
 inline bool FunctionProto::has_name() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
 }
 inline void FunctionProto::clear_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.name_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& FunctionProto::name() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
   return _internal_name();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_name(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
 }
 inline std::string* FunctionProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
   return _s;
 }
 inline const std::string& FunctionProto::_internal_name() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.name_.Get();
 }
 inline void FunctionProto::_internal_set_name(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.name_.Set(value, GetArena());
 }
 inline std::string* FunctionProto::_internal_mutable_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000001u;
   return _impl_.name_.Mutable( GetArena());
 }
 inline std::string* FunctionProto::release_name() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000001u;
   auto* released = _impl_.name_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void FunctionProto::set_allocated_name(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000001u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.name_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.name_.IsDefault()) {
           _impl_.name_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
 }
 
 // repeated string input = 4;
 inline int FunctionProto::_internal_input_size() const {
   return _internal_input().size();
 }
 inline int FunctionProto::input_size() const {
   return _internal_input_size();
 }
 inline void FunctionProto::clear_input() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.input_.Clear();
 }
 inline std::string* FunctionProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_input()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
   return _s;
 }
 inline const std::string& FunctionProto::input(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
   return _internal_input().Get(index);
 }
 inline std::string* FunctionProto::mutable_input(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
   return _internal_mutable_input()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::set_input(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_input()->Mutable(index),
       std::forward<Arg_>(value), args... );
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::add_input(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
                                std::forward<Arg_>(value),
                                args... );
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::input() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
   return _internal_input();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_input();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::_internal_input() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.input_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::_internal_mutable_input() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.input_;
 }
 
 // repeated string output = 5;
 inline int FunctionProto::_internal_output_size() const {
   return _internal_output().size();
 }
 inline int FunctionProto::output_size() const {
   return _internal_output_size();
 }
 inline void FunctionProto::clear_output() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.output_.Clear();
 }
 inline std::string* FunctionProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_output()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
   return _s;
 }
 inline const std::string& FunctionProto::output(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
   return _internal_output().Get(index);
 }
 inline std::string* FunctionProto::mutable_output(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
   return _internal_mutable_output()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::set_output(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_output()->Mutable(index),
       std::forward<Arg_>(value), args... );
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::add_output(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
                                std::forward<Arg_>(value),
                                args... );
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
   return _internal_output();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_output();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::_internal_output() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.output_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::_internal_mutable_output() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.output_;
 }
 
 // repeated string attribute = 6;
 inline int FunctionProto::_internal_attribute_size() const {
   return _internal_attribute().size();
 }
 inline int FunctionProto::attribute_size() const {
   return _internal_attribute_size();
 }
 inline void FunctionProto::clear_attribute() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.attribute_.Clear();
 }
 inline std::string* FunctionProto::add_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   std::string* _s = _internal_mutable_attribute()->Add();
   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
   return _s;
 }
 inline const std::string& FunctionProto::attribute(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
   return _internal_attribute().Get(index);
 }
 inline std::string* FunctionProto::mutable_attribute(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
   return _internal_mutable_attribute()->Mutable(index);
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::set_attribute(int index, Arg_&& value, Args_... args) {
   ::google::protobuf::internal::AssignToString(
       *_internal_mutable_attribute()->Mutable(index),
       std::forward<Arg_>(value), args... );
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
 }
 template <typename Arg_, typename... Args_>
 inline void FunctionProto::add_attribute(Arg_&& value, Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_attribute(),
                                std::forward<Arg_>(value),
                                args... );
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::attribute() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
   return _internal_attribute();
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::mutable_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_attribute();
 }
 inline const ::google::protobuf::RepeatedPtrField<std::string>&
 FunctionProto::_internal_attribute() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.attribute_;
 }
 inline ::google::protobuf::RepeatedPtrField<std::string>*
 FunctionProto::_internal_mutable_attribute() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.attribute_;
 }
 
 // repeated .onnx.AttributeProto attribute_proto = 11;
 inline int FunctionProto::_internal_attribute_proto_size() const {
   return _internal_attribute_proto().size();
 }
 inline int FunctionProto::attribute_proto_size() const {
   return _internal_attribute_proto_size();
 }
 inline void FunctionProto::clear_attribute_proto() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.attribute_proto_.Clear();
 }
 inline ::onnx::AttributeProto* FunctionProto::mutable_attribute_proto(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
   return _internal_mutable_attribute_proto()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* FunctionProto::mutable_attribute_proto()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_attribute_proto();
 }
 inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
   return _internal_attribute_proto().Get(index);
 }
 inline ::onnx::AttributeProto* FunctionProto::add_attribute_proto() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::AttributeProto* _add = _internal_mutable_attribute_proto()->Add();
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& FunctionProto::attribute_proto() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
   return _internal_attribute_proto();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
 FunctionProto::_internal_attribute_proto() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.attribute_proto_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>*
 FunctionProto::_internal_mutable_attribute_proto() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.attribute_proto_;
 }
 
 // repeated .onnx.NodeProto node = 7;
 inline int FunctionProto::_internal_node_size() const {
   return _internal_node().size();
 }
 inline int FunctionProto::node_size() const {
   return _internal_node_size();
 }
 inline void FunctionProto::clear_node() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.node_.Clear();
 }
 inline ::onnx::NodeProto* FunctionProto::mutable_node(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
   return _internal_mutable_node()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* FunctionProto::mutable_node()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_node();
 }
 inline const ::onnx::NodeProto& FunctionProto::node(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
   return _internal_node().Get(index);
 }
 inline ::onnx::NodeProto* FunctionProto::add_node() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& FunctionProto::node() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
   return _internal_node();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
 FunctionProto::_internal_node() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.node_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>*
 FunctionProto::_internal_mutable_node() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.node_;
 }
 
 // optional string doc_string = 8;
 inline bool FunctionProto::has_doc_string() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline void FunctionProto::clear_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.doc_string_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& FunctionProto::doc_string() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
   return _internal_doc_string();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_doc_string(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
 }
 inline std::string* FunctionProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_doc_string();
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
   return _s;
 }
 inline const std::string& FunctionProto::_internal_doc_string() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.doc_string_.Get();
 }
 inline void FunctionProto::_internal_set_doc_string(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   _impl_.doc_string_.Set(value, GetArena());
 }
 inline std::string* FunctionProto::_internal_mutable_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000002u;
   return _impl_.doc_string_.Mutable( GetArena());
 }
 inline std::string* FunctionProto::release_doc_string() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
   auto* released = _impl_.doc_string_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.doc_string_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void FunctionProto::set_allocated_doc_string(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.doc_string_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.doc_string_.IsDefault()) {
           _impl_.doc_string_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
 }
 
 // repeated .onnx.OperatorSetIdProto opset_import = 9;
 inline int FunctionProto::_internal_opset_import_size() const {
   return _internal_opset_import().size();
 }
 inline int FunctionProto::opset_import_size() const {
   return _internal_opset_import_size();
 }
 inline void FunctionProto::clear_opset_import() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.opset_import_.Clear();
 }
 inline ::onnx::OperatorSetIdProto* FunctionProto::mutable_opset_import(int index)
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
   return _internal_mutable_opset_import()->Mutable(index);
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* FunctionProto::mutable_opset_import()
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
   ::google::protobuf::internal::TSanWrite(&_impl_);
   return _internal_mutable_opset_import();
 }
 inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
   return _internal_opset_import().Get(index);
 }
 inline ::onnx::OperatorSetIdProto* FunctionProto::add_opset_import() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
   // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
   return _add;
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& FunctionProto::opset_import() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
   return _internal_opset_import();
 }
 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
 FunctionProto::_internal_opset_import() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.opset_import_;
 }
 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>*
 FunctionProto::_internal_mutable_opset_import() {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return &_impl_.opset_import_;
 }
 
 // optional string domain = 10;
 inline bool FunctionProto::has_domain() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline void FunctionProto::clear_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_.domain_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
 inline const std::string& FunctionProto::domain() const
     ABSL_ATTRIBUTE_LIFETIME_BOUND {
   // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
   return _internal_domain();
 }
 template <typename Arg_, typename... Args_>
 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_domain(Arg_&& arg,
                                                      Args_... args) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
   // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
 }
 inline std::string* FunctionProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
   std::string* _s = _internal_mutable_domain();
   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
   return _s;
 }
 inline const std::string& FunctionProto::_internal_domain() const {
   ::google::protobuf::internal::TSanRead(&_impl_);
   return _impl_.domain_.Get();
 }
 inline void FunctionProto::_internal_set_domain(const std::string& value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.domain_.Set(value, GetArena());
 }
 inline std::string* FunctionProto::_internal_mutable_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   _impl_._has_bits_[0] |= 0x00000004u;
   return _impl_.domain_.Mutable( GetArena());
 }
 inline std::string* FunctionProto::release_domain() {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000004u;
   auto* released = _impl_.domain_.Release();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.domain_.Set("", GetArena());
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return released;
 }
 inline void FunctionProto::set_allocated_domain(std::string* value) {
   ::google::protobuf::internal::TSanWrite(&_impl_);
   if (value != nullptr) {
     _impl_._has_bits_[0] |= 0x00000004u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000004u;
   }
   _impl_.domain_.SetAllocated(value, GetArena());
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
         if (_impl_.domain_.IsDefault()) {
           _impl_.domain_.Set("", GetArena());
         }
   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
 }
 
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace onnx
 
 
 namespace google {
 namespace protobuf {
 
 template <>
 struct is_proto_enum<::onnx::AttributeProto_AttributeType> : std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor<::onnx::AttributeProto_AttributeType>() {
   return ::onnx::AttributeProto_AttributeType_descriptor();
 }
 template <>
 struct is_proto_enum<::onnx::TensorProto_DataType> : std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor<::onnx::TensorProto_DataType>() {
   return ::onnx::TensorProto_DataType_descriptor();
 }
 template <>
 struct is_proto_enum<::onnx::TensorProto_DataLocation> : std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor<::onnx::TensorProto_DataLocation>() {
   return ::onnx::TensorProto_DataLocation_descriptor();
 }
 template <>
 struct is_proto_enum<::onnx::Version> : std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor<::onnx::Version>() {
   return ::onnx::Version_descriptor();
 }
 template <>
 struct is_proto_enum<::onnx::OperatorStatus> : std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor<::onnx::OperatorStatus>() {
   return ::onnx::OperatorStatus_descriptor();
 }
 
 }  // namespace protobuf
 }  // namespace google
 
 // @@protoc_insertion_point(global_scope)
 
 #include "google/protobuf/port_undef.inc"
 
 #endif  // GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh