include/onnx/onnx-ml.pb.h

0001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
0002 // NO CHECKED-IN PROTOBUF GENCODE
0003 // source: onnx/onnx-ml.proto
0004 // Protobuf C++ Version: 5.28.2
0005
0006 #ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh
0007 #define GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh
0008
0009 #include <limits>
0010 #include <string>
0011 #include <type_traits>
0012 #include <utility>
0013
0014 #include "google/protobuf/runtime_version.h"
0015 #if PROTOBUF_VERSION != 5028002
0016 #error "Protobuf C++ gencode is built with an incompatible version of"
0017 #error "Protobuf C++ headers/runtime. See"
0018 #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
0019 #endif
0020 #include "google/protobuf/io/coded_stream.h"
0021 #include "google/protobuf/arena.h"
0022 #include "google/protobuf/arenastring.h"
0023 #include "google/protobuf/generated_message_tctable_decl.h"
0024 #include "google/protobuf/generated_message_util.h"
0025 #include "google/protobuf/metadata_lite.h"
0026 #include "google/protobuf/generated_message_reflection.h"
0027 #include "google/protobuf/message.h"
0028 #include "google/protobuf/repeated_field.h"  // IWYU pragma: export
0029 #include "google/protobuf/extension_set.h"  // IWYU pragma: export
0030 #include "google/protobuf/generated_enum_reflection.h"
0031 #include "google/protobuf/unknown_field_set.h"
0032 // @@protoc_insertion_point(includes)
0033
0034 // Must be included last.
0035 #include "google/protobuf/port_def.inc"
0036
0037 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2dml_2eproto ONNX_API
0038
0039 namespace google {
0040 namespace protobuf {
0041 namespace internal {
0042 class AnyMetadata;
0043 }  // namespace internal
0044 }  // namespace protobuf
0045 }  // namespace google
0046
0047 // Internal implementation detail -- do not use these members.
0048 struct ONNX_API TableStruct_onnx_2fonnx_2dml_2eproto {
0049   static const ::uint32_t offsets[];
0050 };
0051 ONNX_API extern const ::google::protobuf::internal::DescriptorTable
0052     descriptor_table_onnx_2fonnx_2dml_2eproto;
0053 namespace onnx {
0054 class AttributeProto;
0055 struct AttributeProtoDefaultTypeInternal;
0056 ONNX_API extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
0057 class FunctionProto;
0058 struct FunctionProtoDefaultTypeInternal;
0059 ONNX_API extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
0060 class GraphProto;
0061 struct GraphProtoDefaultTypeInternal;
0062 ONNX_API extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
0063 class ModelProto;
0064 struct ModelProtoDefaultTypeInternal;
0065 ONNX_API extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
0066 class NodeProto;
0067 struct NodeProtoDefaultTypeInternal;
0068 ONNX_API extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
0069 class OperatorSetIdProto;
0070 struct OperatorSetIdProtoDefaultTypeInternal;
0071 ONNX_API extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
0072 class SparseTensorProto;
0073 struct SparseTensorProtoDefaultTypeInternal;
0074 ONNX_API extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
0075 class StringStringEntryProto;
0076 struct StringStringEntryProtoDefaultTypeInternal;
0077 ONNX_API extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
0078 class TensorAnnotation;
0079 struct TensorAnnotationDefaultTypeInternal;
0080 ONNX_API extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
0081 class TensorProto;
0082 struct TensorProtoDefaultTypeInternal;
0083 ONNX_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
0084 class TensorProto_Segment;
0085 struct TensorProto_SegmentDefaultTypeInternal;
0086 ONNX_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
0087 class TensorShapeProto;
0088 struct TensorShapeProtoDefaultTypeInternal;
0089 ONNX_API extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
0090 class TensorShapeProto_Dimension;
0091 struct TensorShapeProto_DimensionDefaultTypeInternal;
0092 ONNX_API extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
0093 class TrainingInfoProto;
0094 struct TrainingInfoProtoDefaultTypeInternal;
0095 ONNX_API extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
0096 class TypeProto;
0097 struct TypeProtoDefaultTypeInternal;
0098 ONNX_API extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
0099 class TypeProto_Map;
0100 struct TypeProto_MapDefaultTypeInternal;
0101 ONNX_API extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
0102 class TypeProto_Opaque;
0103 struct TypeProto_OpaqueDefaultTypeInternal;
0104 ONNX_API extern TypeProto_OpaqueDefaultTypeInternal _TypeProto_Opaque_default_instance_;
0105 class TypeProto_Optional;
0106 struct TypeProto_OptionalDefaultTypeInternal;
0107 ONNX_API extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
0108 class TypeProto_Sequence;
0109 struct TypeProto_SequenceDefaultTypeInternal;
0110 ONNX_API extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
0111 class TypeProto_SparseTensor;
0112 struct TypeProto_SparseTensorDefaultTypeInternal;
0113 ONNX_API extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
0114 class TypeProto_Tensor;
0115 struct TypeProto_TensorDefaultTypeInternal;
0116 ONNX_API extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
0117 class ValueInfoProto;
0118 struct ValueInfoProtoDefaultTypeInternal;
0119 ONNX_API extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
0120 }  // namespace onnx
0121 namespace google {
0122 namespace protobuf {
0123 }  // namespace protobuf
0124 }  // namespace google
0125
0126 namespace onnx {
0127 enum AttributeProto_AttributeType : int {
0128   AttributeProto_AttributeType_UNDEFINED = 0,
0129   AttributeProto_AttributeType_FLOAT = 1,
0130   AttributeProto_AttributeType_INT = 2,
0131   AttributeProto_AttributeType_STRING = 3,
0132   AttributeProto_AttributeType_TENSOR = 4,
0133   AttributeProto_AttributeType_GRAPH = 5,
0134   AttributeProto_AttributeType_SPARSE_TENSOR = 11,
0135   AttributeProto_AttributeType_TYPE_PROTO = 13,
0136   AttributeProto_AttributeType_FLOATS = 6,
0137   AttributeProto_AttributeType_INTS = 7,
0138   AttributeProto_AttributeType_STRINGS = 8,
0139   AttributeProto_AttributeType_TENSORS = 9,
0140   AttributeProto_AttributeType_GRAPHS = 10,
0141   AttributeProto_AttributeType_SPARSE_TENSORS = 12,
0142   AttributeProto_AttributeType_TYPE_PROTOS = 14,
0143 };
0144
0145 ONNX_API bool AttributeProto_AttributeType_IsValid(int value);
0146 ONNX_API extern const uint32_t AttributeProto_AttributeType_internal_data_[];
0147 constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = static_cast<AttributeProto_AttributeType>(0);
0148 constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = static_cast<AttributeProto_AttributeType>(14);
0149 constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = 14 + 1;
0150 ONNX_API const ::google::protobuf::EnumDescriptor*
0151 AttributeProto_AttributeType_descriptor();
0152 template <typename T>
0153 const std::string& AttributeProto_AttributeType_Name(T value) {
0154   static_assert(std::is_same<T, AttributeProto_AttributeType>::value ||
0155                     std::is_integral<T>::value,
0156                 "Incorrect type passed to AttributeType_Name().");
0157   return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(value));
0158 }
0159 template <>
0160 inline const std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
0161   return ::google::protobuf::internal::NameOfDenseEnum<AttributeProto_AttributeType_descriptor,
0162                                                  0, 14>(
0163       static_cast<int>(value));
0164 }
0165 inline bool AttributeProto_AttributeType_Parse(absl::string_view name, AttributeProto_AttributeType* value) {
0166   return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(
0167       AttributeProto_AttributeType_descriptor(), name, value);
0168 }
0169 enum TensorProto_DataType : int {
0170   TensorProto_DataType_UNDEFINED = 0,
0171   TensorProto_DataType_FLOAT = 1,
0172   TensorProto_DataType_UINT8 = 2,
0173   TensorProto_DataType_INT8 = 3,
0174   TensorProto_DataType_UINT16 = 4,
0175   TensorProto_DataType_INT16 = 5,
0176   TensorProto_DataType_INT32 = 6,
0177   TensorProto_DataType_INT64 = 7,
0178   TensorProto_DataType_STRING = 8,
0179   TensorProto_DataType_BOOL = 9,
0180   TensorProto_DataType_FLOAT16 = 10,
0181   TensorProto_DataType_DOUBLE = 11,
0182   TensorProto_DataType_UINT32 = 12,
0183   TensorProto_DataType_UINT64 = 13,
0184   TensorProto_DataType_COMPLEX64 = 14,
0185   TensorProto_DataType_COMPLEX128 = 15,
0186   TensorProto_DataType_BFLOAT16 = 16,
0187   TensorProto_DataType_FLOAT8E4M3FN = 17,
0188   TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
0189   TensorProto_DataType_FLOAT8E5M2 = 19,
0190   TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
0191   TensorProto_DataType_UINT4 = 21,
0192   TensorProto_DataType_INT4 = 22,
0193 };
0194
0195 ONNX_API bool TensorProto_DataType_IsValid(int value);
0196 ONNX_API extern const uint32_t TensorProto_DataType_internal_data_[];
0197 constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = static_cast<TensorProto_DataType>(0);
0198 constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = static_cast<TensorProto_DataType>(22);
0199 constexpr int TensorProto_DataType_DataType_ARRAYSIZE = 22 + 1;
0200 ONNX_API const ::google::protobuf::EnumDescriptor*
0201 TensorProto_DataType_descriptor();
0202 template <typename T>
0203 const std::string& TensorProto_DataType_Name(T value) {
0204   static_assert(std::is_same<T, TensorProto_DataType>::value ||
0205                     std::is_integral<T>::value,
0206                 "Incorrect type passed to DataType_Name().");
0207   return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(value));
0208 }
0209 template <>
0210 inline const std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
0211   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataType_descriptor,
0212                                                  0, 22>(
0213       static_cast<int>(value));
0214 }
0215 inline bool TensorProto_DataType_Parse(absl::string_view name, TensorProto_DataType* value) {
0216   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
0217       TensorProto_DataType_descriptor(), name, value);
0218 }
0219 enum TensorProto_DataLocation : int {
0220   TensorProto_DataLocation_DEFAULT = 0,
0221   TensorProto_DataLocation_EXTERNAL = 1,
0222 };
0223
0224 ONNX_API bool TensorProto_DataLocation_IsValid(int value);
0225 ONNX_API extern const uint32_t TensorProto_DataLocation_internal_data_[];
0226 constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = static_cast<TensorProto_DataLocation>(0);
0227 constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = static_cast<TensorProto_DataLocation>(1);
0228 constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = 1 + 1;
0229 ONNX_API const ::google::protobuf::EnumDescriptor*
0230 TensorProto_DataLocation_descriptor();
0231 template <typename T>
0232 const std::string& TensorProto_DataLocation_Name(T value) {
0233   static_assert(std::is_same<T, TensorProto_DataLocation>::value ||
0234                     std::is_integral<T>::value,
0235                 "Incorrect type passed to DataLocation_Name().");
0236   return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(value));
0237 }
0238 template <>
0239 inline const std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value) {
0240   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataLocation_descriptor,
0241                                                  0, 1>(
0242       static_cast<int>(value));
0243 }
0244 inline bool TensorProto_DataLocation_Parse(absl::string_view name, TensorProto_DataLocation* value) {
0245   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataLocation>(
0246       TensorProto_DataLocation_descriptor(), name, value);
0247 }
0248 enum Version : int {
0249   _START_VERSION = 0,
0250   IR_VERSION_2017_10_10 = 1,
0251   IR_VERSION_2017_10_30 = 2,
0252   IR_VERSION_2017_11_3 = 3,
0253   IR_VERSION_2019_1_22 = 4,
0254   IR_VERSION_2019_3_18 = 5,
0255   IR_VERSION_2019_9_19 = 6,
0256   IR_VERSION_2020_5_8 = 7,
0257   IR_VERSION_2021_7_30 = 8,
0258   IR_VERSION_2023_5_5 = 9,
0259   IR_VERSION = 10,
0260 };
0261
0262 ONNX_API bool Version_IsValid(int value);
0263 ONNX_API extern const uint32_t Version_internal_data_[];
0264 constexpr Version Version_MIN = static_cast<Version>(0);
0265 constexpr Version Version_MAX = static_cast<Version>(10);
0266 constexpr int Version_ARRAYSIZE = 10 + 1;
0267 ONNX_API const ::google::protobuf::EnumDescriptor*
0268 Version_descriptor();
0269 template <typename T>
0270 const std::string& Version_Name(T value) {
0271   static_assert(std::is_same<T, Version>::value ||
0272                     std::is_integral<T>::value,
0273                 "Incorrect type passed to Version_Name().");
0274   return Version_Name(static_cast<Version>(value));
0275 }
0276 template <>
0277 inline const std::string& Version_Name(Version value) {
0278   return ::google::protobuf::internal::NameOfDenseEnum<Version_descriptor,
0279                                                  0, 10>(
0280       static_cast<int>(value));
0281 }
0282 inline bool Version_Parse(absl::string_view name, Version* value) {
0283   return ::google::protobuf::internal::ParseNamedEnum<Version>(
0284       Version_descriptor(), name, value);
0285 }
0286 enum OperatorStatus : int {
0287   EXPERIMENTAL = 0,
0288   STABLE = 1,
0289 };
0290
0291 ONNX_API bool OperatorStatus_IsValid(int value);
0292 ONNX_API extern const uint32_t OperatorStatus_internal_data_[];
0293 constexpr OperatorStatus OperatorStatus_MIN = static_cast<OperatorStatus>(0);
0294 constexpr OperatorStatus OperatorStatus_MAX = static_cast<OperatorStatus>(1);
0295 constexpr int OperatorStatus_ARRAYSIZE = 1 + 1;
0296 ONNX_API const ::google::protobuf::EnumDescriptor*
0297 OperatorStatus_descriptor();
0298 template <typename T>
0299 const std::string& OperatorStatus_Name(T value) {
0300   static_assert(std::is_same<T, OperatorStatus>::value ||
0301                     std::is_integral<T>::value,
0302                 "Incorrect type passed to OperatorStatus_Name().");
0303   return OperatorStatus_Name(static_cast<OperatorStatus>(value));
0304 }
0305 template <>
0306 inline const std::string& OperatorStatus_Name(OperatorStatus value) {
0307   return ::google::protobuf::internal::NameOfDenseEnum<OperatorStatus_descriptor,
0308                                                  0, 1>(
0309       static_cast<int>(value));
0310 }
0311 inline bool OperatorStatus_Parse(absl::string_view name, OperatorStatus* value) {
0312   return ::google::protobuf::internal::ParseNamedEnum<OperatorStatus>(
0313       OperatorStatus_descriptor(), name, value);
0314 }
0315
0316 // ===================================================================
0317
0318
0319 // -------------------------------------------------------------------
0320
0321 class ONNX_API TypeProto_Opaque final : public ::google::protobuf::Message
0322 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Opaque) */ {
0323  public:
0324   inline TypeProto_Opaque() : TypeProto_Opaque(nullptr) {}
0325   ~TypeProto_Opaque() PROTOBUF_FINAL;
0326   template <typename = void>
0327   explicit PROTOBUF_CONSTEXPR TypeProto_Opaque(
0328       ::google::protobuf::internal::ConstantInitialized);
0329
0330   inline TypeProto_Opaque(const TypeProto_Opaque& from) : TypeProto_Opaque(nullptr, from) {}
0331   inline TypeProto_Opaque(TypeProto_Opaque&& from) noexcept
0332       : TypeProto_Opaque(nullptr, std::move(from)) {}
0333   inline TypeProto_Opaque& operator=(const TypeProto_Opaque& from) {
0334     CopyFrom(from);
0335     return *this;
0336   }
0337   inline TypeProto_Opaque& operator=(TypeProto_Opaque&& from) noexcept {
0338     if (this == &from) return *this;
0339     if (GetArena() == from.GetArena()
0340 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0341         && GetArena() != nullptr
0342 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0343     ) {
0344       InternalSwap(&from);
0345     } else {
0346       CopyFrom(from);
0347     }
0348     return *this;
0349   }
0350
0351   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0352       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0353     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0354   }
0355   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0356       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0357     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0358   }
0359
0360   static const ::google::protobuf::Descriptor* descriptor() {
0361     return GetDescriptor();
0362   }
0363   static const ::google::protobuf::Descriptor* GetDescriptor() {
0364     return default_instance().GetMetadata().descriptor;
0365   }
0366   static const ::google::protobuf::Reflection* GetReflection() {
0367     return default_instance().GetMetadata().reflection;
0368   }
0369   static const TypeProto_Opaque& default_instance() {
0370     return *internal_default_instance();
0371   }
0372   static inline const TypeProto_Opaque* internal_default_instance() {
0373     return reinterpret_cast<const TypeProto_Opaque*>(
0374         &_TypeProto_Opaque_default_instance_);
0375   }
0376   static constexpr int kIndexInFileMessages = 18;
0377   friend void swap(TypeProto_Opaque& a, TypeProto_Opaque& b) { a.Swap(&b); }
0378   inline void Swap(TypeProto_Opaque* other) {
0379     if (other == this) return;
0380 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0381     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0382 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0383     if (GetArena() == other->GetArena()) {
0384 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0385       InternalSwap(other);
0386     } else {
0387       ::google::protobuf::internal::GenericSwap(this, other);
0388     }
0389   }
0390   void UnsafeArenaSwap(TypeProto_Opaque* other) {
0391     if (other == this) return;
0392     ABSL_DCHECK(GetArena() == other->GetArena());
0393     InternalSwap(other);
0394   }
0395
0396   // implements Message ----------------------------------------------
0397
0398   TypeProto_Opaque* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0399     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Opaque>(arena);
0400   }
0401   using ::google::protobuf::Message::CopyFrom;
0402   void CopyFrom(const TypeProto_Opaque& from);
0403   using ::google::protobuf::Message::MergeFrom;
0404   void MergeFrom(const TypeProto_Opaque& from) { TypeProto_Opaque::MergeImpl(*this, from); }
0405
0406   private:
0407   static void MergeImpl(
0408       ::google::protobuf::MessageLite& to_msg,
0409       const ::google::protobuf::MessageLite& from_msg);
0410
0411   public:
0412   bool IsInitialized() const {
0413     return true;
0414   }
0415   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0416   #if defined(PROTOBUF_CUSTOM_VTABLE)
0417   private:
0418   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0419   static ::uint8_t* _InternalSerialize(
0420       const MessageLite& msg, ::uint8_t* target,
0421       ::google::protobuf::io::EpsCopyOutputStream* stream);
0422
0423   public:
0424   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0425   ::uint8_t* _InternalSerialize(
0426       ::uint8_t* target,
0427       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0428     return _InternalSerialize(*this, target, stream);
0429   }
0430   #else   // PROTOBUF_CUSTOM_VTABLE
0431   ::size_t ByteSizeLong() const final;
0432   ::uint8_t* _InternalSerialize(
0433       ::uint8_t* target,
0434       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0435   #endif  // PROTOBUF_CUSTOM_VTABLE
0436   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0437
0438   private:
0439   void SharedCtor(::google::protobuf::Arena* arena);
0440   void SharedDtor();
0441   void InternalSwap(TypeProto_Opaque* other);
0442  private:
0443   friend class ::google::protobuf::internal::AnyMetadata;
0444   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Opaque"; }
0445
0446  protected:
0447   explicit TypeProto_Opaque(::google::protobuf::Arena* arena);
0448   TypeProto_Opaque(::google::protobuf::Arena* arena, const TypeProto_Opaque& from);
0449   TypeProto_Opaque(::google::protobuf::Arena* arena, TypeProto_Opaque&& from) noexcept
0450       : TypeProto_Opaque(arena) {
0451     *this = ::std::move(from);
0452   }
0453   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0454   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0455
0456  public:
0457   ::google::protobuf::Metadata GetMetadata() const;
0458   // nested types ----------------------------------------------------
0459
0460   // accessors -------------------------------------------------------
0461   enum : int {
0462     kDomainFieldNumber = 1,
0463     kNameFieldNumber = 2,
0464   };
0465   // optional string domain = 1;
0466   bool has_domain() const;
0467   void clear_domain() ;
0468   const std::string& domain() const;
0469   template <typename Arg_ = const std::string&, typename... Args_>
0470   void set_domain(Arg_&& arg, Args_... args);
0471   std::string* mutable_domain();
0472   PROTOBUF_NODISCARD std::string* release_domain();
0473   void set_allocated_domain(std::string* value);
0474
0475   private:
0476   const std::string& _internal_domain() const;
0477   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
0478       const std::string& value);
0479   std::string* _internal_mutable_domain();
0480
0481   public:
0482   // optional string name = 2;
0483   bool has_name() const;
0484   void clear_name() ;
0485   const std::string& name() const;
0486   template <typename Arg_ = const std::string&, typename... Args_>
0487   void set_name(Arg_&& arg, Args_... args);
0488   std::string* mutable_name();
0489   PROTOBUF_NODISCARD std::string* release_name();
0490   void set_allocated_name(std::string* value);
0491
0492   private:
0493   const std::string& _internal_name() const;
0494   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
0495       const std::string& value);
0496   std::string* _internal_mutable_name();
0497
0498   public:
0499   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Opaque)
0500  private:
0501   class _Internal;
0502   friend class ::google::protobuf::internal::TcParser;
0503   static const ::google::protobuf::internal::TcParseTable<
0504       1, 2, 0,
0505       40, 2>
0506       _table_;
0507
0508
0509   friend class ::google::protobuf::MessageLite;
0510   friend class ::google::protobuf::Arena;
0511   template <typename T>
0512   friend class ::google::protobuf::Arena::InternalHelper;
0513   using InternalArenaConstructable_ = void;
0514   using DestructorSkippable_ = void;
0515   struct Impl_ {
0516     inline explicit constexpr Impl_(
0517         ::google::protobuf::internal::ConstantInitialized) noexcept;
0518     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0519                           ::google::protobuf::Arena* arena);
0520     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0521                           ::google::protobuf::Arena* arena, const Impl_& from,
0522                           const TypeProto_Opaque& from_msg);
0523     ::google::protobuf::internal::HasBits<1> _has_bits_;
0524     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0525     ::google::protobuf::internal::ArenaStringPtr domain_;
0526     ::google::protobuf::internal::ArenaStringPtr name_;
0527     PROTOBUF_TSAN_DECLARE_MEMBER
0528   };
0529   union { Impl_ _impl_; };
0530   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
0531 };
0532 // -------------------------------------------------------------------
0533
0534 class ONNX_API TensorShapeProto_Dimension final : public ::google::protobuf::Message
0535 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
0536  public:
0537   inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
0538   ~TensorShapeProto_Dimension() PROTOBUF_FINAL;
0539   template <typename = void>
0540   explicit PROTOBUF_CONSTEXPR TensorShapeProto_Dimension(
0541       ::google::protobuf::internal::ConstantInitialized);
0542
0543   inline TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from) : TensorShapeProto_Dimension(nullptr, from) {}
0544   inline TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
0545       : TensorShapeProto_Dimension(nullptr, std::move(from)) {}
0546   inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
0547     CopyFrom(from);
0548     return *this;
0549   }
0550   inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
0551     if (this == &from) return *this;
0552     if (GetArena() == from.GetArena()
0553 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0554         && GetArena() != nullptr
0555 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0556     ) {
0557       InternalSwap(&from);
0558     } else {
0559       CopyFrom(from);
0560     }
0561     return *this;
0562   }
0563
0564   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0565       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0566     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0567   }
0568   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0569       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0570     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0571   }
0572
0573   static const ::google::protobuf::Descriptor* descriptor() {
0574     return GetDescriptor();
0575   }
0576   static const ::google::protobuf::Descriptor* GetDescriptor() {
0577     return default_instance().GetMetadata().descriptor;
0578   }
0579   static const ::google::protobuf::Reflection* GetReflection() {
0580     return default_instance().GetMetadata().reflection;
0581   }
0582   static const TensorShapeProto_Dimension& default_instance() {
0583     return *internal_default_instance();
0584   }
0585   enum ValueCase {
0586     kDimValue = 1,
0587     kDimParam = 2,
0588     VALUE_NOT_SET = 0,
0589   };
0590   static inline const TensorShapeProto_Dimension* internal_default_instance() {
0591     return reinterpret_cast<const TensorShapeProto_Dimension*>(
0592         &_TensorShapeProto_Dimension_default_instance_);
0593   }
0594   static constexpr int kIndexInFileMessages = 11;
0595   friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) { a.Swap(&b); }
0596   inline void Swap(TensorShapeProto_Dimension* other) {
0597     if (other == this) return;
0598 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0599     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0600 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0601     if (GetArena() == other->GetArena()) {
0602 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0603       InternalSwap(other);
0604     } else {
0605       ::google::protobuf::internal::GenericSwap(this, other);
0606     }
0607   }
0608   void UnsafeArenaSwap(TensorShapeProto_Dimension* other) {
0609     if (other == this) return;
0610     ABSL_DCHECK(GetArena() == other->GetArena());
0611     InternalSwap(other);
0612   }
0613
0614   // implements Message ----------------------------------------------
0615
0616   TensorShapeProto_Dimension* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0617     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto_Dimension>(arena);
0618   }
0619   using ::google::protobuf::Message::CopyFrom;
0620   void CopyFrom(const TensorShapeProto_Dimension& from);
0621   using ::google::protobuf::Message::MergeFrom;
0622   void MergeFrom(const TensorShapeProto_Dimension& from) { TensorShapeProto_Dimension::MergeImpl(*this, from); }
0623
0624   private:
0625   static void MergeImpl(
0626       ::google::protobuf::MessageLite& to_msg,
0627       const ::google::protobuf::MessageLite& from_msg);
0628
0629   public:
0630   bool IsInitialized() const {
0631     return true;
0632   }
0633   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0634   #if defined(PROTOBUF_CUSTOM_VTABLE)
0635   private:
0636   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0637   static ::uint8_t* _InternalSerialize(
0638       const MessageLite& msg, ::uint8_t* target,
0639       ::google::protobuf::io::EpsCopyOutputStream* stream);
0640
0641   public:
0642   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0643   ::uint8_t* _InternalSerialize(
0644       ::uint8_t* target,
0645       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0646     return _InternalSerialize(*this, target, stream);
0647   }
0648   #else   // PROTOBUF_CUSTOM_VTABLE
0649   ::size_t ByteSizeLong() const final;
0650   ::uint8_t* _InternalSerialize(
0651       ::uint8_t* target,
0652       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0653   #endif  // PROTOBUF_CUSTOM_VTABLE
0654   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0655
0656   private:
0657   void SharedCtor(::google::protobuf::Arena* arena);
0658   void SharedDtor();
0659   void InternalSwap(TensorShapeProto_Dimension* other);
0660  private:
0661   friend class ::google::protobuf::internal::AnyMetadata;
0662   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto.Dimension"; }
0663
0664  protected:
0665   explicit TensorShapeProto_Dimension(::google::protobuf::Arena* arena);
0666   TensorShapeProto_Dimension(::google::protobuf::Arena* arena, const TensorShapeProto_Dimension& from);
0667   TensorShapeProto_Dimension(::google::protobuf::Arena* arena, TensorShapeProto_Dimension&& from) noexcept
0668       : TensorShapeProto_Dimension(arena) {
0669     *this = ::std::move(from);
0670   }
0671   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0672   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0673
0674  public:
0675   ::google::protobuf::Metadata GetMetadata() const;
0676   // nested types ----------------------------------------------------
0677
0678   // accessors -------------------------------------------------------
0679   enum : int {
0680     kDenotationFieldNumber = 3,
0681     kDimValueFieldNumber = 1,
0682     kDimParamFieldNumber = 2,
0683   };
0684   // optional string denotation = 3;
0685   bool has_denotation() const;
0686   void clear_denotation() ;
0687   const std::string& denotation() const;
0688   template <typename Arg_ = const std::string&, typename... Args_>
0689   void set_denotation(Arg_&& arg, Args_... args);
0690   std::string* mutable_denotation();
0691   PROTOBUF_NODISCARD std::string* release_denotation();
0692   void set_allocated_denotation(std::string* value);
0693
0694   private:
0695   const std::string& _internal_denotation() const;
0696   inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(
0697       const std::string& value);
0698   std::string* _internal_mutable_denotation();
0699
0700   public:
0701   // int64 dim_value = 1;
0702   bool has_dim_value() const;
0703   void clear_dim_value() ;
0704   ::int64_t dim_value() const;
0705   void set_dim_value(::int64_t value);
0706
0707   private:
0708   ::int64_t _internal_dim_value() const;
0709   void _internal_set_dim_value(::int64_t value);
0710
0711   public:
0712   // string dim_param = 2;
0713   bool has_dim_param() const;
0714   void clear_dim_param() ;
0715   const std::string& dim_param() const;
0716   template <typename Arg_ = const std::string&, typename... Args_>
0717   void set_dim_param(Arg_&& arg, Args_... args);
0718   std::string* mutable_dim_param();
0719   PROTOBUF_NODISCARD std::string* release_dim_param();
0720   void set_allocated_dim_param(std::string* value);
0721
0722   private:
0723   const std::string& _internal_dim_param() const;
0724   inline PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(
0725       const std::string& value);
0726   std::string* _internal_mutable_dim_param();
0727
0728   public:
0729   void clear_value();
0730   ValueCase value_case() const;
0731   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
0732  private:
0733   class _Internal;
0734   void set_has_dim_value();
0735   void set_has_dim_param();
0736   inline bool has_value() const;
0737   inline void clear_has_value();
0738   friend class ::google::protobuf::internal::TcParser;
0739   static const ::google::protobuf::internal::TcParseTable<
0740       0, 3, 0,
0741       59, 2>
0742       _table_;
0743
0744
0745   friend class ::google::protobuf::MessageLite;
0746   friend class ::google::protobuf::Arena;
0747   template <typename T>
0748   friend class ::google::protobuf::Arena::InternalHelper;
0749   using InternalArenaConstructable_ = void;
0750   using DestructorSkippable_ = void;
0751   struct Impl_ {
0752     inline explicit constexpr Impl_(
0753         ::google::protobuf::internal::ConstantInitialized) noexcept;
0754     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0755                           ::google::protobuf::Arena* arena);
0756     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0757                           ::google::protobuf::Arena* arena, const Impl_& from,
0758                           const TensorShapeProto_Dimension& from_msg);
0759     ::google::protobuf::internal::HasBits<1> _has_bits_;
0760     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0761     ::google::protobuf::internal::ArenaStringPtr denotation_;
0762     union ValueUnion {
0763       constexpr ValueUnion() : _constinit_{} {}
0764       ::google::protobuf::internal::ConstantInitialized _constinit_;
0765       ::int64_t dim_value_;
0766       ::google::protobuf::internal::ArenaStringPtr dim_param_;
0767     } value_;
0768     ::uint32_t _oneof_case_[1];
0769     PROTOBUF_TSAN_DECLARE_MEMBER
0770   };
0771   union { Impl_ _impl_; };
0772   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
0773 };
0774 // -------------------------------------------------------------------
0775
0776 class ONNX_API TensorProto_Segment final : public ::google::protobuf::Message
0777 /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
0778  public:
0779   inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
0780   ~TensorProto_Segment() PROTOBUF_FINAL;
0781   template <typename = void>
0782   explicit PROTOBUF_CONSTEXPR TensorProto_Segment(
0783       ::google::protobuf::internal::ConstantInitialized);
0784
0785   inline TensorProto_Segment(const TensorProto_Segment& from) : TensorProto_Segment(nullptr, from) {}
0786   inline TensorProto_Segment(TensorProto_Segment&& from) noexcept
0787       : TensorProto_Segment(nullptr, std::move(from)) {}
0788   inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
0789     CopyFrom(from);
0790     return *this;
0791   }
0792   inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
0793     if (this == &from) return *this;
0794     if (GetArena() == from.GetArena()
0795 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0796         && GetArena() != nullptr
0797 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0798     ) {
0799       InternalSwap(&from);
0800     } else {
0801       CopyFrom(from);
0802     }
0803     return *this;
0804   }
0805
0806   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0807       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0808     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0809   }
0810   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0811       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0812     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0813   }
0814
0815   static const ::google::protobuf::Descriptor* descriptor() {
0816     return GetDescriptor();
0817   }
0818   static const ::google::protobuf::Descriptor* GetDescriptor() {
0819     return default_instance().GetMetadata().descriptor;
0820   }
0821   static const ::google::protobuf::Reflection* GetReflection() {
0822     return default_instance().GetMetadata().reflection;
0823   }
0824   static const TensorProto_Segment& default_instance() {
0825     return *internal_default_instance();
0826   }
0827   static inline const TensorProto_Segment* internal_default_instance() {
0828     return reinterpret_cast<const TensorProto_Segment*>(
0829         &_TensorProto_Segment_default_instance_);
0830   }
0831   static constexpr int kIndexInFileMessages = 8;
0832   friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) { a.Swap(&b); }
0833   inline void Swap(TensorProto_Segment* other) {
0834     if (other == this) return;
0835 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0836     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0837 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0838     if (GetArena() == other->GetArena()) {
0839 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0840       InternalSwap(other);
0841     } else {
0842       ::google::protobuf::internal::GenericSwap(this, other);
0843     }
0844   }
0845   void UnsafeArenaSwap(TensorProto_Segment* other) {
0846     if (other == this) return;
0847     ABSL_DCHECK(GetArena() == other->GetArena());
0848     InternalSwap(other);
0849   }
0850
0851   // implements Message ----------------------------------------------
0852
0853   TensorProto_Segment* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0854     return ::google::protobuf::Message::DefaultConstruct<TensorProto_Segment>(arena);
0855   }
0856   using ::google::protobuf::Message::CopyFrom;
0857   void CopyFrom(const TensorProto_Segment& from);
0858   using ::google::protobuf::Message::MergeFrom;
0859   void MergeFrom(const TensorProto_Segment& from) { TensorProto_Segment::MergeImpl(*this, from); }
0860
0861   private:
0862   static void MergeImpl(
0863       ::google::protobuf::MessageLite& to_msg,
0864       const ::google::protobuf::MessageLite& from_msg);
0865
0866   public:
0867   bool IsInitialized() const {
0868     return true;
0869   }
0870   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0871   #if defined(PROTOBUF_CUSTOM_VTABLE)
0872   private:
0873   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0874   static ::uint8_t* _InternalSerialize(
0875       const MessageLite& msg, ::uint8_t* target,
0876       ::google::protobuf::io::EpsCopyOutputStream* stream);
0877
0878   public:
0879   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0880   ::uint8_t* _InternalSerialize(
0881       ::uint8_t* target,
0882       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0883     return _InternalSerialize(*this, target, stream);
0884   }
0885   #else   // PROTOBUF_CUSTOM_VTABLE
0886   ::size_t ByteSizeLong() const final;
0887   ::uint8_t* _InternalSerialize(
0888       ::uint8_t* target,
0889       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0890   #endif  // PROTOBUF_CUSTOM_VTABLE
0891   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0892
0893   private:
0894   void SharedCtor(::google::protobuf::Arena* arena);
0895   void SharedDtor();
0896   void InternalSwap(TensorProto_Segment* other);
0897  private:
0898   friend class ::google::protobuf::internal::AnyMetadata;
0899   static ::absl::string_view FullMessageName() { return "onnx.TensorProto.Segment"; }
0900
0901  protected:
0902   explicit TensorProto_Segment(::google::protobuf::Arena* arena);
0903   TensorProto_Segment(::google::protobuf::Arena* arena, const TensorProto_Segment& from);
0904   TensorProto_Segment(::google::protobuf::Arena* arena, TensorProto_Segment&& from) noexcept
0905       : TensorProto_Segment(arena) {
0906     *this = ::std::move(from);
0907   }
0908   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0909   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0910
0911  public:
0912   ::google::protobuf::Metadata GetMetadata() const;
0913   // nested types ----------------------------------------------------
0914
0915   // accessors -------------------------------------------------------
0916   enum : int {
0917     kBeginFieldNumber = 1,
0918     kEndFieldNumber = 2,
0919   };
0920   // optional int64 begin = 1;
0921   bool has_begin() const;
0922   void clear_begin() ;
0923   ::int64_t begin() const;
0924   void set_begin(::int64_t value);
0925
0926   private:
0927   ::int64_t _internal_begin() const;
0928   void _internal_set_begin(::int64_t value);
0929
0930   public:
0931   // optional int64 end = 2;
0932   bool has_end() const;
0933   void clear_end() ;
0934   ::int64_t end() const;
0935   void set_end(::int64_t value);
0936
0937   private:
0938   ::int64_t _internal_end() const;
0939   void _internal_set_end(::int64_t value);
0940
0941   public:
0942   // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment)
0943  private:
0944   class _Internal;
0945   friend class ::google::protobuf::internal::TcParser;
0946   static const ::google::protobuf::internal::TcParseTable<
0947       1, 2, 0,
0948       0, 2>
0949       _table_;
0950
0951
0952   friend class ::google::protobuf::MessageLite;
0953   friend class ::google::protobuf::Arena;
0954   template <typename T>
0955   friend class ::google::protobuf::Arena::InternalHelper;
0956   using InternalArenaConstructable_ = void;
0957   using DestructorSkippable_ = void;
0958   struct Impl_ {
0959     inline explicit constexpr Impl_(
0960         ::google::protobuf::internal::ConstantInitialized) noexcept;
0961     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0962                           ::google::protobuf::Arena* arena);
0963     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0964                           ::google::protobuf::Arena* arena, const Impl_& from,
0965                           const TensorProto_Segment& from_msg);
0966     ::google::protobuf::internal::HasBits<1> _has_bits_;
0967     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0968     ::int64_t begin_;
0969     ::int64_t end_;
0970     PROTOBUF_TSAN_DECLARE_MEMBER
0971   };
0972   union { Impl_ _impl_; };
0973   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
0974 };
0975 // -------------------------------------------------------------------
0976
0977 class ONNX_API StringStringEntryProto final : public ::google::protobuf::Message
0978 /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
0979  public:
0980   inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
0981   ~StringStringEntryProto() PROTOBUF_FINAL;
0982   template <typename = void>
0983   explicit PROTOBUF_CONSTEXPR StringStringEntryProto(
0984       ::google::protobuf::internal::ConstantInitialized);
0985
0986   inline StringStringEntryProto(const StringStringEntryProto& from) : StringStringEntryProto(nullptr, from) {}
0987   inline StringStringEntryProto(StringStringEntryProto&& from) noexcept
0988       : StringStringEntryProto(nullptr, std::move(from)) {}
0989   inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
0990     CopyFrom(from);
0991     return *this;
0992   }
0993   inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
0994     if (this == &from) return *this;
0995     if (GetArena() == from.GetArena()
0996 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0997         && GetArena() != nullptr
0998 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0999     ) {
1000       InternalSwap(&from);
1001     } else {
1002       CopyFrom(from);
1003     }
1004     return *this;
1005   }
1006
1007   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1008       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1009     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1010   }
1011   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
1012       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1013     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1014   }
1015
1016   static const ::google::protobuf::Descriptor* descriptor() {
1017     return GetDescriptor();
1018   }
1019   static const ::google::protobuf::Descriptor* GetDescriptor() {
1020     return default_instance().GetMetadata().descriptor;
1021   }
1022   static const ::google::protobuf::Reflection* GetReflection() {
1023     return default_instance().GetMetadata().reflection;
1024   }
1025   static const StringStringEntryProto& default_instance() {
1026     return *internal_default_instance();
1027   }
1028   static inline const StringStringEntryProto* internal_default_instance() {
1029     return reinterpret_cast<const StringStringEntryProto*>(
1030         &_StringStringEntryProto_default_instance_);
1031   }
1032   static constexpr int kIndexInFileMessages = 5;
1033   friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) { a.Swap(&b); }
1034   inline void Swap(StringStringEntryProto* other) {
1035     if (other == this) return;
1036 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1037     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
1038 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
1039     if (GetArena() == other->GetArena()) {
1040 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1041       InternalSwap(other);
1042     } else {
1043       ::google::protobuf::internal::GenericSwap(this, other);
1044     }
1045   }
1046   void UnsafeArenaSwap(StringStringEntryProto* other) {
1047     if (other == this) return;
1048     ABSL_DCHECK(GetArena() == other->GetArena());
1049     InternalSwap(other);
1050   }
1051
1052   // implements Message ----------------------------------------------
1053
1054   StringStringEntryProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
1055     return ::google::protobuf::Message::DefaultConstruct<StringStringEntryProto>(arena);
1056   }
1057   using ::google::protobuf::Message::CopyFrom;
1058   void CopyFrom(const StringStringEntryProto& from);
1059   using ::google::protobuf::Message::MergeFrom;
1060   void MergeFrom(const StringStringEntryProto& from) { StringStringEntryProto::MergeImpl(*this, from); }
1061
1062   private:
1063   static void MergeImpl(
1064       ::google::protobuf::MessageLite& to_msg,
1065       const ::google::protobuf::MessageLite& from_msg);
1066
1067   public:
1068   bool IsInitialized() const {
1069     return true;
1070   }
1071   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1072   #if defined(PROTOBUF_CUSTOM_VTABLE)
1073   private:
1074   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1075   static ::uint8_t* _InternalSerialize(
1076       const MessageLite& msg, ::uint8_t* target,
1077       ::google::protobuf::io::EpsCopyOutputStream* stream);
1078
1079   public:
1080   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1081   ::uint8_t* _InternalSerialize(
1082       ::uint8_t* target,
1083       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
1084     return _InternalSerialize(*this, target, stream);
1085   }
1086   #else   // PROTOBUF_CUSTOM_VTABLE
1087   ::size_t ByteSizeLong() const final;
1088   ::uint8_t* _InternalSerialize(
1089       ::uint8_t* target,
1090       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
1091   #endif  // PROTOBUF_CUSTOM_VTABLE
1092   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1093
1094   private:
1095   void SharedCtor(::google::protobuf::Arena* arena);
1096   void SharedDtor();
1097   void InternalSwap(StringStringEntryProto* other);
1098  private:
1099   friend class ::google::protobuf::internal::AnyMetadata;
1100   static ::absl::string_view FullMessageName() { return "onnx.StringStringEntryProto"; }
1101
1102  protected:
1103   explicit StringStringEntryProto(::google::protobuf::Arena* arena);
1104   StringStringEntryProto(::google::protobuf::Arena* arena, const StringStringEntryProto& from);
1105   StringStringEntryProto(::google::protobuf::Arena* arena, StringStringEntryProto&& from) noexcept
1106       : StringStringEntryProto(arena) {
1107     *this = ::std::move(from);
1108   }
1109   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
1110   static const ::google::protobuf::Message::ClassDataFull _class_data_;
1111
1112  public:
1113   ::google::protobuf::Metadata GetMetadata() const;
1114   // nested types ----------------------------------------------------
1115
1116   // accessors -------------------------------------------------------
1117   enum : int {
1118     kKeyFieldNumber = 1,
1119     kValueFieldNumber = 2,
1120   };
1121   // optional string key = 1;
1122   bool has_key() const;
1123   void clear_key() ;
1124   const std::string& key() const;
1125   template <typename Arg_ = const std::string&, typename... Args_>
1126   void set_key(Arg_&& arg, Args_... args);
1127   std::string* mutable_key();
1128   PROTOBUF_NODISCARD std::string* release_key();
1129   void set_allocated_key(std::string* value);
1130
1131   private:
1132   const std::string& _internal_key() const;
1133   inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
1134       const std::string& value);
1135   std::string* _internal_mutable_key();
1136
1137   public:
1138   // optional string value = 2;
1139   bool has_value() const;
1140   void clear_value() ;
1141   const std::string& value() const;
1142   template <typename Arg_ = const std::string&, typename... Args_>
1143   void set_value(Arg_&& arg, Args_... args);
1144   std::string* mutable_value();
1145   PROTOBUF_NODISCARD std::string* release_value();
1146   void set_allocated_value(std::string* value);
1147
1148   private:
1149   const std::string& _internal_value() const;
1150   inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(
1151       const std::string& value);
1152   std::string* _internal_mutable_value();
1153
1154   public:
1155   // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto)
1156  private:
1157   class _Internal;
1158   friend class ::google::protobuf::internal::TcParser;
1159   static const ::google::protobuf::internal::TcParseTable<
1160       1, 2, 0,
1161       44, 2>
1162       _table_;
1163
1164
1165   friend class ::google::protobuf::MessageLite;
1166   friend class ::google::protobuf::Arena;
1167   template <typename T>
1168   friend class ::google::protobuf::Arena::InternalHelper;
1169   using InternalArenaConstructable_ = void;
1170   using DestructorSkippable_ = void;
1171   struct Impl_ {
1172     inline explicit constexpr Impl_(
1173         ::google::protobuf::internal::ConstantInitialized) noexcept;
1174     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1175                           ::google::protobuf::Arena* arena);
1176     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1177                           ::google::protobuf::Arena* arena, const Impl_& from,
1178                           const StringStringEntryProto& from_msg);
1179     ::google::protobuf::internal::HasBits<1> _has_bits_;
1180     mutable ::google::protobuf::internal::CachedSize _cached_size_;
1181     ::google::protobuf::internal::ArenaStringPtr key_;
1182     ::google::protobuf::internal::ArenaStringPtr value_;
1183     PROTOBUF_TSAN_DECLARE_MEMBER
1184   };
1185   union { Impl_ _impl_; };
1186   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1187 };
1188 // -------------------------------------------------------------------
1189
1190 class ONNX_API OperatorSetIdProto final : public ::google::protobuf::Message
1191 /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
1192  public:
1193   inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
1194   ~OperatorSetIdProto() PROTOBUF_FINAL;
1195   template <typename = void>
1196   explicit PROTOBUF_CONSTEXPR OperatorSetIdProto(
1197       ::google::protobuf::internal::ConstantInitialized);
1198
1199   inline OperatorSetIdProto(const OperatorSetIdProto& from) : OperatorSetIdProto(nullptr, from) {}
1200   inline OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
1201       : OperatorSetIdProto(nullptr, std::move(from)) {}
1202   inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
1203     CopyFrom(from);
1204     return *this;
1205   }
1206   inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
1207     if (this == &from) return *this;
1208     if (GetArena() == from.GetArena()
1209 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1210         && GetArena() != nullptr
1211 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1212     ) {
1213       InternalSwap(&from);
1214     } else {
1215       CopyFrom(from);
1216     }
1217     return *this;
1218   }
1219
1220   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1221       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1222     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1223   }
1224   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
1225       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1226     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1227   }
1228
1229   static const ::google::protobuf::Descriptor* descriptor() {
1230     return GetDescriptor();
1231   }
1232   static const ::google::protobuf::Descriptor* GetDescriptor() {
1233     return default_instance().GetMetadata().descriptor;
1234   }
1235   static const ::google::protobuf::Reflection* GetReflection() {
1236     return default_instance().GetMetadata().reflection;
1237   }
1238   static const OperatorSetIdProto& default_instance() {
1239     return *internal_default_instance();
1240   }
1241   static inline const OperatorSetIdProto* internal_default_instance() {
1242     return reinterpret_cast<const OperatorSetIdProto*>(
1243         &_OperatorSetIdProto_default_instance_);
1244   }
1245   static constexpr int kIndexInFileMessages = 20;
1246   friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) { a.Swap(&b); }
1247   inline void Swap(OperatorSetIdProto* other) {
1248     if (other == this) return;
1249 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1250     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
1251 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
1252     if (GetArena() == other->GetArena()) {
1253 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1254       InternalSwap(other);
1255     } else {
1256       ::google::protobuf::internal::GenericSwap(this, other);
1257     }
1258   }
1259   void UnsafeArenaSwap(OperatorSetIdProto* other) {
1260     if (other == this) return;
1261     ABSL_DCHECK(GetArena() == other->GetArena());
1262     InternalSwap(other);
1263   }
1264
1265   // implements Message ----------------------------------------------
1266
1267   OperatorSetIdProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
1268     return ::google::protobuf::Message::DefaultConstruct<OperatorSetIdProto>(arena);
1269   }
1270   using ::google::protobuf::Message::CopyFrom;
1271   void CopyFrom(const OperatorSetIdProto& from);
1272   using ::google::protobuf::Message::MergeFrom;
1273   void MergeFrom(const OperatorSetIdProto& from) { OperatorSetIdProto::MergeImpl(*this, from); }
1274
1275   private:
1276   static void MergeImpl(
1277       ::google::protobuf::MessageLite& to_msg,
1278       const ::google::protobuf::MessageLite& from_msg);
1279
1280   public:
1281   bool IsInitialized() const {
1282     return true;
1283   }
1284   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1285   #if defined(PROTOBUF_CUSTOM_VTABLE)
1286   private:
1287   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1288   static ::uint8_t* _InternalSerialize(
1289       const MessageLite& msg, ::uint8_t* target,
1290       ::google::protobuf::io::EpsCopyOutputStream* stream);
1291
1292   public:
1293   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1294   ::uint8_t* _InternalSerialize(
1295       ::uint8_t* target,
1296       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
1297     return _InternalSerialize(*this, target, stream);
1298   }
1299   #else   // PROTOBUF_CUSTOM_VTABLE
1300   ::size_t ByteSizeLong() const final;
1301   ::uint8_t* _InternalSerialize(
1302       ::uint8_t* target,
1303       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
1304   #endif  // PROTOBUF_CUSTOM_VTABLE
1305   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1306
1307   private:
1308   void SharedCtor(::google::protobuf::Arena* arena);
1309   void SharedDtor();
1310   void InternalSwap(OperatorSetIdProto* other);
1311  private:
1312   friend class ::google::protobuf::internal::AnyMetadata;
1313   static ::absl::string_view FullMessageName() { return "onnx.OperatorSetIdProto"; }
1314
1315  protected:
1316   explicit OperatorSetIdProto(::google::protobuf::Arena* arena);
1317   OperatorSetIdProto(::google::protobuf::Arena* arena, const OperatorSetIdProto& from);
1318   OperatorSetIdProto(::google::protobuf::Arena* arena, OperatorSetIdProto&& from) noexcept
1319       : OperatorSetIdProto(arena) {
1320     *this = ::std::move(from);
1321   }
1322   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
1323   static const ::google::protobuf::Message::ClassDataFull _class_data_;
1324
1325  public:
1326   ::google::protobuf::Metadata GetMetadata() const;
1327   // nested types ----------------------------------------------------
1328
1329   // accessors -------------------------------------------------------
1330   enum : int {
1331     kDomainFieldNumber = 1,
1332     kVersionFieldNumber = 2,
1333   };
1334   // optional string domain = 1;
1335   bool has_domain() const;
1336   void clear_domain() ;
1337   const std::string& domain() const;
1338   template <typename Arg_ = const std::string&, typename... Args_>
1339   void set_domain(Arg_&& arg, Args_... args);
1340   std::string* mutable_domain();
1341   PROTOBUF_NODISCARD std::string* release_domain();
1342   void set_allocated_domain(std::string* value);
1343
1344   private:
1345   const std::string& _internal_domain() const;
1346   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
1347       const std::string& value);
1348   std::string* _internal_mutable_domain();
1349
1350   public:
1351   // optional int64 version = 2;
1352   bool has_version() const;
1353   void clear_version() ;
1354   ::int64_t version() const;
1355   void set_version(::int64_t value);
1356
1357   private:
1358   ::int64_t _internal_version() const;
1359   void _internal_set_version(::int64_t value);
1360
1361   public:
1362   // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto)
1363  private:
1364   class _Internal;
1365   friend class ::google::protobuf::internal::TcParser;
1366   static const ::google::protobuf::internal::TcParseTable<
1367       1, 2, 0,
1368       38, 2>
1369       _table_;
1370
1371
1372   friend class ::google::protobuf::MessageLite;
1373   friend class ::google::protobuf::Arena;
1374   template <typename T>
1375   friend class ::google::protobuf::Arena::InternalHelper;
1376   using InternalArenaConstructable_ = void;
1377   using DestructorSkippable_ = void;
1378   struct Impl_ {
1379     inline explicit constexpr Impl_(
1380         ::google::protobuf::internal::ConstantInitialized) noexcept;
1381     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1382                           ::google::protobuf::Arena* arena);
1383     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1384                           ::google::protobuf::Arena* arena, const Impl_& from,
1385                           const OperatorSetIdProto& from_msg);
1386     ::google::protobuf::internal::HasBits<1> _has_bits_;
1387     mutable ::google::protobuf::internal::CachedSize _cached_size_;
1388     ::google::protobuf::internal::ArenaStringPtr domain_;
1389     ::int64_t version_;
1390     PROTOBUF_TSAN_DECLARE_MEMBER
1391   };
1392   union { Impl_ _impl_; };
1393   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1394 };
1395 // -------------------------------------------------------------------
1396
1397 class ONNX_API TensorShapeProto final : public ::google::protobuf::Message
1398 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
1399  public:
1400   inline TensorShapeProto() : TensorShapeProto(nullptr) {}
1401   ~TensorShapeProto() PROTOBUF_FINAL;
1402   template <typename = void>
1403   explicit PROTOBUF_CONSTEXPR TensorShapeProto(
1404       ::google::protobuf::internal::ConstantInitialized);
1405
1406   inline TensorShapeProto(const TensorShapeProto& from) : TensorShapeProto(nullptr, from) {}
1407   inline TensorShapeProto(TensorShapeProto&& from) noexcept
1408       : TensorShapeProto(nullptr, std::move(from)) {}
1409   inline TensorShapeProto& operator=(const TensorShapeProto& from) {
1410     CopyFrom(from);
1411     return *this;
1412   }
1413   inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
1414     if (this == &from) return *this;
1415     if (GetArena() == from.GetArena()
1416 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1417         && GetArena() != nullptr
1418 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1419     ) {
1420       InternalSwap(&from);
1421     } else {
1422       CopyFrom(from);
1423     }
1424     return *this;
1425   }
1426
1427   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1428       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1429     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1430   }
1431   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
1432       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1433     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1434   }
1435
1436   static const ::google::protobuf::Descriptor* descriptor() {
1437     return GetDescriptor();
1438   }
1439   static const ::google::protobuf::Descriptor* GetDescriptor() {
1440     return default_instance().GetMetadata().descriptor;
1441   }
1442   static const ::google::protobuf::Reflection* GetReflection() {
1443     return default_instance().GetMetadata().reflection;
1444   }
1445   static const TensorShapeProto& default_instance() {
1446     return *internal_default_instance();
1447   }
1448   static inline const TensorShapeProto* internal_default_instance() {
1449     return reinterpret_cast<const TensorShapeProto*>(
1450         &_TensorShapeProto_default_instance_);
1451   }
1452   static constexpr int kIndexInFileMessages = 12;
1453   friend void swap(TensorShapeProto& a, TensorShapeProto& b) { a.Swap(&b); }
1454   inline void Swap(TensorShapeProto* other) {
1455     if (other == this) return;
1456 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1457     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
1458 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
1459     if (GetArena() == other->GetArena()) {
1460 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1461       InternalSwap(other);
1462     } else {
1463       ::google::protobuf::internal::GenericSwap(this, other);
1464     }
1465   }
1466   void UnsafeArenaSwap(TensorShapeProto* other) {
1467     if (other == this) return;
1468     ABSL_DCHECK(GetArena() == other->GetArena());
1469     InternalSwap(other);
1470   }
1471
1472   // implements Message ----------------------------------------------
1473
1474   TensorShapeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
1475     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto>(arena);
1476   }
1477   using ::google::protobuf::Message::CopyFrom;
1478   void CopyFrom(const TensorShapeProto& from);
1479   using ::google::protobuf::Message::MergeFrom;
1480   void MergeFrom(const TensorShapeProto& from) { TensorShapeProto::MergeImpl(*this, from); }
1481
1482   private:
1483   static void MergeImpl(
1484       ::google::protobuf::MessageLite& to_msg,
1485       const ::google::protobuf::MessageLite& from_msg);
1486
1487   public:
1488   bool IsInitialized() const {
1489     return true;
1490   }
1491   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1492   #if defined(PROTOBUF_CUSTOM_VTABLE)
1493   private:
1494   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1495   static ::uint8_t* _InternalSerialize(
1496       const MessageLite& msg, ::uint8_t* target,
1497       ::google::protobuf::io::EpsCopyOutputStream* stream);
1498
1499   public:
1500   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1501   ::uint8_t* _InternalSerialize(
1502       ::uint8_t* target,
1503       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
1504     return _InternalSerialize(*this, target, stream);
1505   }
1506   #else   // PROTOBUF_CUSTOM_VTABLE
1507   ::size_t ByteSizeLong() const final;
1508   ::uint8_t* _InternalSerialize(
1509       ::uint8_t* target,
1510       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
1511   #endif  // PROTOBUF_CUSTOM_VTABLE
1512   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1513
1514   private:
1515   void SharedCtor(::google::protobuf::Arena* arena);
1516   void SharedDtor();
1517   void InternalSwap(TensorShapeProto* other);
1518  private:
1519   friend class ::google::protobuf::internal::AnyMetadata;
1520   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto"; }
1521
1522  protected:
1523   explicit TensorShapeProto(::google::protobuf::Arena* arena);
1524   TensorShapeProto(::google::protobuf::Arena* arena, const TensorShapeProto& from);
1525   TensorShapeProto(::google::protobuf::Arena* arena, TensorShapeProto&& from) noexcept
1526       : TensorShapeProto(arena) {
1527     *this = ::std::move(from);
1528   }
1529   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
1530   static const ::google::protobuf::Message::ClassDataFull _class_data_;
1531
1532  public:
1533   ::google::protobuf::Metadata GetMetadata() const;
1534   // nested types ----------------------------------------------------
1535   using Dimension = TensorShapeProto_Dimension;
1536
1537   // accessors -------------------------------------------------------
1538   enum : int {
1539     kDimFieldNumber = 1,
1540   };
1541   // repeated .onnx.TensorShapeProto.Dimension dim = 1;
1542   int dim_size() const;
1543   private:
1544   int _internal_dim_size() const;
1545
1546   public:
1547   void clear_dim() ;
1548   ::onnx::TensorShapeProto_Dimension* mutable_dim(int index);
1549   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* mutable_dim();
1550
1551   private:
1552   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& _internal_dim() const;
1553   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* _internal_mutable_dim();
1554   public:
1555   const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
1556   ::onnx::TensorShapeProto_Dimension* add_dim();
1557   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& dim() const;
1558   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
1559  private:
1560   class _Internal;
1561   friend class ::google::protobuf::internal::TcParser;
1562   static const ::google::protobuf::internal::TcParseTable<
1563       0, 1, 1,
1564       0, 2>
1565       _table_;
1566
1567
1568   friend class ::google::protobuf::MessageLite;
1569   friend class ::google::protobuf::Arena;
1570   template <typename T>
1571   friend class ::google::protobuf::Arena::InternalHelper;
1572   using InternalArenaConstructable_ = void;
1573   using DestructorSkippable_ = void;
1574   struct Impl_ {
1575     inline explicit constexpr Impl_(
1576         ::google::protobuf::internal::ConstantInitialized) noexcept;
1577     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1578                           ::google::protobuf::Arena* arena);
1579     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1580                           ::google::protobuf::Arena* arena, const Impl_& from,
1581                           const TensorShapeProto& from_msg);
1582     ::google::protobuf::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
1583     mutable ::google::protobuf::internal::CachedSize _cached_size_;
1584     PROTOBUF_TSAN_DECLARE_MEMBER
1585   };
1586   union { Impl_ _impl_; };
1587   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1588 };
1589 // -------------------------------------------------------------------
1590
1591 class ONNX_API TensorProto final : public ::google::protobuf::Message
1592 /* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
1593  public:
1594   inline TensorProto() : TensorProto(nullptr) {}
1595   ~TensorProto() PROTOBUF_FINAL;
1596   template <typename = void>
1597   explicit PROTOBUF_CONSTEXPR TensorProto(
1598       ::google::protobuf::internal::ConstantInitialized);
1599
1600   inline TensorProto(const TensorProto& from) : TensorProto(nullptr, from) {}
1601   inline TensorProto(TensorProto&& from) noexcept
1602       : TensorProto(nullptr, std::move(from)) {}
1603   inline TensorProto& operator=(const TensorProto& from) {
1604     CopyFrom(from);
1605     return *this;
1606   }
1607   inline TensorProto& operator=(TensorProto&& from) noexcept {
1608     if (this == &from) return *this;
1609     if (GetArena() == from.GetArena()
1610 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1611         && GetArena() != nullptr
1612 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1613     ) {
1614       InternalSwap(&from);
1615     } else {
1616       CopyFrom(from);
1617     }
1618     return *this;
1619   }
1620
1621   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1622       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1623     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1624   }
1625   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
1626       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1627     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1628   }
1629
1630   static const ::google::protobuf::Descriptor* descriptor() {
1631     return GetDescriptor();
1632   }
1633   static const ::google::protobuf::Descriptor* GetDescriptor() {
1634     return default_instance().GetMetadata().descriptor;
1635   }
1636   static const ::google::protobuf::Reflection* GetReflection() {
1637     return default_instance().GetMetadata().reflection;
1638   }
1639   static const TensorProto& default_instance() {
1640     return *internal_default_instance();
1641   }
1642   static inline const TensorProto* internal_default_instance() {
1643     return reinterpret_cast<const TensorProto*>(
1644         &_TensorProto_default_instance_);
1645   }
1646   static constexpr int kIndexInFileMessages = 9;
1647   friend void swap(TensorProto& a, TensorProto& b) { a.Swap(&b); }
1648   inline void Swap(TensorProto* other) {
1649     if (other == this) return;
1650 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1651     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
1652 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
1653     if (GetArena() == other->GetArena()) {
1654 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1655       InternalSwap(other);
1656     } else {
1657       ::google::protobuf::internal::GenericSwap(this, other);
1658     }
1659   }
1660   void UnsafeArenaSwap(TensorProto* other) {
1661     if (other == this) return;
1662     ABSL_DCHECK(GetArena() == other->GetArena());
1663     InternalSwap(other);
1664   }
1665
1666   // implements Message ----------------------------------------------
1667
1668   TensorProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
1669     return ::google::protobuf::Message::DefaultConstruct<TensorProto>(arena);
1670   }
1671   using ::google::protobuf::Message::CopyFrom;
1672   void CopyFrom(const TensorProto& from);
1673   using ::google::protobuf::Message::MergeFrom;
1674   void MergeFrom(const TensorProto& from) { TensorProto::MergeImpl(*this, from); }
1675
1676   private:
1677   static void MergeImpl(
1678       ::google::protobuf::MessageLite& to_msg,
1679       const ::google::protobuf::MessageLite& from_msg);
1680
1681   public:
1682   bool IsInitialized() const {
1683     return true;
1684   }
1685   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1686   #if defined(PROTOBUF_CUSTOM_VTABLE)
1687   private:
1688   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1689   static ::uint8_t* _InternalSerialize(
1690       const MessageLite& msg, ::uint8_t* target,
1691       ::google::protobuf::io::EpsCopyOutputStream* stream);
1692
1693   public:
1694   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1695   ::uint8_t* _InternalSerialize(
1696       ::uint8_t* target,
1697       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
1698     return _InternalSerialize(*this, target, stream);
1699   }
1700   #else   // PROTOBUF_CUSTOM_VTABLE
1701   ::size_t ByteSizeLong() const final;
1702   ::uint8_t* _InternalSerialize(
1703       ::uint8_t* target,
1704       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
1705   #endif  // PROTOBUF_CUSTOM_VTABLE
1706   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1707
1708   private:
1709   void SharedCtor(::google::protobuf::Arena* arena);
1710   void SharedDtor();
1711   void InternalSwap(TensorProto* other);
1712  private:
1713   friend class ::google::protobuf::internal::AnyMetadata;
1714   static ::absl::string_view FullMessageName() { return "onnx.TensorProto"; }
1715
1716  protected:
1717   explicit TensorProto(::google::protobuf::Arena* arena);
1718   TensorProto(::google::protobuf::Arena* arena, const TensorProto& from);
1719   TensorProto(::google::protobuf::Arena* arena, TensorProto&& from) noexcept
1720       : TensorProto(arena) {
1721     *this = ::std::move(from);
1722   }
1723   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
1724   static const ::google::protobuf::Message::ClassDataFull _class_data_;
1725
1726  public:
1727   ::google::protobuf::Metadata GetMetadata() const;
1728   // nested types ----------------------------------------------------
1729   using Segment = TensorProto_Segment;
1730   using DataType = TensorProto_DataType;
1731   static constexpr DataType UNDEFINED = TensorProto_DataType_UNDEFINED;
1732   static constexpr DataType FLOAT = TensorProto_DataType_FLOAT;
1733   static constexpr DataType UINT8 = TensorProto_DataType_UINT8;
1734   static constexpr DataType INT8 = TensorProto_DataType_INT8;
1735   static constexpr DataType UINT16 = TensorProto_DataType_UINT16;
1736   static constexpr DataType INT16 = TensorProto_DataType_INT16;
1737   static constexpr DataType INT32 = TensorProto_DataType_INT32;
1738   static constexpr DataType INT64 = TensorProto_DataType_INT64;
1739   static constexpr DataType STRING = TensorProto_DataType_STRING;
1740   static constexpr DataType BOOL = TensorProto_DataType_BOOL;
1741   static constexpr DataType FLOAT16 = TensorProto_DataType_FLOAT16;
1742   static constexpr DataType DOUBLE = TensorProto_DataType_DOUBLE;
1743   static constexpr DataType UINT32 = TensorProto_DataType_UINT32;
1744   static constexpr DataType UINT64 = TensorProto_DataType_UINT64;
1745   static constexpr DataType COMPLEX64 = TensorProto_DataType_COMPLEX64;
1746   static constexpr DataType COMPLEX128 = TensorProto_DataType_COMPLEX128;
1747   static constexpr DataType BFLOAT16 = TensorProto_DataType_BFLOAT16;
1748   static constexpr DataType FLOAT8E4M3FN = TensorProto_DataType_FLOAT8E4M3FN;
1749   static constexpr DataType FLOAT8E4M3FNUZ = TensorProto_DataType_FLOAT8E4M3FNUZ;
1750   static constexpr DataType FLOAT8E5M2 = TensorProto_DataType_FLOAT8E5M2;
1751   static constexpr DataType FLOAT8E5M2FNUZ = TensorProto_DataType_FLOAT8E5M2FNUZ;
1752   static constexpr DataType UINT4 = TensorProto_DataType_UINT4;
1753   static constexpr DataType INT4 = TensorProto_DataType_INT4;
1754   static inline bool DataType_IsValid(int value) {
1755     return TensorProto_DataType_IsValid(value);
1756   }
1757   static constexpr DataType DataType_MIN = TensorProto_DataType_DataType_MIN;
1758   static constexpr DataType DataType_MAX = TensorProto_DataType_DataType_MAX;
1759   static constexpr int DataType_ARRAYSIZE = TensorProto_DataType_DataType_ARRAYSIZE;
1760   static inline const ::google::protobuf::EnumDescriptor* DataType_descriptor() {
1761     return TensorProto_DataType_descriptor();
1762   }
1763   template <typename T>
1764   static inline const std::string& DataType_Name(T value) {
1765     return TensorProto_DataType_Name(value);
1766   }
1767   static inline bool DataType_Parse(absl::string_view name, DataType* value) {
1768     return TensorProto_DataType_Parse(name, value);
1769   }
1770   using DataLocation = TensorProto_DataLocation;
1771   static constexpr DataLocation DEFAULT = TensorProto_DataLocation_DEFAULT;
1772   static constexpr DataLocation EXTERNAL = TensorProto_DataLocation_EXTERNAL;
1773   static inline bool DataLocation_IsValid(int value) {
1774     return TensorProto_DataLocation_IsValid(value);
1775   }
1776   static constexpr DataLocation DataLocation_MIN = TensorProto_DataLocation_DataLocation_MIN;
1777   static constexpr DataLocation DataLocation_MAX = TensorProto_DataLocation_DataLocation_MAX;
1778   static constexpr int DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_ARRAYSIZE;
1779   static inline const ::google::protobuf::EnumDescriptor* DataLocation_descriptor() {
1780     return TensorProto_DataLocation_descriptor();
1781   }
1782   template <typename T>
1783   static inline const std::string& DataLocation_Name(T value) {
1784     return TensorProto_DataLocation_Name(value);
1785   }
1786   static inline bool DataLocation_Parse(absl::string_view name, DataLocation* value) {
1787     return TensorProto_DataLocation_Parse(name, value);
1788   }
1789
1790   // accessors -------------------------------------------------------
1791   enum : int {
1792     kDimsFieldNumber = 1,
1793     kFloatDataFieldNumber = 4,
1794     kInt32DataFieldNumber = 5,
1795     kStringDataFieldNumber = 6,
1796     kInt64DataFieldNumber = 7,
1797     kDoubleDataFieldNumber = 10,
1798     kUint64DataFieldNumber = 11,
1799     kExternalDataFieldNumber = 13,
1800     kMetadataPropsFieldNumber = 16,
1801     kNameFieldNumber = 8,
1802     kRawDataFieldNumber = 9,
1803     kDocStringFieldNumber = 12,
1804     kSegmentFieldNumber = 3,
1805     kDataTypeFieldNumber = 2,
1806     kDataLocationFieldNumber = 14,
1807   };
1808   // repeated int64 dims = 1;
1809   int dims_size() const;
1810   private:
1811   int _internal_dims_size() const;
1812
1813   public:
1814   void clear_dims() ;
1815   ::int64_t dims(int index) const;
1816   void set_dims(int index, ::int64_t value);
1817   void add_dims(::int64_t value);
1818   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
1819   ::google::protobuf::RepeatedField<::int64_t>* mutable_dims();
1820
1821   private:
1822   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
1823   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_dims();
1824
1825   public:
1826   // repeated float float_data = 4 [packed = true];
1827   int float_data_size() const;
1828   private:
1829   int _internal_float_data_size() const;
1830
1831   public:
1832   void clear_float_data() ;
1833   float float_data(int index) const;
1834   void set_float_data(int index, float value);
1835   void add_float_data(float value);
1836   const ::google::protobuf::RepeatedField<float>& float_data() const;
1837   ::google::protobuf::RepeatedField<float>* mutable_float_data();
1838
1839   private:
1840   const ::google::protobuf::RepeatedField<float>& _internal_float_data() const;
1841   ::google::protobuf::RepeatedField<float>* _internal_mutable_float_data();
1842
1843   public:
1844   // repeated int32 int32_data = 5 [packed = true];
1845   int int32_data_size() const;
1846   private:
1847   int _internal_int32_data_size() const;
1848
1849   public:
1850   void clear_int32_data() ;
1851   ::int32_t int32_data(int index) const;
1852   void set_int32_data(int index, ::int32_t value);
1853   void add_int32_data(::int32_t value);
1854   const ::google::protobuf::RepeatedField<::int32_t>& int32_data() const;
1855   ::google::protobuf::RepeatedField<::int32_t>* mutable_int32_data();
1856
1857   private:
1858   const ::google::protobuf::RepeatedField<::int32_t>& _internal_int32_data() const;
1859   ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_int32_data();
1860
1861   public:
1862   // repeated bytes string_data = 6;
1863   int string_data_size() const;
1864   private:
1865   int _internal_string_data_size() const;
1866
1867   public:
1868   void clear_string_data() ;
1869   const std::string& string_data(int index) const;
1870   std::string* mutable_string_data(int index);
1871   template <typename Arg_ = const std::string&, typename... Args_>
1872   void set_string_data(int index, Arg_&& value, Args_... args);
1873   std::string* add_string_data();
1874   template <typename Arg_ = const std::string&, typename... Args_>
1875   void add_string_data(Arg_&& value, Args_... args);
1876   const ::google::protobuf::RepeatedPtrField<std::string>& string_data() const;
1877   ::google::protobuf::RepeatedPtrField<std::string>* mutable_string_data();
1878
1879   private:
1880   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_string_data() const;
1881   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_string_data();
1882
1883   public:
1884   // repeated int64 int64_data = 7 [packed = true];
1885   int int64_data_size() const;
1886   private:
1887   int _internal_int64_data_size() const;
1888
1889   public:
1890   void clear_int64_data() ;
1891   ::int64_t int64_data(int index) const;
1892   void set_int64_data(int index, ::int64_t value);
1893   void add_int64_data(::int64_t value);
1894   const ::google::protobuf::RepeatedField<::int64_t>& int64_data() const;
1895   ::google::protobuf::RepeatedField<::int64_t>* mutable_int64_data();
1896
1897   private:
1898   const ::google::protobuf::RepeatedField<::int64_t>& _internal_int64_data() const;
1899   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_int64_data();
1900
1901   public:
1902   // repeated double double_data = 10 [packed = true];
1903   int double_data_size() const;
1904   private:
1905   int _internal_double_data_size() const;
1906
1907   public:
1908   void clear_double_data() ;
1909   double double_data(int index) const;
1910   void set_double_data(int index, double value);
1911   void add_double_data(double value);
1912   const ::google::protobuf::RepeatedField<double>& double_data() const;
1913   ::google::protobuf::RepeatedField<double>* mutable_double_data();
1914
1915   private:
1916   const ::google::protobuf::RepeatedField<double>& _internal_double_data() const;
1917   ::google::protobuf::RepeatedField<double>* _internal_mutable_double_data();
1918
1919   public:
1920   // repeated uint64 uint64_data = 11 [packed = true];
1921   int uint64_data_size() const;
1922   private:
1923   int _internal_uint64_data_size() const;
1924
1925   public:
1926   void clear_uint64_data() ;
1927   ::uint64_t uint64_data(int index) const;
1928   void set_uint64_data(int index, ::uint64_t value);
1929   void add_uint64_data(::uint64_t value);
1930   const ::google::protobuf::RepeatedField<::uint64_t>& uint64_data() const;
1931   ::google::protobuf::RepeatedField<::uint64_t>* mutable_uint64_data();
1932
1933   private:
1934   const ::google::protobuf::RepeatedField<::uint64_t>& _internal_uint64_data() const;
1935   ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_uint64_data();
1936
1937   public:
1938   // repeated .onnx.StringStringEntryProto external_data = 13;
1939   int external_data_size() const;
1940   private:
1941   int _internal_external_data_size() const;
1942
1943   public:
1944   void clear_external_data() ;
1945   ::onnx::StringStringEntryProto* mutable_external_data(int index);
1946   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_external_data();
1947
1948   private:
1949   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_external_data() const;
1950   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_external_data();
1951   public:
1952   const ::onnx::StringStringEntryProto& external_data(int index) const;
1953   ::onnx::StringStringEntryProto* add_external_data();
1954   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& external_data() const;
1955   // repeated .onnx.StringStringEntryProto metadata_props = 16;
1956   int metadata_props_size() const;
1957   private:
1958   int _internal_metadata_props_size() const;
1959
1960   public:
1961   void clear_metadata_props() ;
1962   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
1963   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
1964
1965   private:
1966   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
1967   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
1968   public:
1969   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
1970   ::onnx::StringStringEntryProto* add_metadata_props();
1971   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
1972   // optional string name = 8;
1973   bool has_name() const;
1974   void clear_name() ;
1975   const std::string& name() const;
1976   template <typename Arg_ = const std::string&, typename... Args_>
1977   void set_name(Arg_&& arg, Args_... args);
1978   std::string* mutable_name();
1979   PROTOBUF_NODISCARD std::string* release_name();
1980   void set_allocated_name(std::string* value);
1981
1982   private:
1983   const std::string& _internal_name() const;
1984   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
1985       const std::string& value);
1986   std::string* _internal_mutable_name();
1987
1988   public:
1989   // optional bytes raw_data = 9;
1990   bool has_raw_data() const;
1991   void clear_raw_data() ;
1992   const std::string& raw_data() const;
1993   template <typename Arg_ = const std::string&, typename... Args_>
1994   void set_raw_data(Arg_&& arg, Args_... args);
1995   std::string* mutable_raw_data();
1996   PROTOBUF_NODISCARD std::string* release_raw_data();
1997   void set_allocated_raw_data(std::string* value);
1998
1999   private:
2000   const std::string& _internal_raw_data() const;
2001   inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(
2002       const std::string& value);
2003   std::string* _internal_mutable_raw_data();
2004
2005   public:
2006   // optional string doc_string = 12;
2007   bool has_doc_string() const;
2008   void clear_doc_string() ;
2009   const std::string& doc_string() const;
2010   template <typename Arg_ = const std::string&, typename... Args_>
2011   void set_doc_string(Arg_&& arg, Args_... args);
2012   std::string* mutable_doc_string();
2013   PROTOBUF_NODISCARD std::string* release_doc_string();
2014   void set_allocated_doc_string(std::string* value);
2015
2016   private:
2017   const std::string& _internal_doc_string() const;
2018   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
2019       const std::string& value);
2020   std::string* _internal_mutable_doc_string();
2021
2022   public:
2023   // optional .onnx.TensorProto.Segment segment = 3;
2024   bool has_segment() const;
2025   void clear_segment() ;
2026   const ::onnx::TensorProto_Segment& segment() const;
2027   PROTOBUF_NODISCARD ::onnx::TensorProto_Segment* release_segment();
2028   ::onnx::TensorProto_Segment* mutable_segment();
2029   void set_allocated_segment(::onnx::TensorProto_Segment* value);
2030   void unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* value);
2031   ::onnx::TensorProto_Segment* unsafe_arena_release_segment();
2032
2033   private:
2034   const ::onnx::TensorProto_Segment& _internal_segment() const;
2035   ::onnx::TensorProto_Segment* _internal_mutable_segment();
2036
2037   public:
2038   // optional int32 data_type = 2;
2039   bool has_data_type() const;
2040   void clear_data_type() ;
2041   ::int32_t data_type() const;
2042   void set_data_type(::int32_t value);
2043
2044   private:
2045   ::int32_t _internal_data_type() const;
2046   void _internal_set_data_type(::int32_t value);
2047
2048   public:
2049   // optional .onnx.TensorProto.DataLocation data_location = 14;
2050   bool has_data_location() const;
2051   void clear_data_location() ;
2052   ::onnx::TensorProto_DataLocation data_location() const;
2053   void set_data_location(::onnx::TensorProto_DataLocation value);
2054
2055   private:
2056   ::onnx::TensorProto_DataLocation _internal_data_location() const;
2057   void _internal_set_data_location(::onnx::TensorProto_DataLocation value);
2058
2059   public:
2060   // @@protoc_insertion_point(class_scope:onnx.TensorProto)
2061  private:
2062   class _Internal;
2063   friend class ::google::protobuf::internal::TcParser;
2064   static const ::google::protobuf::internal::TcParseTable<
2065       4, 15, 4,
2066       47, 2>
2067       _table_;
2068
2069
2070   friend class ::google::protobuf::MessageLite;
2071   friend class ::google::protobuf::Arena;
2072   template <typename T>
2073   friend class ::google::protobuf::Arena::InternalHelper;
2074   using InternalArenaConstructable_ = void;
2075   using DestructorSkippable_ = void;
2076   struct Impl_ {
2077     inline explicit constexpr Impl_(
2078         ::google::protobuf::internal::ConstantInitialized) noexcept;
2079     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2080                           ::google::protobuf::Arena* arena);
2081     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2082                           ::google::protobuf::Arena* arena, const Impl_& from,
2083                           const TensorProto& from_msg);
2084     ::google::protobuf::internal::HasBits<1> _has_bits_;
2085     mutable ::google::protobuf::internal::CachedSize _cached_size_;
2086     ::google::protobuf::RepeatedField<::int64_t> dims_;
2087     ::google::protobuf::RepeatedField<float> float_data_;
2088     ::google::protobuf::RepeatedField<::int32_t> int32_data_;
2089     mutable ::google::protobuf::internal::CachedSize _int32_data_cached_byte_size_;
2090     ::google::protobuf::RepeatedPtrField<std::string> string_data_;
2091     ::google::protobuf::RepeatedField<::int64_t> int64_data_;
2092     mutable ::google::protobuf::internal::CachedSize _int64_data_cached_byte_size_;
2093     ::google::protobuf::RepeatedField<double> double_data_;
2094     ::google::protobuf::RepeatedField<::uint64_t> uint64_data_;
2095     mutable ::google::protobuf::internal::CachedSize _uint64_data_cached_byte_size_;
2096     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
2097     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
2098     ::google::protobuf::internal::ArenaStringPtr name_;
2099     ::google::protobuf::internal::ArenaStringPtr raw_data_;
2100     ::google::protobuf::internal::ArenaStringPtr doc_string_;
2101     ::onnx::TensorProto_Segment* segment_;
2102     ::int32_t data_type_;
2103     int data_location_;
2104     PROTOBUF_TSAN_DECLARE_MEMBER
2105   };
2106   union { Impl_ _impl_; };
2107   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2108 };
2109 // -------------------------------------------------------------------
2110
2111 class ONNX_API TensorAnnotation final : public ::google::protobuf::Message
2112 /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
2113  public:
2114   inline TensorAnnotation() : TensorAnnotation(nullptr) {}
2115   ~TensorAnnotation() PROTOBUF_FINAL;
2116   template <typename = void>
2117   explicit PROTOBUF_CONSTEXPR TensorAnnotation(
2118       ::google::protobuf::internal::ConstantInitialized);
2119
2120   inline TensorAnnotation(const TensorAnnotation& from) : TensorAnnotation(nullptr, from) {}
2121   inline TensorAnnotation(TensorAnnotation&& from) noexcept
2122       : TensorAnnotation(nullptr, std::move(from)) {}
2123   inline TensorAnnotation& operator=(const TensorAnnotation& from) {
2124     CopyFrom(from);
2125     return *this;
2126   }
2127   inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
2128     if (this == &from) return *this;
2129     if (GetArena() == from.GetArena()
2130 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2131         && GetArena() != nullptr
2132 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2133     ) {
2134       InternalSwap(&from);
2135     } else {
2136       CopyFrom(from);
2137     }
2138     return *this;
2139   }
2140
2141   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2142       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2143     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2144   }
2145   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
2146       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2147     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2148   }
2149
2150   static const ::google::protobuf::Descriptor* descriptor() {
2151     return GetDescriptor();
2152   }
2153   static const ::google::protobuf::Descriptor* GetDescriptor() {
2154     return default_instance().GetMetadata().descriptor;
2155   }
2156   static const ::google::protobuf::Reflection* GetReflection() {
2157     return default_instance().GetMetadata().reflection;
2158   }
2159   static const TensorAnnotation& default_instance() {
2160     return *internal_default_instance();
2161   }
2162   static inline const TensorAnnotation* internal_default_instance() {
2163     return reinterpret_cast<const TensorAnnotation*>(
2164         &_TensorAnnotation_default_instance_);
2165   }
2166   static constexpr int kIndexInFileMessages = 6;
2167   friend void swap(TensorAnnotation& a, TensorAnnotation& b) { a.Swap(&b); }
2168   inline void Swap(TensorAnnotation* other) {
2169     if (other == this) return;
2170 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2171     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
2172 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
2173     if (GetArena() == other->GetArena()) {
2174 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2175       InternalSwap(other);
2176     } else {
2177       ::google::protobuf::internal::GenericSwap(this, other);
2178     }
2179   }
2180   void UnsafeArenaSwap(TensorAnnotation* other) {
2181     if (other == this) return;
2182     ABSL_DCHECK(GetArena() == other->GetArena());
2183     InternalSwap(other);
2184   }
2185
2186   // implements Message ----------------------------------------------
2187
2188   TensorAnnotation* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
2189     return ::google::protobuf::Message::DefaultConstruct<TensorAnnotation>(arena);
2190   }
2191   using ::google::protobuf::Message::CopyFrom;
2192   void CopyFrom(const TensorAnnotation& from);
2193   using ::google::protobuf::Message::MergeFrom;
2194   void MergeFrom(const TensorAnnotation& from) { TensorAnnotation::MergeImpl(*this, from); }
2195
2196   private:
2197   static void MergeImpl(
2198       ::google::protobuf::MessageLite& to_msg,
2199       const ::google::protobuf::MessageLite& from_msg);
2200
2201   public:
2202   bool IsInitialized() const {
2203     return true;
2204   }
2205   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2206   #if defined(PROTOBUF_CUSTOM_VTABLE)
2207   private:
2208   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2209   static ::uint8_t* _InternalSerialize(
2210       const MessageLite& msg, ::uint8_t* target,
2211       ::google::protobuf::io::EpsCopyOutputStream* stream);
2212
2213   public:
2214   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2215   ::uint8_t* _InternalSerialize(
2216       ::uint8_t* target,
2217       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
2218     return _InternalSerialize(*this, target, stream);
2219   }
2220   #else   // PROTOBUF_CUSTOM_VTABLE
2221   ::size_t ByteSizeLong() const final;
2222   ::uint8_t* _InternalSerialize(
2223       ::uint8_t* target,
2224       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
2225   #endif  // PROTOBUF_CUSTOM_VTABLE
2226   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2227
2228   private:
2229   void SharedCtor(::google::protobuf::Arena* arena);
2230   void SharedDtor();
2231   void InternalSwap(TensorAnnotation* other);
2232  private:
2233   friend class ::google::protobuf::internal::AnyMetadata;
2234   static ::absl::string_view FullMessageName() { return "onnx.TensorAnnotation"; }
2235
2236  protected:
2237   explicit TensorAnnotation(::google::protobuf::Arena* arena);
2238   TensorAnnotation(::google::protobuf::Arena* arena, const TensorAnnotation& from);
2239   TensorAnnotation(::google::protobuf::Arena* arena, TensorAnnotation&& from) noexcept
2240       : TensorAnnotation(arena) {
2241     *this = ::std::move(from);
2242   }
2243   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
2244   static const ::google::protobuf::Message::ClassDataFull _class_data_;
2245
2246  public:
2247   ::google::protobuf::Metadata GetMetadata() const;
2248   // nested types ----------------------------------------------------
2249
2250   // accessors -------------------------------------------------------
2251   enum : int {
2252     kQuantParameterTensorNamesFieldNumber = 2,
2253     kTensorNameFieldNumber = 1,
2254   };
2255   // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
2256   int quant_parameter_tensor_names_size() const;
2257   private:
2258   int _internal_quant_parameter_tensor_names_size() const;
2259
2260   public:
2261   void clear_quant_parameter_tensor_names() ;
2262   ::onnx::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
2263   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_quant_parameter_tensor_names();
2264
2265   private:
2266   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_quant_parameter_tensor_names() const;
2267   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_quant_parameter_tensor_names();
2268   public:
2269   const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
2270   ::onnx::StringStringEntryProto* add_quant_parameter_tensor_names();
2271   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& quant_parameter_tensor_names() const;
2272   // optional string tensor_name = 1;
2273   bool has_tensor_name() const;
2274   void clear_tensor_name() ;
2275   const std::string& tensor_name() const;
2276   template <typename Arg_ = const std::string&, typename... Args_>
2277   void set_tensor_name(Arg_&& arg, Args_... args);
2278   std::string* mutable_tensor_name();
2279   PROTOBUF_NODISCARD std::string* release_tensor_name();
2280   void set_allocated_tensor_name(std::string* value);
2281
2282   private:
2283   const std::string& _internal_tensor_name() const;
2284   inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(
2285       const std::string& value);
2286   std::string* _internal_mutable_tensor_name();
2287
2288   public:
2289   // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation)
2290  private:
2291   class _Internal;
2292   friend class ::google::protobuf::internal::TcParser;
2293   static const ::google::protobuf::internal::TcParseTable<
2294       1, 2, 1,
2295       41, 2>
2296       _table_;
2297
2298
2299   friend class ::google::protobuf::MessageLite;
2300   friend class ::google::protobuf::Arena;
2301   template <typename T>
2302   friend class ::google::protobuf::Arena::InternalHelper;
2303   using InternalArenaConstructable_ = void;
2304   using DestructorSkippable_ = void;
2305   struct Impl_ {
2306     inline explicit constexpr Impl_(
2307         ::google::protobuf::internal::ConstantInitialized) noexcept;
2308     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2309                           ::google::protobuf::Arena* arena);
2310     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2311                           ::google::protobuf::Arena* arena, const Impl_& from,
2312                           const TensorAnnotation& from_msg);
2313     ::google::protobuf::internal::HasBits<1> _has_bits_;
2314     mutable ::google::protobuf::internal::CachedSize _cached_size_;
2315     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
2316     ::google::protobuf::internal::ArenaStringPtr tensor_name_;
2317     PROTOBUF_TSAN_DECLARE_MEMBER
2318   };
2319   union { Impl_ _impl_; };
2320   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2321 };
2322 // -------------------------------------------------------------------
2323
2324 class ONNX_API TypeProto_Tensor final : public ::google::protobuf::Message
2325 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
2326  public:
2327   inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
2328   ~TypeProto_Tensor() PROTOBUF_FINAL;
2329   template <typename = void>
2330   explicit PROTOBUF_CONSTEXPR TypeProto_Tensor(
2331       ::google::protobuf::internal::ConstantInitialized);
2332
2333   inline TypeProto_Tensor(const TypeProto_Tensor& from) : TypeProto_Tensor(nullptr, from) {}
2334   inline TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
2335       : TypeProto_Tensor(nullptr, std::move(from)) {}
2336   inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
2337     CopyFrom(from);
2338     return *this;
2339   }
2340   inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
2341     if (this == &from) return *this;
2342     if (GetArena() == from.GetArena()
2343 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2344         && GetArena() != nullptr
2345 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2346     ) {
2347       InternalSwap(&from);
2348     } else {
2349       CopyFrom(from);
2350     }
2351     return *this;
2352   }
2353
2354   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2355       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2356     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2357   }
2358   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
2359       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2360     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2361   }
2362
2363   static const ::google::protobuf::Descriptor* descriptor() {
2364     return GetDescriptor();
2365   }
2366   static const ::google::protobuf::Descriptor* GetDescriptor() {
2367     return default_instance().GetMetadata().descriptor;
2368   }
2369   static const ::google::protobuf::Reflection* GetReflection() {
2370     return default_instance().GetMetadata().reflection;
2371   }
2372   static const TypeProto_Tensor& default_instance() {
2373     return *internal_default_instance();
2374   }
2375   static inline const TypeProto_Tensor* internal_default_instance() {
2376     return reinterpret_cast<const TypeProto_Tensor*>(
2377         &_TypeProto_Tensor_default_instance_);
2378   }
2379   static constexpr int kIndexInFileMessages = 13;
2380   friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) { a.Swap(&b); }
2381   inline void Swap(TypeProto_Tensor* other) {
2382     if (other == this) return;
2383 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2384     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
2385 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
2386     if (GetArena() == other->GetArena()) {
2387 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2388       InternalSwap(other);
2389     } else {
2390       ::google::protobuf::internal::GenericSwap(this, other);
2391     }
2392   }
2393   void UnsafeArenaSwap(TypeProto_Tensor* other) {
2394     if (other == this) return;
2395     ABSL_DCHECK(GetArena() == other->GetArena());
2396     InternalSwap(other);
2397   }
2398
2399   // implements Message ----------------------------------------------
2400
2401   TypeProto_Tensor* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
2402     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Tensor>(arena);
2403   }
2404   using ::google::protobuf::Message::CopyFrom;
2405   void CopyFrom(const TypeProto_Tensor& from);
2406   using ::google::protobuf::Message::MergeFrom;
2407   void MergeFrom(const TypeProto_Tensor& from) { TypeProto_Tensor::MergeImpl(*this, from); }
2408
2409   private:
2410   static void MergeImpl(
2411       ::google::protobuf::MessageLite& to_msg,
2412       const ::google::protobuf::MessageLite& from_msg);
2413
2414   public:
2415   bool IsInitialized() const {
2416     return true;
2417   }
2418   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2419   #if defined(PROTOBUF_CUSTOM_VTABLE)
2420   private:
2421   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2422   static ::uint8_t* _InternalSerialize(
2423       const MessageLite& msg, ::uint8_t* target,
2424       ::google::protobuf::io::EpsCopyOutputStream* stream);
2425
2426   public:
2427   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2428   ::uint8_t* _InternalSerialize(
2429       ::uint8_t* target,
2430       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
2431     return _InternalSerialize(*this, target, stream);
2432   }
2433   #else   // PROTOBUF_CUSTOM_VTABLE
2434   ::size_t ByteSizeLong() const final;
2435   ::uint8_t* _InternalSerialize(
2436       ::uint8_t* target,
2437       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
2438   #endif  // PROTOBUF_CUSTOM_VTABLE
2439   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2440
2441   private:
2442   void SharedCtor(::google::protobuf::Arena* arena);
2443   void SharedDtor();
2444   void InternalSwap(TypeProto_Tensor* other);
2445  private:
2446   friend class ::google::protobuf::internal::AnyMetadata;
2447   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Tensor"; }
2448
2449  protected:
2450   explicit TypeProto_Tensor(::google::protobuf::Arena* arena);
2451   TypeProto_Tensor(::google::protobuf::Arena* arena, const TypeProto_Tensor& from);
2452   TypeProto_Tensor(::google::protobuf::Arena* arena, TypeProto_Tensor&& from) noexcept
2453       : TypeProto_Tensor(arena) {
2454     *this = ::std::move(from);
2455   }
2456   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
2457   static const ::google::protobuf::Message::ClassDataFull _class_data_;
2458
2459  public:
2460   ::google::protobuf::Metadata GetMetadata() const;
2461   // nested types ----------------------------------------------------
2462
2463   // accessors -------------------------------------------------------
2464   enum : int {
2465     kShapeFieldNumber = 2,
2466     kElemTypeFieldNumber = 1,
2467   };
2468   // optional .onnx.TensorShapeProto shape = 2;
2469   bool has_shape() const;
2470   void clear_shape() ;
2471   const ::onnx::TensorShapeProto& shape() const;
2472   PROTOBUF_NODISCARD ::onnx::TensorShapeProto* release_shape();
2473   ::onnx::TensorShapeProto* mutable_shape();
2474   void set_allocated_shape(::onnx::TensorShapeProto* value);
2475   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value);
2476   ::onnx::TensorShapeProto* unsafe_arena_release_shape();
2477
2478   private:
2479   const ::onnx::TensorShapeProto& _internal_shape() const;
2480   ::onnx::TensorShapeProto* _internal_mutable_shape();
2481
2482   public:
2483   // optional int32 elem_type = 1;
2484   bool has_elem_type() const;
2485   void clear_elem_type() ;
2486   ::int32_t elem_type() const;
2487   void set_elem_type(::int32_t value);
2488
2489   private:
2490   ::int32_t _internal_elem_type() const;
2491   void _internal_set_elem_type(::int32_t value);
2492
2493   public:
2494   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor)
2495  private:
2496   class _Internal;
2497   friend class ::google::protobuf::internal::TcParser;
2498   static const ::google::protobuf::internal::TcParseTable<
2499       1, 2, 1,
2500       0, 2>
2501       _table_;
2502
2503
2504   friend class ::google::protobuf::MessageLite;
2505   friend class ::google::protobuf::Arena;
2506   template <typename T>
2507   friend class ::google::protobuf::Arena::InternalHelper;
2508   using InternalArenaConstructable_ = void;
2509   using DestructorSkippable_ = void;
2510   struct Impl_ {
2511     inline explicit constexpr Impl_(
2512         ::google::protobuf::internal::ConstantInitialized) noexcept;
2513     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2514                           ::google::protobuf::Arena* arena);
2515     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2516                           ::google::protobuf::Arena* arena, const Impl_& from,
2517                           const TypeProto_Tensor& from_msg);
2518     ::google::protobuf::internal::HasBits<1> _has_bits_;
2519     mutable ::google::protobuf::internal::CachedSize _cached_size_;
2520     ::onnx::TensorShapeProto* shape_;
2521     ::int32_t elem_type_;
2522     PROTOBUF_TSAN_DECLARE_MEMBER
2523   };
2524   union { Impl_ _impl_; };
2525   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2526 };
2527 // -------------------------------------------------------------------
2528
2529 class ONNX_API TypeProto_SparseTensor final : public ::google::protobuf::Message
2530 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
2531  public:
2532   inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {}
2533   ~TypeProto_SparseTensor() PROTOBUF_FINAL;
2534   template <typename = void>
2535   explicit PROTOBUF_CONSTEXPR TypeProto_SparseTensor(
2536       ::google::protobuf::internal::ConstantInitialized);
2537
2538   inline TypeProto_SparseTensor(const TypeProto_SparseTensor& from) : TypeProto_SparseTensor(nullptr, from) {}
2539   inline TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
2540       : TypeProto_SparseTensor(nullptr, std::move(from)) {}
2541   inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
2542     CopyFrom(from);
2543     return *this;
2544   }
2545   inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
2546     if (this == &from) return *this;
2547     if (GetArena() == from.GetArena()
2548 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2549         && GetArena() != nullptr
2550 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2551     ) {
2552       InternalSwap(&from);
2553     } else {
2554       CopyFrom(from);
2555     }
2556     return *this;
2557   }
2558
2559   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2560       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2561     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2562   }
2563   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
2564       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2565     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2566   }
2567
2568   static const ::google::protobuf::Descriptor* descriptor() {
2569     return GetDescriptor();
2570   }
2571   static const ::google::protobuf::Descriptor* GetDescriptor() {
2572     return default_instance().GetMetadata().descriptor;
2573   }
2574   static const ::google::protobuf::Reflection* GetReflection() {
2575     return default_instance().GetMetadata().reflection;
2576   }
2577   static const TypeProto_SparseTensor& default_instance() {
2578     return *internal_default_instance();
2579   }
2580   static inline const TypeProto_SparseTensor* internal_default_instance() {
2581     return reinterpret_cast<const TypeProto_SparseTensor*>(
2582         &_TypeProto_SparseTensor_default_instance_);
2583   }
2584   static constexpr int kIndexInFileMessages = 17;
2585   friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) { a.Swap(&b); }
2586   inline void Swap(TypeProto_SparseTensor* other) {
2587     if (other == this) return;
2588 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2589     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
2590 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
2591     if (GetArena() == other->GetArena()) {
2592 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2593       InternalSwap(other);
2594     } else {
2595       ::google::protobuf::internal::GenericSwap(this, other);
2596     }
2597   }
2598   void UnsafeArenaSwap(TypeProto_SparseTensor* other) {
2599     if (other == this) return;
2600     ABSL_DCHECK(GetArena() == other->GetArena());
2601     InternalSwap(other);
2602   }
2603
2604   // implements Message ----------------------------------------------
2605
2606   TypeProto_SparseTensor* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
2607     return ::google::protobuf::Message::DefaultConstruct<TypeProto_SparseTensor>(arena);
2608   }
2609   using ::google::protobuf::Message::CopyFrom;
2610   void CopyFrom(const TypeProto_SparseTensor& from);
2611   using ::google::protobuf::Message::MergeFrom;
2612   void MergeFrom(const TypeProto_SparseTensor& from) { TypeProto_SparseTensor::MergeImpl(*this, from); }
2613
2614   private:
2615   static void MergeImpl(
2616       ::google::protobuf::MessageLite& to_msg,
2617       const ::google::protobuf::MessageLite& from_msg);
2618
2619   public:
2620   bool IsInitialized() const {
2621     return true;
2622   }
2623   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2624   #if defined(PROTOBUF_CUSTOM_VTABLE)
2625   private:
2626   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2627   static ::uint8_t* _InternalSerialize(
2628       const MessageLite& msg, ::uint8_t* target,
2629       ::google::protobuf::io::EpsCopyOutputStream* stream);
2630
2631   public:
2632   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2633   ::uint8_t* _InternalSerialize(
2634       ::uint8_t* target,
2635       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
2636     return _InternalSerialize(*this, target, stream);
2637   }
2638   #else   // PROTOBUF_CUSTOM_VTABLE
2639   ::size_t ByteSizeLong() const final;
2640   ::uint8_t* _InternalSerialize(
2641       ::uint8_t* target,
2642       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
2643   #endif  // PROTOBUF_CUSTOM_VTABLE
2644   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2645
2646   private:
2647   void SharedCtor(::google::protobuf::Arena* arena);
2648   void SharedDtor();
2649   void InternalSwap(TypeProto_SparseTensor* other);
2650  private:
2651   friend class ::google::protobuf::internal::AnyMetadata;
2652   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.SparseTensor"; }
2653
2654  protected:
2655   explicit TypeProto_SparseTensor(::google::protobuf::Arena* arena);
2656   TypeProto_SparseTensor(::google::protobuf::Arena* arena, const TypeProto_SparseTensor& from);
2657   TypeProto_SparseTensor(::google::protobuf::Arena* arena, TypeProto_SparseTensor&& from) noexcept
2658       : TypeProto_SparseTensor(arena) {
2659     *this = ::std::move(from);
2660   }
2661   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
2662   static const ::google::protobuf::Message::ClassDataFull _class_data_;
2663
2664  public:
2665   ::google::protobuf::Metadata GetMetadata() const;
2666   // nested types ----------------------------------------------------
2667
2668   // accessors -------------------------------------------------------
2669   enum : int {
2670     kShapeFieldNumber = 2,
2671     kElemTypeFieldNumber = 1,
2672   };
2673   // optional .onnx.TensorShapeProto shape = 2;
2674   bool has_shape() const;
2675   void clear_shape() ;
2676   const ::onnx::TensorShapeProto& shape() const;
2677   PROTOBUF_NODISCARD ::onnx::TensorShapeProto* release_shape();
2678   ::onnx::TensorShapeProto* mutable_shape();
2679   void set_allocated_shape(::onnx::TensorShapeProto* value);
2680   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value);
2681   ::onnx::TensorShapeProto* unsafe_arena_release_shape();
2682
2683   private:
2684   const ::onnx::TensorShapeProto& _internal_shape() const;
2685   ::onnx::TensorShapeProto* _internal_mutable_shape();
2686
2687   public:
2688   // optional int32 elem_type = 1;
2689   bool has_elem_type() const;
2690   void clear_elem_type() ;
2691   ::int32_t elem_type() const;
2692   void set_elem_type(::int32_t value);
2693
2694   private:
2695   ::int32_t _internal_elem_type() const;
2696   void _internal_set_elem_type(::int32_t value);
2697
2698   public:
2699   // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor)
2700  private:
2701   class _Internal;
2702   friend class ::google::protobuf::internal::TcParser;
2703   static const ::google::protobuf::internal::TcParseTable<
2704       1, 2, 1,
2705       0, 2>
2706       _table_;
2707
2708
2709   friend class ::google::protobuf::MessageLite;
2710   friend class ::google::protobuf::Arena;
2711   template <typename T>
2712   friend class ::google::protobuf::Arena::InternalHelper;
2713   using InternalArenaConstructable_ = void;
2714   using DestructorSkippable_ = void;
2715   struct Impl_ {
2716     inline explicit constexpr Impl_(
2717         ::google::protobuf::internal::ConstantInitialized) noexcept;
2718     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2719                           ::google::protobuf::Arena* arena);
2720     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2721                           ::google::protobuf::Arena* arena, const Impl_& from,
2722                           const TypeProto_SparseTensor& from_msg);
2723     ::google::protobuf::internal::HasBits<1> _has_bits_;
2724     mutable ::google::protobuf::internal::CachedSize _cached_size_;
2725     ::onnx::TensorShapeProto* shape_;
2726     ::int32_t elem_type_;
2727     PROTOBUF_TSAN_DECLARE_MEMBER
2728   };
2729   union { Impl_ _impl_; };
2730   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2731 };
2732 // -------------------------------------------------------------------
2733
2734 class ONNX_API SparseTensorProto final : public ::google::protobuf::Message
2735 /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
2736  public:
2737   inline SparseTensorProto() : SparseTensorProto(nullptr) {}
2738   ~SparseTensorProto() PROTOBUF_FINAL;
2739   template <typename = void>
2740   explicit PROTOBUF_CONSTEXPR SparseTensorProto(
2741       ::google::protobuf::internal::ConstantInitialized);
2742
2743   inline SparseTensorProto(const SparseTensorProto& from) : SparseTensorProto(nullptr, from) {}
2744   inline SparseTensorProto(SparseTensorProto&& from) noexcept
2745       : SparseTensorProto(nullptr, std::move(from)) {}
2746   inline SparseTensorProto& operator=(const SparseTensorProto& from) {
2747     CopyFrom(from);
2748     return *this;
2749   }
2750   inline SparseTensorProto& operator=(SparseTensorProto&& from) noexcept {
2751     if (this == &from) return *this;
2752     if (GetArena() == from.GetArena()
2753 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2754         && GetArena() != nullptr
2755 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2756     ) {
2757       InternalSwap(&from);
2758     } else {
2759       CopyFrom(from);
2760     }
2761     return *this;
2762   }
2763
2764   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2765       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2766     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2767   }
2768   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
2769       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2770     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2771   }
2772
2773   static const ::google::protobuf::Descriptor* descriptor() {
2774     return GetDescriptor();
2775   }
2776   static const ::google::protobuf::Descriptor* GetDescriptor() {
2777     return default_instance().GetMetadata().descriptor;
2778   }
2779   static const ::google::protobuf::Reflection* GetReflection() {
2780     return default_instance().GetMetadata().reflection;
2781   }
2782   static const SparseTensorProto& default_instance() {
2783     return *internal_default_instance();
2784   }
2785   static inline const SparseTensorProto* internal_default_instance() {
2786     return reinterpret_cast<const SparseTensorProto*>(
2787         &_SparseTensorProto_default_instance_);
2788   }
2789   static constexpr int kIndexInFileMessages = 10;
2790   friend void swap(SparseTensorProto& a, SparseTensorProto& b) { a.Swap(&b); }
2791   inline void Swap(SparseTensorProto* other) {
2792     if (other == this) return;
2793 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2794     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
2795 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
2796     if (GetArena() == other->GetArena()) {
2797 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2798       InternalSwap(other);
2799     } else {
2800       ::google::protobuf::internal::GenericSwap(this, other);
2801     }
2802   }
2803   void UnsafeArenaSwap(SparseTensorProto* other) {
2804     if (other == this) return;
2805     ABSL_DCHECK(GetArena() == other->GetArena());
2806     InternalSwap(other);
2807   }
2808
2809   // implements Message ----------------------------------------------
2810
2811   SparseTensorProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
2812     return ::google::protobuf::Message::DefaultConstruct<SparseTensorProto>(arena);
2813   }
2814   using ::google::protobuf::Message::CopyFrom;
2815   void CopyFrom(const SparseTensorProto& from);
2816   using ::google::protobuf::Message::MergeFrom;
2817   void MergeFrom(const SparseTensorProto& from) { SparseTensorProto::MergeImpl(*this, from); }
2818
2819   private:
2820   static void MergeImpl(
2821       ::google::protobuf::MessageLite& to_msg,
2822       const ::google::protobuf::MessageLite& from_msg);
2823
2824   public:
2825   bool IsInitialized() const {
2826     return true;
2827   }
2828   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2829   #if defined(PROTOBUF_CUSTOM_VTABLE)
2830   private:
2831   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2832   static ::uint8_t* _InternalSerialize(
2833       const MessageLite& msg, ::uint8_t* target,
2834       ::google::protobuf::io::EpsCopyOutputStream* stream);
2835
2836   public:
2837   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2838   ::uint8_t* _InternalSerialize(
2839       ::uint8_t* target,
2840       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
2841     return _InternalSerialize(*this, target, stream);
2842   }
2843   #else   // PROTOBUF_CUSTOM_VTABLE
2844   ::size_t ByteSizeLong() const final;
2845   ::uint8_t* _InternalSerialize(
2846       ::uint8_t* target,
2847       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
2848   #endif  // PROTOBUF_CUSTOM_VTABLE
2849   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2850
2851   private:
2852   void SharedCtor(::google::protobuf::Arena* arena);
2853   void SharedDtor();
2854   void InternalSwap(SparseTensorProto* other);
2855  private:
2856   friend class ::google::protobuf::internal::AnyMetadata;
2857   static ::absl::string_view FullMessageName() { return "onnx.SparseTensorProto"; }
2858
2859  protected:
2860   explicit SparseTensorProto(::google::protobuf::Arena* arena);
2861   SparseTensorProto(::google::protobuf::Arena* arena, const SparseTensorProto& from);
2862   SparseTensorProto(::google::protobuf::Arena* arena, SparseTensorProto&& from) noexcept
2863       : SparseTensorProto(arena) {
2864     *this = ::std::move(from);
2865   }
2866   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
2867   static const ::google::protobuf::Message::ClassDataFull _class_data_;
2868
2869  public:
2870   ::google::protobuf::Metadata GetMetadata() const;
2871   // nested types ----------------------------------------------------
2872
2873   // accessors -------------------------------------------------------
2874   enum : int {
2875     kDimsFieldNumber = 3,
2876     kValuesFieldNumber = 1,
2877     kIndicesFieldNumber = 2,
2878   };
2879   // repeated int64 dims = 3;
2880   int dims_size() const;
2881   private:
2882   int _internal_dims_size() const;
2883
2884   public:
2885   void clear_dims() ;
2886   ::int64_t dims(int index) const;
2887   void set_dims(int index, ::int64_t value);
2888   void add_dims(::int64_t value);
2889   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
2890   ::google::protobuf::RepeatedField<::int64_t>* mutable_dims();
2891
2892   private:
2893   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
2894   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_dims();
2895
2896   public:
2897   // optional .onnx.TensorProto values = 1;
2898   bool has_values() const;
2899   void clear_values() ;
2900   const ::onnx::TensorProto& values() const;
2901   PROTOBUF_NODISCARD ::onnx::TensorProto* release_values();
2902   ::onnx::TensorProto* mutable_values();
2903   void set_allocated_values(::onnx::TensorProto* value);
2904   void unsafe_arena_set_allocated_values(::onnx::TensorProto* value);
2905   ::onnx::TensorProto* unsafe_arena_release_values();
2906
2907   private:
2908   const ::onnx::TensorProto& _internal_values() const;
2909   ::onnx::TensorProto* _internal_mutable_values();
2910
2911   public:
2912   // optional .onnx.TensorProto indices = 2;
2913   bool has_indices() const;
2914   void clear_indices() ;
2915   const ::onnx::TensorProto& indices() const;
2916   PROTOBUF_NODISCARD ::onnx::TensorProto* release_indices();
2917   ::onnx::TensorProto* mutable_indices();
2918   void set_allocated_indices(::onnx::TensorProto* value);
2919   void unsafe_arena_set_allocated_indices(::onnx::TensorProto* value);
2920   ::onnx::TensorProto* unsafe_arena_release_indices();
2921
2922   private:
2923   const ::onnx::TensorProto& _internal_indices() const;
2924   ::onnx::TensorProto* _internal_mutable_indices();
2925
2926   public:
2927   // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto)
2928  private:
2929   class _Internal;
2930   friend class ::google::protobuf::internal::TcParser;
2931   static const ::google::protobuf::internal::TcParseTable<
2932       2, 3, 2,
2933       0, 2>
2934       _table_;
2935
2936
2937   friend class ::google::protobuf::MessageLite;
2938   friend class ::google::protobuf::Arena;
2939   template <typename T>
2940   friend class ::google::protobuf::Arena::InternalHelper;
2941   using InternalArenaConstructable_ = void;
2942   using DestructorSkippable_ = void;
2943   struct Impl_ {
2944     inline explicit constexpr Impl_(
2945         ::google::protobuf::internal::ConstantInitialized) noexcept;
2946     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2947                           ::google::protobuf::Arena* arena);
2948     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
2949                           ::google::protobuf::Arena* arena, const Impl_& from,
2950                           const SparseTensorProto& from_msg);
2951     ::google::protobuf::internal::HasBits<1> _has_bits_;
2952     mutable ::google::protobuf::internal::CachedSize _cached_size_;
2953     ::google::protobuf::RepeatedField<::int64_t> dims_;
2954     ::onnx::TensorProto* values_;
2955     ::onnx::TensorProto* indices_;
2956     PROTOBUF_TSAN_DECLARE_MEMBER
2957   };
2958   union { Impl_ _impl_; };
2959   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2960 };
2961 // -------------------------------------------------------------------
2962
2963 class ONNX_API TypeProto final : public ::google::protobuf::Message
2964 /* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
2965  public:
2966   inline TypeProto() : TypeProto(nullptr) {}
2967   ~TypeProto() PROTOBUF_FINAL;
2968   template <typename = void>
2969   explicit PROTOBUF_CONSTEXPR TypeProto(
2970       ::google::protobuf::internal::ConstantInitialized);
2971
2972   inline TypeProto(const TypeProto& from) : TypeProto(nullptr, from) {}
2973   inline TypeProto(TypeProto&& from) noexcept
2974       : TypeProto(nullptr, std::move(from)) {}
2975   inline TypeProto& operator=(const TypeProto& from) {
2976     CopyFrom(from);
2977     return *this;
2978   }
2979   inline TypeProto& operator=(TypeProto&& from) noexcept {
2980     if (this == &from) return *this;
2981     if (GetArena() == from.GetArena()
2982 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2983         && GetArena() != nullptr
2984 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2985     ) {
2986       InternalSwap(&from);
2987     } else {
2988       CopyFrom(from);
2989     }
2990     return *this;
2991   }
2992
2993   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2994       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2995     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2996   }
2997   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
2998       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2999     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3000   }
3001
3002   static const ::google::protobuf::Descriptor* descriptor() {
3003     return GetDescriptor();
3004   }
3005   static const ::google::protobuf::Descriptor* GetDescriptor() {
3006     return default_instance().GetMetadata().descriptor;
3007   }
3008   static const ::google::protobuf::Reflection* GetReflection() {
3009     return default_instance().GetMetadata().reflection;
3010   }
3011   static const TypeProto& default_instance() {
3012     return *internal_default_instance();
3013   }
3014   enum ValueCase {
3015     kTensorType = 1,
3016     kSequenceType = 4,
3017     kMapType = 5,
3018     kOptionalType = 9,
3019     kSparseTensorType = 8,
3020     kOpaqueType = 7,
3021     VALUE_NOT_SET = 0,
3022   };
3023   static inline const TypeProto* internal_default_instance() {
3024     return reinterpret_cast<const TypeProto*>(
3025         &_TypeProto_default_instance_);
3026   }
3027   static constexpr int kIndexInFileMessages = 19;
3028   friend void swap(TypeProto& a, TypeProto& b) { a.Swap(&b); }
3029   inline void Swap(TypeProto* other) {
3030     if (other == this) return;
3031 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3032     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
3033 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
3034     if (GetArena() == other->GetArena()) {
3035 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3036       InternalSwap(other);
3037     } else {
3038       ::google::protobuf::internal::GenericSwap(this, other);
3039     }
3040   }
3041   void UnsafeArenaSwap(TypeProto* other) {
3042     if (other == this) return;
3043     ABSL_DCHECK(GetArena() == other->GetArena());
3044     InternalSwap(other);
3045   }
3046
3047   // implements Message ----------------------------------------------
3048
3049   TypeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
3050     return ::google::protobuf::Message::DefaultConstruct<TypeProto>(arena);
3051   }
3052   using ::google::protobuf::Message::CopyFrom;
3053   void CopyFrom(const TypeProto& from);
3054   using ::google::protobuf::Message::MergeFrom;
3055   void MergeFrom(const TypeProto& from) { TypeProto::MergeImpl(*this, from); }
3056
3057   private:
3058   static void MergeImpl(
3059       ::google::protobuf::MessageLite& to_msg,
3060       const ::google::protobuf::MessageLite& from_msg);
3061
3062   public:
3063   bool IsInitialized() const {
3064     return true;
3065   }
3066   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3067   #if defined(PROTOBUF_CUSTOM_VTABLE)
3068   private:
3069   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3070   static ::uint8_t* _InternalSerialize(
3071       const MessageLite& msg, ::uint8_t* target,
3072       ::google::protobuf::io::EpsCopyOutputStream* stream);
3073
3074   public:
3075   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3076   ::uint8_t* _InternalSerialize(
3077       ::uint8_t* target,
3078       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
3079     return _InternalSerialize(*this, target, stream);
3080   }
3081   #else   // PROTOBUF_CUSTOM_VTABLE
3082   ::size_t ByteSizeLong() const final;
3083   ::uint8_t* _InternalSerialize(
3084       ::uint8_t* target,
3085       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
3086   #endif  // PROTOBUF_CUSTOM_VTABLE
3087   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3088
3089   private:
3090   void SharedCtor(::google::protobuf::Arena* arena);
3091   void SharedDtor();
3092   void InternalSwap(TypeProto* other);
3093  private:
3094   friend class ::google::protobuf::internal::AnyMetadata;
3095   static ::absl::string_view FullMessageName() { return "onnx.TypeProto"; }
3096
3097  protected:
3098   explicit TypeProto(::google::protobuf::Arena* arena);
3099   TypeProto(::google::protobuf::Arena* arena, const TypeProto& from);
3100   TypeProto(::google::protobuf::Arena* arena, TypeProto&& from) noexcept
3101       : TypeProto(arena) {
3102     *this = ::std::move(from);
3103   }
3104   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
3105   static const ::google::protobuf::Message::ClassDataFull _class_data_;
3106
3107  public:
3108   ::google::protobuf::Metadata GetMetadata() const;
3109   // nested types ----------------------------------------------------
3110   using Tensor = TypeProto_Tensor;
3111   using Sequence = TypeProto_Sequence;
3112   using Map = TypeProto_Map;
3113   using Optional = TypeProto_Optional;
3114   using SparseTensor = TypeProto_SparseTensor;
3115   using Opaque = TypeProto_Opaque;
3116
3117   // accessors -------------------------------------------------------
3118   enum : int {
3119     kDenotationFieldNumber = 6,
3120     kTensorTypeFieldNumber = 1,
3121     kSequenceTypeFieldNumber = 4,
3122     kMapTypeFieldNumber = 5,
3123     kOptionalTypeFieldNumber = 9,
3124     kSparseTensorTypeFieldNumber = 8,
3125     kOpaqueTypeFieldNumber = 7,
3126   };
3127   // optional string denotation = 6;
3128   bool has_denotation() const;
3129   void clear_denotation() ;
3130   const std::string& denotation() const;
3131   template <typename Arg_ = const std::string&, typename... Args_>
3132   void set_denotation(Arg_&& arg, Args_... args);
3133   std::string* mutable_denotation();
3134   PROTOBUF_NODISCARD std::string* release_denotation();
3135   void set_allocated_denotation(std::string* value);
3136
3137   private:
3138   const std::string& _internal_denotation() const;
3139   inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(
3140       const std::string& value);
3141   std::string* _internal_mutable_denotation();
3142
3143   public:
3144   // .onnx.TypeProto.Tensor tensor_type = 1;
3145   bool has_tensor_type() const;
3146   private:
3147   bool _internal_has_tensor_type() const;
3148
3149   public:
3150   void clear_tensor_type() ;
3151   const ::onnx::TypeProto_Tensor& tensor_type() const;
3152   PROTOBUF_NODISCARD ::onnx::TypeProto_Tensor* release_tensor_type();
3153   ::onnx::TypeProto_Tensor* mutable_tensor_type();
3154   void set_allocated_tensor_type(::onnx::TypeProto_Tensor* value);
3155   void unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* value);
3156   ::onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
3157
3158   private:
3159   const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
3160   ::onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
3161
3162   public:
3163   // .onnx.TypeProto.Sequence sequence_type = 4;
3164   bool has_sequence_type() const;
3165   private:
3166   bool _internal_has_sequence_type() const;
3167
3168   public:
3169   void clear_sequence_type() ;
3170   const ::onnx::TypeProto_Sequence& sequence_type() const;
3171   PROTOBUF_NODISCARD ::onnx::TypeProto_Sequence* release_sequence_type();
3172   ::onnx::TypeProto_Sequence* mutable_sequence_type();
3173   void set_allocated_sequence_type(::onnx::TypeProto_Sequence* value);
3174   void unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* value);
3175   ::onnx::TypeProto_Sequence* unsafe_arena_release_sequence_type();
3176
3177   private:
3178   const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
3179   ::onnx::TypeProto_Sequence* _internal_mutable_sequence_type();
3180
3181   public:
3182   // .onnx.TypeProto.Map map_type = 5;
3183   bool has_map_type() const;
3184   private:
3185   bool _internal_has_map_type() const;
3186
3187   public:
3188   void clear_map_type() ;
3189   const ::onnx::TypeProto_Map& map_type() const;
3190   PROTOBUF_NODISCARD ::onnx::TypeProto_Map* release_map_type();
3191   ::onnx::TypeProto_Map* mutable_map_type();
3192   void set_allocated_map_type(::onnx::TypeProto_Map* value);
3193   void unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* value);
3194   ::onnx::TypeProto_Map* unsafe_arena_release_map_type();
3195
3196   private:
3197   const ::onnx::TypeProto_Map& _internal_map_type() const;
3198   ::onnx::TypeProto_Map* _internal_mutable_map_type();
3199
3200   public:
3201   // .onnx.TypeProto.Optional optional_type = 9;
3202   bool has_optional_type() const;
3203   private:
3204   bool _internal_has_optional_type() const;
3205
3206   public:
3207   void clear_optional_type() ;
3208   const ::onnx::TypeProto_Optional& optional_type() const;
3209   PROTOBUF_NODISCARD ::onnx::TypeProto_Optional* release_optional_type();
3210   ::onnx::TypeProto_Optional* mutable_optional_type();
3211   void set_allocated_optional_type(::onnx::TypeProto_Optional* value);
3212   void unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* value);
3213   ::onnx::TypeProto_Optional* unsafe_arena_release_optional_type();
3214
3215   private:
3216   const ::onnx::TypeProto_Optional& _internal_optional_type() const;
3217   ::onnx::TypeProto_Optional* _internal_mutable_optional_type();
3218
3219   public:
3220   // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
3221   bool has_sparse_tensor_type() const;
3222   private:
3223   bool _internal_has_sparse_tensor_type() const;
3224
3225   public:
3226   void clear_sparse_tensor_type() ;
3227   const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
3228   PROTOBUF_NODISCARD ::onnx::TypeProto_SparseTensor* release_sparse_tensor_type();
3229   ::onnx::TypeProto_SparseTensor* mutable_sparse_tensor_type();
3230   void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value);
3231   void unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value);
3232   ::onnx::TypeProto_SparseTensor* unsafe_arena_release_sparse_tensor_type();
3233
3234   private:
3235   const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
3236   ::onnx::TypeProto_SparseTensor* _internal_mutable_sparse_tensor_type();
3237
3238   public:
3239   // .onnx.TypeProto.Opaque opaque_type = 7;
3240   bool has_opaque_type() const;
3241   private:
3242   bool _internal_has_opaque_type() const;
3243
3244   public:
3245   void clear_opaque_type() ;
3246   const ::onnx::TypeProto_Opaque& opaque_type() const;
3247   PROTOBUF_NODISCARD ::onnx::TypeProto_Opaque* release_opaque_type();
3248   ::onnx::TypeProto_Opaque* mutable_opaque_type();
3249   void set_allocated_opaque_type(::onnx::TypeProto_Opaque* value);
3250   void unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* value);
3251   ::onnx::TypeProto_Opaque* unsafe_arena_release_opaque_type();
3252
3253   private:
3254   const ::onnx::TypeProto_Opaque& _internal_opaque_type() const;
3255   ::onnx::TypeProto_Opaque* _internal_mutable_opaque_type();
3256
3257   public:
3258   void clear_value();
3259   ValueCase value_case() const;
3260   // @@protoc_insertion_point(class_scope:onnx.TypeProto)
3261  private:
3262   class _Internal;
3263   void set_has_tensor_type();
3264   void set_has_sequence_type();
3265   void set_has_map_type();
3266   void set_has_optional_type();
3267   void set_has_sparse_tensor_type();
3268   void set_has_opaque_type();
3269   inline bool has_value() const;
3270   inline void clear_has_value();
3271   friend class ::google::protobuf::internal::TcParser;
3272   static const ::google::protobuf::internal::TcParseTable<
3273       0, 7, 6,
3274       33, 2>
3275       _table_;
3276
3277
3278   friend class ::google::protobuf::MessageLite;
3279   friend class ::google::protobuf::Arena;
3280   template <typename T>
3281   friend class ::google::protobuf::Arena::InternalHelper;
3282   using InternalArenaConstructable_ = void;
3283   using DestructorSkippable_ = void;
3284   struct Impl_ {
3285     inline explicit constexpr Impl_(
3286         ::google::protobuf::internal::ConstantInitialized) noexcept;
3287     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3288                           ::google::protobuf::Arena* arena);
3289     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3290                           ::google::protobuf::Arena* arena, const Impl_& from,
3291                           const TypeProto& from_msg);
3292     ::google::protobuf::internal::HasBits<1> _has_bits_;
3293     mutable ::google::protobuf::internal::CachedSize _cached_size_;
3294     ::google::protobuf::internal::ArenaStringPtr denotation_;
3295     union ValueUnion {
3296       constexpr ValueUnion() : _constinit_{} {}
3297       ::google::protobuf::internal::ConstantInitialized _constinit_;
3298       ::onnx::TypeProto_Tensor* tensor_type_;
3299       ::onnx::TypeProto_Sequence* sequence_type_;
3300       ::onnx::TypeProto_Map* map_type_;
3301       ::onnx::TypeProto_Optional* optional_type_;
3302       ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
3303       ::onnx::TypeProto_Opaque* opaque_type_;
3304     } value_;
3305     ::uint32_t _oneof_case_[1];
3306     PROTOBUF_TSAN_DECLARE_MEMBER
3307   };
3308   union { Impl_ _impl_; };
3309   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3310 };
3311 // -------------------------------------------------------------------
3312
3313 class ONNX_API TypeProto_Map final : public ::google::protobuf::Message
3314 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
3315  public:
3316   inline TypeProto_Map() : TypeProto_Map(nullptr) {}
3317   ~TypeProto_Map() PROTOBUF_FINAL;
3318   template <typename = void>
3319   explicit PROTOBUF_CONSTEXPR TypeProto_Map(
3320       ::google::protobuf::internal::ConstantInitialized);
3321
3322   inline TypeProto_Map(const TypeProto_Map& from) : TypeProto_Map(nullptr, from) {}
3323   inline TypeProto_Map(TypeProto_Map&& from) noexcept
3324       : TypeProto_Map(nullptr, std::move(from)) {}
3325   inline TypeProto_Map& operator=(const TypeProto_Map& from) {
3326     CopyFrom(from);
3327     return *this;
3328   }
3329   inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
3330     if (this == &from) return *this;
3331     if (GetArena() == from.GetArena()
3332 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3333         && GetArena() != nullptr
3334 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3335     ) {
3336       InternalSwap(&from);
3337     } else {
3338       CopyFrom(from);
3339     }
3340     return *this;
3341   }
3342
3343   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3344       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3345     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3346   }
3347   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
3348       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3349     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3350   }
3351
3352   static const ::google::protobuf::Descriptor* descriptor() {
3353     return GetDescriptor();
3354   }
3355   static const ::google::protobuf::Descriptor* GetDescriptor() {
3356     return default_instance().GetMetadata().descriptor;
3357   }
3358   static const ::google::protobuf::Reflection* GetReflection() {
3359     return default_instance().GetMetadata().reflection;
3360   }
3361   static const TypeProto_Map& default_instance() {
3362     return *internal_default_instance();
3363   }
3364   static inline const TypeProto_Map* internal_default_instance() {
3365     return reinterpret_cast<const TypeProto_Map*>(
3366         &_TypeProto_Map_default_instance_);
3367   }
3368   static constexpr int kIndexInFileMessages = 15;
3369   friend void swap(TypeProto_Map& a, TypeProto_Map& b) { a.Swap(&b); }
3370   inline void Swap(TypeProto_Map* other) {
3371     if (other == this) return;
3372 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3373     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
3374 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
3375     if (GetArena() == other->GetArena()) {
3376 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3377       InternalSwap(other);
3378     } else {
3379       ::google::protobuf::internal::GenericSwap(this, other);
3380     }
3381   }
3382   void UnsafeArenaSwap(TypeProto_Map* other) {
3383     if (other == this) return;
3384     ABSL_DCHECK(GetArena() == other->GetArena());
3385     InternalSwap(other);
3386   }
3387
3388   // implements Message ----------------------------------------------
3389
3390   TypeProto_Map* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
3391     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Map>(arena);
3392   }
3393   using ::google::protobuf::Message::CopyFrom;
3394   void CopyFrom(const TypeProto_Map& from);
3395   using ::google::protobuf::Message::MergeFrom;
3396   void MergeFrom(const TypeProto_Map& from) { TypeProto_Map::MergeImpl(*this, from); }
3397
3398   private:
3399   static void MergeImpl(
3400       ::google::protobuf::MessageLite& to_msg,
3401       const ::google::protobuf::MessageLite& from_msg);
3402
3403   public:
3404   bool IsInitialized() const {
3405     return true;
3406   }
3407   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3408   #if defined(PROTOBUF_CUSTOM_VTABLE)
3409   private:
3410   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3411   static ::uint8_t* _InternalSerialize(
3412       const MessageLite& msg, ::uint8_t* target,
3413       ::google::protobuf::io::EpsCopyOutputStream* stream);
3414
3415   public:
3416   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3417   ::uint8_t* _InternalSerialize(
3418       ::uint8_t* target,
3419       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
3420     return _InternalSerialize(*this, target, stream);
3421   }
3422   #else   // PROTOBUF_CUSTOM_VTABLE
3423   ::size_t ByteSizeLong() const final;
3424   ::uint8_t* _InternalSerialize(
3425       ::uint8_t* target,
3426       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
3427   #endif  // PROTOBUF_CUSTOM_VTABLE
3428   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3429
3430   private:
3431   void SharedCtor(::google::protobuf::Arena* arena);
3432   void SharedDtor();
3433   void InternalSwap(TypeProto_Map* other);
3434  private:
3435   friend class ::google::protobuf::internal::AnyMetadata;
3436   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Map"; }
3437
3438  protected:
3439   explicit TypeProto_Map(::google::protobuf::Arena* arena);
3440   TypeProto_Map(::google::protobuf::Arena* arena, const TypeProto_Map& from);
3441   TypeProto_Map(::google::protobuf::Arena* arena, TypeProto_Map&& from) noexcept
3442       : TypeProto_Map(arena) {
3443     *this = ::std::move(from);
3444   }
3445   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
3446   static const ::google::protobuf::Message::ClassDataFull _class_data_;
3447
3448  public:
3449   ::google::protobuf::Metadata GetMetadata() const;
3450   // nested types ----------------------------------------------------
3451
3452   // accessors -------------------------------------------------------
3453   enum : int {
3454     kValueTypeFieldNumber = 2,
3455     kKeyTypeFieldNumber = 1,
3456   };
3457   // optional .onnx.TypeProto value_type = 2;
3458   bool has_value_type() const;
3459   void clear_value_type() ;
3460   const ::onnx::TypeProto& value_type() const;
3461   PROTOBUF_NODISCARD ::onnx::TypeProto* release_value_type();
3462   ::onnx::TypeProto* mutable_value_type();
3463   void set_allocated_value_type(::onnx::TypeProto* value);
3464   void unsafe_arena_set_allocated_value_type(::onnx::TypeProto* value);
3465   ::onnx::TypeProto* unsafe_arena_release_value_type();
3466
3467   private:
3468   const ::onnx::TypeProto& _internal_value_type() const;
3469   ::onnx::TypeProto* _internal_mutable_value_type();
3470
3471   public:
3472   // optional int32 key_type = 1;
3473   bool has_key_type() const;
3474   void clear_key_type() ;
3475   ::int32_t key_type() const;
3476   void set_key_type(::int32_t value);
3477
3478   private:
3479   ::int32_t _internal_key_type() const;
3480   void _internal_set_key_type(::int32_t value);
3481
3482   public:
3483   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map)
3484  private:
3485   class _Internal;
3486   friend class ::google::protobuf::internal::TcParser;
3487   static const ::google::protobuf::internal::TcParseTable<
3488       1, 2, 1,
3489       0, 2>
3490       _table_;
3491
3492
3493   friend class ::google::protobuf::MessageLite;
3494   friend class ::google::protobuf::Arena;
3495   template <typename T>
3496   friend class ::google::protobuf::Arena::InternalHelper;
3497   using InternalArenaConstructable_ = void;
3498   using DestructorSkippable_ = void;
3499   struct Impl_ {
3500     inline explicit constexpr Impl_(
3501         ::google::protobuf::internal::ConstantInitialized) noexcept;
3502     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3503                           ::google::protobuf::Arena* arena);
3504     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3505                           ::google::protobuf::Arena* arena, const Impl_& from,
3506                           const TypeProto_Map& from_msg);
3507     ::google::protobuf::internal::HasBits<1> _has_bits_;
3508     mutable ::google::protobuf::internal::CachedSize _cached_size_;
3509     ::onnx::TypeProto* value_type_;
3510     ::int32_t key_type_;
3511     PROTOBUF_TSAN_DECLARE_MEMBER
3512   };
3513   union { Impl_ _impl_; };
3514   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3515 };
3516 // -------------------------------------------------------------------
3517
3518 class ONNX_API TypeProto_Optional final : public ::google::protobuf::Message
3519 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
3520  public:
3521   inline TypeProto_Optional() : TypeProto_Optional(nullptr) {}
3522   ~TypeProto_Optional() PROTOBUF_FINAL;
3523   template <typename = void>
3524   explicit PROTOBUF_CONSTEXPR TypeProto_Optional(
3525       ::google::protobuf::internal::ConstantInitialized);
3526
3527   inline TypeProto_Optional(const TypeProto_Optional& from) : TypeProto_Optional(nullptr, from) {}
3528   inline TypeProto_Optional(TypeProto_Optional&& from) noexcept
3529       : TypeProto_Optional(nullptr, std::move(from)) {}
3530   inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
3531     CopyFrom(from);
3532     return *this;
3533   }
3534   inline TypeProto_Optional& operator=(TypeProto_Optional&& from) noexcept {
3535     if (this == &from) return *this;
3536     if (GetArena() == from.GetArena()
3537 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3538         && GetArena() != nullptr
3539 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3540     ) {
3541       InternalSwap(&from);
3542     } else {
3543       CopyFrom(from);
3544     }
3545     return *this;
3546   }
3547
3548   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3549       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3550     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3551   }
3552   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
3553       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3554     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3555   }
3556
3557   static const ::google::protobuf::Descriptor* descriptor() {
3558     return GetDescriptor();
3559   }
3560   static const ::google::protobuf::Descriptor* GetDescriptor() {
3561     return default_instance().GetMetadata().descriptor;
3562   }
3563   static const ::google::protobuf::Reflection* GetReflection() {
3564     return default_instance().GetMetadata().reflection;
3565   }
3566   static const TypeProto_Optional& default_instance() {
3567     return *internal_default_instance();
3568   }
3569   static inline const TypeProto_Optional* internal_default_instance() {
3570     return reinterpret_cast<const TypeProto_Optional*>(
3571         &_TypeProto_Optional_default_instance_);
3572   }
3573   static constexpr int kIndexInFileMessages = 16;
3574   friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) { a.Swap(&b); }
3575   inline void Swap(TypeProto_Optional* other) {
3576     if (other == this) return;
3577 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3578     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
3579 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
3580     if (GetArena() == other->GetArena()) {
3581 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3582       InternalSwap(other);
3583     } else {
3584       ::google::protobuf::internal::GenericSwap(this, other);
3585     }
3586   }
3587   void UnsafeArenaSwap(TypeProto_Optional* other) {
3588     if (other == this) return;
3589     ABSL_DCHECK(GetArena() == other->GetArena());
3590     InternalSwap(other);
3591   }
3592
3593   // implements Message ----------------------------------------------
3594
3595   TypeProto_Optional* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
3596     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Optional>(arena);
3597   }
3598   using ::google::protobuf::Message::CopyFrom;
3599   void CopyFrom(const TypeProto_Optional& from);
3600   using ::google::protobuf::Message::MergeFrom;
3601   void MergeFrom(const TypeProto_Optional& from) { TypeProto_Optional::MergeImpl(*this, from); }
3602
3603   private:
3604   static void MergeImpl(
3605       ::google::protobuf::MessageLite& to_msg,
3606       const ::google::protobuf::MessageLite& from_msg);
3607
3608   public:
3609   bool IsInitialized() const {
3610     return true;
3611   }
3612   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3613   #if defined(PROTOBUF_CUSTOM_VTABLE)
3614   private:
3615   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3616   static ::uint8_t* _InternalSerialize(
3617       const MessageLite& msg, ::uint8_t* target,
3618       ::google::protobuf::io::EpsCopyOutputStream* stream);
3619
3620   public:
3621   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3622   ::uint8_t* _InternalSerialize(
3623       ::uint8_t* target,
3624       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
3625     return _InternalSerialize(*this, target, stream);
3626   }
3627   #else   // PROTOBUF_CUSTOM_VTABLE
3628   ::size_t ByteSizeLong() const final;
3629   ::uint8_t* _InternalSerialize(
3630       ::uint8_t* target,
3631       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
3632   #endif  // PROTOBUF_CUSTOM_VTABLE
3633   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3634
3635   private:
3636   void SharedCtor(::google::protobuf::Arena* arena);
3637   void SharedDtor();
3638   void InternalSwap(TypeProto_Optional* other);
3639  private:
3640   friend class ::google::protobuf::internal::AnyMetadata;
3641   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Optional"; }
3642
3643  protected:
3644   explicit TypeProto_Optional(::google::protobuf::Arena* arena);
3645   TypeProto_Optional(::google::protobuf::Arena* arena, const TypeProto_Optional& from);
3646   TypeProto_Optional(::google::protobuf::Arena* arena, TypeProto_Optional&& from) noexcept
3647       : TypeProto_Optional(arena) {
3648     *this = ::std::move(from);
3649   }
3650   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
3651   static const ::google::protobuf::Message::ClassDataFull _class_data_;
3652
3653  public:
3654   ::google::protobuf::Metadata GetMetadata() const;
3655   // nested types ----------------------------------------------------
3656
3657   // accessors -------------------------------------------------------
3658   enum : int {
3659     kElemTypeFieldNumber = 1,
3660   };
3661   // optional .onnx.TypeProto elem_type = 1;
3662   bool has_elem_type() const;
3663   void clear_elem_type() ;
3664   const ::onnx::TypeProto& elem_type() const;
3665   PROTOBUF_NODISCARD ::onnx::TypeProto* release_elem_type();
3666   ::onnx::TypeProto* mutable_elem_type();
3667   void set_allocated_elem_type(::onnx::TypeProto* value);
3668   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value);
3669   ::onnx::TypeProto* unsafe_arena_release_elem_type();
3670
3671   private:
3672   const ::onnx::TypeProto& _internal_elem_type() const;
3673   ::onnx::TypeProto* _internal_mutable_elem_type();
3674
3675   public:
3676   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional)
3677  private:
3678   class _Internal;
3679   friend class ::google::protobuf::internal::TcParser;
3680   static const ::google::protobuf::internal::TcParseTable<
3681       0, 1, 1,
3682       0, 2>
3683       _table_;
3684
3685
3686   friend class ::google::protobuf::MessageLite;
3687   friend class ::google::protobuf::Arena;
3688   template <typename T>
3689   friend class ::google::protobuf::Arena::InternalHelper;
3690   using InternalArenaConstructable_ = void;
3691   using DestructorSkippable_ = void;
3692   struct Impl_ {
3693     inline explicit constexpr Impl_(
3694         ::google::protobuf::internal::ConstantInitialized) noexcept;
3695     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3696                           ::google::protobuf::Arena* arena);
3697     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3698                           ::google::protobuf::Arena* arena, const Impl_& from,
3699                           const TypeProto_Optional& from_msg);
3700     ::google::protobuf::internal::HasBits<1> _has_bits_;
3701     mutable ::google::protobuf::internal::CachedSize _cached_size_;
3702     ::onnx::TypeProto* elem_type_;
3703     PROTOBUF_TSAN_DECLARE_MEMBER
3704   };
3705   union { Impl_ _impl_; };
3706   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3707 };
3708 // -------------------------------------------------------------------
3709
3710 class ONNX_API TypeProto_Sequence final : public ::google::protobuf::Message
3711 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
3712  public:
3713   inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {}
3714   ~TypeProto_Sequence() PROTOBUF_FINAL;
3715   template <typename = void>
3716   explicit PROTOBUF_CONSTEXPR TypeProto_Sequence(
3717       ::google::protobuf::internal::ConstantInitialized);
3718
3719   inline TypeProto_Sequence(const TypeProto_Sequence& from) : TypeProto_Sequence(nullptr, from) {}
3720   inline TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
3721       : TypeProto_Sequence(nullptr, std::move(from)) {}
3722   inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
3723     CopyFrom(from);
3724     return *this;
3725   }
3726   inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
3727     if (this == &from) return *this;
3728     if (GetArena() == from.GetArena()
3729 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3730         && GetArena() != nullptr
3731 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3732     ) {
3733       InternalSwap(&from);
3734     } else {
3735       CopyFrom(from);
3736     }
3737     return *this;
3738   }
3739
3740   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3741       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3742     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3743   }
3744   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
3745       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3746     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3747   }
3748
3749   static const ::google::protobuf::Descriptor* descriptor() {
3750     return GetDescriptor();
3751   }
3752   static const ::google::protobuf::Descriptor* GetDescriptor() {
3753     return default_instance().GetMetadata().descriptor;
3754   }
3755   static const ::google::protobuf::Reflection* GetReflection() {
3756     return default_instance().GetMetadata().reflection;
3757   }
3758   static const TypeProto_Sequence& default_instance() {
3759     return *internal_default_instance();
3760   }
3761   static inline const TypeProto_Sequence* internal_default_instance() {
3762     return reinterpret_cast<const TypeProto_Sequence*>(
3763         &_TypeProto_Sequence_default_instance_);
3764   }
3765   static constexpr int kIndexInFileMessages = 14;
3766   friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) { a.Swap(&b); }
3767   inline void Swap(TypeProto_Sequence* other) {
3768     if (other == this) return;
3769 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3770     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
3771 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
3772     if (GetArena() == other->GetArena()) {
3773 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3774       InternalSwap(other);
3775     } else {
3776       ::google::protobuf::internal::GenericSwap(this, other);
3777     }
3778   }
3779   void UnsafeArenaSwap(TypeProto_Sequence* other) {
3780     if (other == this) return;
3781     ABSL_DCHECK(GetArena() == other->GetArena());
3782     InternalSwap(other);
3783   }
3784
3785   // implements Message ----------------------------------------------
3786
3787   TypeProto_Sequence* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
3788     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Sequence>(arena);
3789   }
3790   using ::google::protobuf::Message::CopyFrom;
3791   void CopyFrom(const TypeProto_Sequence& from);
3792   using ::google::protobuf::Message::MergeFrom;
3793   void MergeFrom(const TypeProto_Sequence& from) { TypeProto_Sequence::MergeImpl(*this, from); }
3794
3795   private:
3796   static void MergeImpl(
3797       ::google::protobuf::MessageLite& to_msg,
3798       const ::google::protobuf::MessageLite& from_msg);
3799
3800   public:
3801   bool IsInitialized() const {
3802     return true;
3803   }
3804   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3805   #if defined(PROTOBUF_CUSTOM_VTABLE)
3806   private:
3807   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3808   static ::uint8_t* _InternalSerialize(
3809       const MessageLite& msg, ::uint8_t* target,
3810       ::google::protobuf::io::EpsCopyOutputStream* stream);
3811
3812   public:
3813   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3814   ::uint8_t* _InternalSerialize(
3815       ::uint8_t* target,
3816       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
3817     return _InternalSerialize(*this, target, stream);
3818   }
3819   #else   // PROTOBUF_CUSTOM_VTABLE
3820   ::size_t ByteSizeLong() const final;
3821   ::uint8_t* _InternalSerialize(
3822       ::uint8_t* target,
3823       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
3824   #endif  // PROTOBUF_CUSTOM_VTABLE
3825   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3826
3827   private:
3828   void SharedCtor(::google::protobuf::Arena* arena);
3829   void SharedDtor();
3830   void InternalSwap(TypeProto_Sequence* other);
3831  private:
3832   friend class ::google::protobuf::internal::AnyMetadata;
3833   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Sequence"; }
3834
3835  protected:
3836   explicit TypeProto_Sequence(::google::protobuf::Arena* arena);
3837   TypeProto_Sequence(::google::protobuf::Arena* arena, const TypeProto_Sequence& from);
3838   TypeProto_Sequence(::google::protobuf::Arena* arena, TypeProto_Sequence&& from) noexcept
3839       : TypeProto_Sequence(arena) {
3840     *this = ::std::move(from);
3841   }
3842   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
3843   static const ::google::protobuf::Message::ClassDataFull _class_data_;
3844
3845  public:
3846   ::google::protobuf::Metadata GetMetadata() const;
3847   // nested types ----------------------------------------------------
3848
3849   // accessors -------------------------------------------------------
3850   enum : int {
3851     kElemTypeFieldNumber = 1,
3852   };
3853   // optional .onnx.TypeProto elem_type = 1;
3854   bool has_elem_type() const;
3855   void clear_elem_type() ;
3856   const ::onnx::TypeProto& elem_type() const;
3857   PROTOBUF_NODISCARD ::onnx::TypeProto* release_elem_type();
3858   ::onnx::TypeProto* mutable_elem_type();
3859   void set_allocated_elem_type(::onnx::TypeProto* value);
3860   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value);
3861   ::onnx::TypeProto* unsafe_arena_release_elem_type();
3862
3863   private:
3864   const ::onnx::TypeProto& _internal_elem_type() const;
3865   ::onnx::TypeProto* _internal_mutable_elem_type();
3866
3867   public:
3868   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence)
3869  private:
3870   class _Internal;
3871   friend class ::google::protobuf::internal::TcParser;
3872   static const ::google::protobuf::internal::TcParseTable<
3873       0, 1, 1,
3874       0, 2>
3875       _table_;
3876
3877
3878   friend class ::google::protobuf::MessageLite;
3879   friend class ::google::protobuf::Arena;
3880   template <typename T>
3881   friend class ::google::protobuf::Arena::InternalHelper;
3882   using InternalArenaConstructable_ = void;
3883   using DestructorSkippable_ = void;
3884   struct Impl_ {
3885     inline explicit constexpr Impl_(
3886         ::google::protobuf::internal::ConstantInitialized) noexcept;
3887     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3888                           ::google::protobuf::Arena* arena);
3889     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
3890                           ::google::protobuf::Arena* arena, const Impl_& from,
3891                           const TypeProto_Sequence& from_msg);
3892     ::google::protobuf::internal::HasBits<1> _has_bits_;
3893     mutable ::google::protobuf::internal::CachedSize _cached_size_;
3894     ::onnx::TypeProto* elem_type_;
3895     PROTOBUF_TSAN_DECLARE_MEMBER
3896   };
3897   union { Impl_ _impl_; };
3898   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3899 };
3900 // -------------------------------------------------------------------
3901
3902 class ONNX_API ValueInfoProto final : public ::google::protobuf::Message
3903 /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
3904  public:
3905   inline ValueInfoProto() : ValueInfoProto(nullptr) {}
3906   ~ValueInfoProto() PROTOBUF_FINAL;
3907   template <typename = void>
3908   explicit PROTOBUF_CONSTEXPR ValueInfoProto(
3909       ::google::protobuf::internal::ConstantInitialized);
3910
3911   inline ValueInfoProto(const ValueInfoProto& from) : ValueInfoProto(nullptr, from) {}
3912   inline ValueInfoProto(ValueInfoProto&& from) noexcept
3913       : ValueInfoProto(nullptr, std::move(from)) {}
3914   inline ValueInfoProto& operator=(const ValueInfoProto& from) {
3915     CopyFrom(from);
3916     return *this;
3917   }
3918   inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
3919     if (this == &from) return *this;
3920     if (GetArena() == from.GetArena()
3921 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3922         && GetArena() != nullptr
3923 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3924     ) {
3925       InternalSwap(&from);
3926     } else {
3927       CopyFrom(from);
3928     }
3929     return *this;
3930   }
3931
3932   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3933       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3934     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3935   }
3936   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
3937       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3938     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3939   }
3940
3941   static const ::google::protobuf::Descriptor* descriptor() {
3942     return GetDescriptor();
3943   }
3944   static const ::google::protobuf::Descriptor* GetDescriptor() {
3945     return default_instance().GetMetadata().descriptor;
3946   }
3947   static const ::google::protobuf::Reflection* GetReflection() {
3948     return default_instance().GetMetadata().reflection;
3949   }
3950   static const ValueInfoProto& default_instance() {
3951     return *internal_default_instance();
3952   }
3953   static inline const ValueInfoProto* internal_default_instance() {
3954     return reinterpret_cast<const ValueInfoProto*>(
3955         &_ValueInfoProto_default_instance_);
3956   }
3957   static constexpr int kIndexInFileMessages = 1;
3958   friend void swap(ValueInfoProto& a, ValueInfoProto& b) { a.Swap(&b); }
3959   inline void Swap(ValueInfoProto* other) {
3960     if (other == this) return;
3961 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3962     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
3963 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
3964     if (GetArena() == other->GetArena()) {
3965 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3966       InternalSwap(other);
3967     } else {
3968       ::google::protobuf::internal::GenericSwap(this, other);
3969     }
3970   }
3971   void UnsafeArenaSwap(ValueInfoProto* other) {
3972     if (other == this) return;
3973     ABSL_DCHECK(GetArena() == other->GetArena());
3974     InternalSwap(other);
3975   }
3976
3977   // implements Message ----------------------------------------------
3978
3979   ValueInfoProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
3980     return ::google::protobuf::Message::DefaultConstruct<ValueInfoProto>(arena);
3981   }
3982   using ::google::protobuf::Message::CopyFrom;
3983   void CopyFrom(const ValueInfoProto& from);
3984   using ::google::protobuf::Message::MergeFrom;
3985   void MergeFrom(const ValueInfoProto& from) { ValueInfoProto::MergeImpl(*this, from); }
3986
3987   private:
3988   static void MergeImpl(
3989       ::google::protobuf::MessageLite& to_msg,
3990       const ::google::protobuf::MessageLite& from_msg);
3991
3992   public:
3993   bool IsInitialized() const {
3994     return true;
3995   }
3996   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3997   #if defined(PROTOBUF_CUSTOM_VTABLE)
3998   private:
3999   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4000   static ::uint8_t* _InternalSerialize(
4001       const MessageLite& msg, ::uint8_t* target,
4002       ::google::protobuf::io::EpsCopyOutputStream* stream);
4003
4004   public:
4005   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4006   ::uint8_t* _InternalSerialize(
4007       ::uint8_t* target,
4008       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
4009     return _InternalSerialize(*this, target, stream);
4010   }
4011   #else   // PROTOBUF_CUSTOM_VTABLE
4012   ::size_t ByteSizeLong() const final;
4013   ::uint8_t* _InternalSerialize(
4014       ::uint8_t* target,
4015       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
4016   #endif  // PROTOBUF_CUSTOM_VTABLE
4017   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4018
4019   private:
4020   void SharedCtor(::google::protobuf::Arena* arena);
4021   void SharedDtor();
4022   void InternalSwap(ValueInfoProto* other);
4023  private:
4024   friend class ::google::protobuf::internal::AnyMetadata;
4025   static ::absl::string_view FullMessageName() { return "onnx.ValueInfoProto"; }
4026
4027  protected:
4028   explicit ValueInfoProto(::google::protobuf::Arena* arena);
4029   ValueInfoProto(::google::protobuf::Arena* arena, const ValueInfoProto& from);
4030   ValueInfoProto(::google::protobuf::Arena* arena, ValueInfoProto&& from) noexcept
4031       : ValueInfoProto(arena) {
4032     *this = ::std::move(from);
4033   }
4034   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
4035   static const ::google::protobuf::Message::ClassDataFull _class_data_;
4036
4037  public:
4038   ::google::protobuf::Metadata GetMetadata() const;
4039   // nested types ----------------------------------------------------
4040
4041   // accessors -------------------------------------------------------
4042   enum : int {
4043     kMetadataPropsFieldNumber = 4,
4044     kNameFieldNumber = 1,
4045     kDocStringFieldNumber = 3,
4046     kTypeFieldNumber = 2,
4047   };
4048   // repeated .onnx.StringStringEntryProto metadata_props = 4;
4049   int metadata_props_size() const;
4050   private:
4051   int _internal_metadata_props_size() const;
4052
4053   public:
4054   void clear_metadata_props() ;
4055   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
4056   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
4057
4058   private:
4059   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
4060   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
4061   public:
4062   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
4063   ::onnx::StringStringEntryProto* add_metadata_props();
4064   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
4065   // optional string name = 1;
4066   bool has_name() const;
4067   void clear_name() ;
4068   const std::string& name() const;
4069   template <typename Arg_ = const std::string&, typename... Args_>
4070   void set_name(Arg_&& arg, Args_... args);
4071   std::string* mutable_name();
4072   PROTOBUF_NODISCARD std::string* release_name();
4073   void set_allocated_name(std::string* value);
4074
4075   private:
4076   const std::string& _internal_name() const;
4077   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
4078       const std::string& value);
4079   std::string* _internal_mutable_name();
4080
4081   public:
4082   // optional string doc_string = 3;
4083   bool has_doc_string() const;
4084   void clear_doc_string() ;
4085   const std::string& doc_string() const;
4086   template <typename Arg_ = const std::string&, typename... Args_>
4087   void set_doc_string(Arg_&& arg, Args_... args);
4088   std::string* mutable_doc_string();
4089   PROTOBUF_NODISCARD std::string* release_doc_string();
4090   void set_allocated_doc_string(std::string* value);
4091
4092   private:
4093   const std::string& _internal_doc_string() const;
4094   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
4095       const std::string& value);
4096   std::string* _internal_mutable_doc_string();
4097
4098   public:
4099   // optional .onnx.TypeProto type = 2;
4100   bool has_type() const;
4101   void clear_type() ;
4102   const ::onnx::TypeProto& type() const;
4103   PROTOBUF_NODISCARD ::onnx::TypeProto* release_type();
4104   ::onnx::TypeProto* mutable_type();
4105   void set_allocated_type(::onnx::TypeProto* value);
4106   void unsafe_arena_set_allocated_type(::onnx::TypeProto* value);
4107   ::onnx::TypeProto* unsafe_arena_release_type();
4108
4109   private:
4110   const ::onnx::TypeProto& _internal_type() const;
4111   ::onnx::TypeProto* _internal_mutable_type();
4112
4113   public:
4114   // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
4115  private:
4116   class _Internal;
4117   friend class ::google::protobuf::internal::TcParser;
4118   static const ::google::protobuf::internal::TcParseTable<
4119       2, 4, 2,
4120       42, 2>
4121       _table_;
4122
4123
4124   friend class ::google::protobuf::MessageLite;
4125   friend class ::google::protobuf::Arena;
4126   template <typename T>
4127   friend class ::google::protobuf::Arena::InternalHelper;
4128   using InternalArenaConstructable_ = void;
4129   using DestructorSkippable_ = void;
4130   struct Impl_ {
4131     inline explicit constexpr Impl_(
4132         ::google::protobuf::internal::ConstantInitialized) noexcept;
4133     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
4134                           ::google::protobuf::Arena* arena);
4135     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
4136                           ::google::protobuf::Arena* arena, const Impl_& from,
4137                           const ValueInfoProto& from_msg);
4138     ::google::protobuf::internal::HasBits<1> _has_bits_;
4139     mutable ::google::protobuf::internal::CachedSize _cached_size_;
4140     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
4141     ::google::protobuf::internal::ArenaStringPtr name_;
4142     ::google::protobuf::internal::ArenaStringPtr doc_string_;
4143     ::onnx::TypeProto* type_;
4144     PROTOBUF_TSAN_DECLARE_MEMBER
4145   };
4146   union { Impl_ _impl_; };
4147   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
4148 };
4149 // -------------------------------------------------------------------
4150
4151 class ONNX_API AttributeProto final : public ::google::protobuf::Message
4152 /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
4153  public:
4154   inline AttributeProto() : AttributeProto(nullptr) {}
4155   ~AttributeProto() PROTOBUF_FINAL;
4156   template <typename = void>
4157   explicit PROTOBUF_CONSTEXPR AttributeProto(
4158       ::google::protobuf::internal::ConstantInitialized);
4159
4160   inline AttributeProto(const AttributeProto& from) : AttributeProto(nullptr, from) {}
4161   inline AttributeProto(AttributeProto&& from) noexcept
4162       : AttributeProto(nullptr, std::move(from)) {}
4163   inline AttributeProto& operator=(const AttributeProto& from) {
4164     CopyFrom(from);
4165     return *this;
4166   }
4167   inline AttributeProto& operator=(AttributeProto&& from) noexcept {
4168     if (this == &from) return *this;
4169     if (GetArena() == from.GetArena()
4170 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4171         && GetArena() != nullptr
4172 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4173     ) {
4174       InternalSwap(&from);
4175     } else {
4176       CopyFrom(from);
4177     }
4178     return *this;
4179   }
4180
4181   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
4182       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4183     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
4184   }
4185   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
4186       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4187     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
4188   }
4189
4190   static const ::google::protobuf::Descriptor* descriptor() {
4191     return GetDescriptor();
4192   }
4193   static const ::google::protobuf::Descriptor* GetDescriptor() {
4194     return default_instance().GetMetadata().descriptor;
4195   }
4196   static const ::google::protobuf::Reflection* GetReflection() {
4197     return default_instance().GetMetadata().reflection;
4198   }
4199   static const AttributeProto& default_instance() {
4200     return *internal_default_instance();
4201   }
4202   static inline const AttributeProto* internal_default_instance() {
4203     return reinterpret_cast<const AttributeProto*>(
4204         &_AttributeProto_default_instance_);
4205   }
4206   static constexpr int kIndexInFileMessages = 0;
4207   friend void swap(AttributeProto& a, AttributeProto& b) { a.Swap(&b); }
4208   inline void Swap(AttributeProto* other) {
4209     if (other == this) return;
4210 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4211     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
4212 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
4213     if (GetArena() == other->GetArena()) {
4214 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4215       InternalSwap(other);
4216     } else {
4217       ::google::protobuf::internal::GenericSwap(this, other);
4218     }
4219   }
4220   void UnsafeArenaSwap(AttributeProto* other) {
4221     if (other == this) return;
4222     ABSL_DCHECK(GetArena() == other->GetArena());
4223     InternalSwap(other);
4224   }
4225
4226   // implements Message ----------------------------------------------
4227
4228   AttributeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
4229     return ::google::protobuf::Message::DefaultConstruct<AttributeProto>(arena);
4230   }
4231   using ::google::protobuf::Message::CopyFrom;
4232   void CopyFrom(const AttributeProto& from);
4233   using ::google::protobuf::Message::MergeFrom;
4234   void MergeFrom(const AttributeProto& from) { AttributeProto::MergeImpl(*this, from); }
4235
4236   private:
4237   static void MergeImpl(
4238       ::google::protobuf::MessageLite& to_msg,
4239       const ::google::protobuf::MessageLite& from_msg);
4240
4241   public:
4242   bool IsInitialized() const {
4243     return true;
4244   }
4245   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
4246   #if defined(PROTOBUF_CUSTOM_VTABLE)
4247   private:
4248   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4249   static ::uint8_t* _InternalSerialize(
4250       const MessageLite& msg, ::uint8_t* target,
4251       ::google::protobuf::io::EpsCopyOutputStream* stream);
4252
4253   public:
4254   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4255   ::uint8_t* _InternalSerialize(
4256       ::uint8_t* target,
4257       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
4258     return _InternalSerialize(*this, target, stream);
4259   }
4260   #else   // PROTOBUF_CUSTOM_VTABLE
4261   ::size_t ByteSizeLong() const final;
4262   ::uint8_t* _InternalSerialize(
4263       ::uint8_t* target,
4264       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
4265   #endif  // PROTOBUF_CUSTOM_VTABLE
4266   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4267
4268   private:
4269   void SharedCtor(::google::protobuf::Arena* arena);
4270   void SharedDtor();
4271   void InternalSwap(AttributeProto* other);
4272  private:
4273   friend class ::google::protobuf::internal::AnyMetadata;
4274   static ::absl::string_view FullMessageName() { return "onnx.AttributeProto"; }
4275
4276  protected:
4277   explicit AttributeProto(::google::protobuf::Arena* arena);
4278   AttributeProto(::google::protobuf::Arena* arena, const AttributeProto& from);
4279   AttributeProto(::google::protobuf::Arena* arena, AttributeProto&& from) noexcept
4280       : AttributeProto(arena) {
4281     *this = ::std::move(from);
4282   }
4283   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
4284   static const ::google::protobuf::Message::ClassDataFull _class_data_;
4285
4286  public:
4287   ::google::protobuf::Metadata GetMetadata() const;
4288   // nested types ----------------------------------------------------
4289   using AttributeType = AttributeProto_AttributeType;
4290   static constexpr AttributeType UNDEFINED = AttributeProto_AttributeType_UNDEFINED;
4291   static constexpr AttributeType FLOAT = AttributeProto_AttributeType_FLOAT;
4292   static constexpr AttributeType INT = AttributeProto_AttributeType_INT;
4293   static constexpr AttributeType STRING = AttributeProto_AttributeType_STRING;
4294   static constexpr AttributeType TENSOR = AttributeProto_AttributeType_TENSOR;
4295   static constexpr AttributeType GRAPH = AttributeProto_AttributeType_GRAPH;
4296   static constexpr AttributeType SPARSE_TENSOR = AttributeProto_AttributeType_SPARSE_TENSOR;
4297   static constexpr AttributeType TYPE_PROTO = AttributeProto_AttributeType_TYPE_PROTO;
4298   static constexpr AttributeType FLOATS = AttributeProto_AttributeType_FLOATS;
4299   static constexpr AttributeType INTS = AttributeProto_AttributeType_INTS;
4300   static constexpr AttributeType STRINGS = AttributeProto_AttributeType_STRINGS;
4301   static constexpr AttributeType TENSORS = AttributeProto_AttributeType_TENSORS;
4302   static constexpr AttributeType GRAPHS = AttributeProto_AttributeType_GRAPHS;
4303   static constexpr AttributeType SPARSE_TENSORS = AttributeProto_AttributeType_SPARSE_TENSORS;
4304   static constexpr AttributeType TYPE_PROTOS = AttributeProto_AttributeType_TYPE_PROTOS;
4305   static inline bool AttributeType_IsValid(int value) {
4306     return AttributeProto_AttributeType_IsValid(value);
4307   }
4308   static constexpr AttributeType AttributeType_MIN = AttributeProto_AttributeType_AttributeType_MIN;
4309   static constexpr AttributeType AttributeType_MAX = AttributeProto_AttributeType_AttributeType_MAX;
4310   static constexpr int AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
4311   static inline const ::google::protobuf::EnumDescriptor* AttributeType_descriptor() {
4312     return AttributeProto_AttributeType_descriptor();
4313   }
4314   template <typename T>
4315   static inline const std::string& AttributeType_Name(T value) {
4316     return AttributeProto_AttributeType_Name(value);
4317   }
4318   static inline bool AttributeType_Parse(absl::string_view name, AttributeType* value) {
4319     return AttributeProto_AttributeType_Parse(name, value);
4320   }
4321
4322   // accessors -------------------------------------------------------
4323   enum : int {
4324     kFloatsFieldNumber = 7,
4325     kIntsFieldNumber = 8,
4326     kStringsFieldNumber = 9,
4327     kTensorsFieldNumber = 10,
4328     kGraphsFieldNumber = 11,
4329     kTypeProtosFieldNumber = 15,
4330     kSparseTensorsFieldNumber = 23,
4331     kNameFieldNumber = 1,
4332     kSFieldNumber = 4,
4333     kDocStringFieldNumber = 13,
4334     kRefAttrNameFieldNumber = 21,
4335     kTFieldNumber = 5,
4336     kGFieldNumber = 6,
4337     kTpFieldNumber = 14,
4338     kSparseTensorFieldNumber = 22,
4339     kIFieldNumber = 3,
4340     kFFieldNumber = 2,
4341     kTypeFieldNumber = 20,
4342   };
4343   // repeated float floats = 7;
4344   int floats_size() const;
4345   private:
4346   int _internal_floats_size() const;
4347
4348   public:
4349   void clear_floats() ;
4350   float floats(int index) const;
4351   void set_floats(int index, float value);
4352   void add_floats(float value);
4353   const ::google::protobuf::RepeatedField<float>& floats() const;
4354   ::google::protobuf::RepeatedField<float>* mutable_floats();
4355
4356   private:
4357   const ::google::protobuf::RepeatedField<float>& _internal_floats() const;
4358   ::google::protobuf::RepeatedField<float>* _internal_mutable_floats();
4359
4360   public:
4361   // repeated int64 ints = 8;
4362   int ints_size() const;
4363   private:
4364   int _internal_ints_size() const;
4365
4366   public:
4367   void clear_ints() ;
4368   ::int64_t ints(int index) const;
4369   void set_ints(int index, ::int64_t value);
4370   void add_ints(::int64_t value);
4371   const ::google::protobuf::RepeatedField<::int64_t>& ints() const;
4372   ::google::protobuf::RepeatedField<::int64_t>* mutable_ints();
4373
4374   private:
4375   const ::google::protobuf::RepeatedField<::int64_t>& _internal_ints() const;
4376   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_ints();
4377
4378   public:
4379   // repeated bytes strings = 9;
4380   int strings_size() const;
4381   private:
4382   int _internal_strings_size() const;
4383
4384   public:
4385   void clear_strings() ;
4386   const std::string& strings(int index) const;
4387   std::string* mutable_strings(int index);
4388   template <typename Arg_ = const std::string&, typename... Args_>
4389   void set_strings(int index, Arg_&& value, Args_... args);
4390   std::string* add_strings();
4391   template <typename Arg_ = const std::string&, typename... Args_>
4392   void add_strings(Arg_&& value, Args_... args);
4393   const ::google::protobuf::RepeatedPtrField<std::string>& strings() const;
4394   ::google::protobuf::RepeatedPtrField<std::string>* mutable_strings();
4395
4396   private:
4397   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_strings() const;
4398   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_strings();
4399
4400   public:
4401   // repeated .onnx.TensorProto tensors = 10;
4402   int tensors_size() const;
4403   private:
4404   int _internal_tensors_size() const;
4405
4406   public:
4407   void clear_tensors() ;
4408   ::onnx::TensorProto* mutable_tensors(int index);
4409   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* mutable_tensors();
4410
4411   private:
4412   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensors() const;
4413   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* _internal_mutable_tensors();
4414   public:
4415   const ::onnx::TensorProto& tensors(int index) const;
4416   ::onnx::TensorProto* add_tensors();
4417   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensors() const;
4418   // repeated .onnx.GraphProto graphs = 11;
4419   int graphs_size() const;
4420   private:
4421   int _internal_graphs_size() const;
4422
4423   public:
4424   void clear_graphs() ;
4425   ::onnx::GraphProto* mutable_graphs(int index);
4426   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* mutable_graphs();
4427
4428   private:
4429   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& _internal_graphs() const;
4430   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* _internal_mutable_graphs();
4431   public:
4432   const ::onnx::GraphProto& graphs(int index) const;
4433   ::onnx::GraphProto* add_graphs();
4434   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& graphs() const;
4435   // repeated .onnx.TypeProto type_protos = 15;
4436   int type_protos_size() const;
4437   private:
4438   int _internal_type_protos_size() const;
4439
4440   public:
4441   void clear_type_protos() ;
4442   ::onnx::TypeProto* mutable_type_protos(int index);
4443   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* mutable_type_protos();
4444
4445   private:
4446   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& _internal_type_protos() const;
4447   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* _internal_mutable_type_protos();
4448   public:
4449   const ::onnx::TypeProto& type_protos(int index) const;
4450   ::onnx::TypeProto* add_type_protos();
4451   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& type_protos() const;
4452   // repeated .onnx.SparseTensorProto sparse_tensors = 23;
4453   int sparse_tensors_size() const;
4454   private:
4455   int _internal_sparse_tensors_size() const;
4456
4457   public:
4458   void clear_sparse_tensors() ;
4459   ::onnx::SparseTensorProto* mutable_sparse_tensors(int index);
4460   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* mutable_sparse_tensors();
4461
4462   private:
4463   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensors() const;
4464   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* _internal_mutable_sparse_tensors();
4465   public:
4466   const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
4467   ::onnx::SparseTensorProto* add_sparse_tensors();
4468   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensors() const;
4469   // optional string name = 1;
4470   bool has_name() const;
4471   void clear_name() ;
4472   const std::string& name() const;
4473   template <typename Arg_ = const std::string&, typename... Args_>
4474   void set_name(Arg_&& arg, Args_... args);
4475   std::string* mutable_name();
4476   PROTOBUF_NODISCARD std::string* release_name();
4477   void set_allocated_name(std::string* value);
4478
4479   private:
4480   const std::string& _internal_name() const;
4481   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
4482       const std::string& value);
4483   std::string* _internal_mutable_name();
4484
4485   public:
4486   // optional bytes s = 4;
4487   bool has_s() const;
4488   void clear_s() ;
4489   const std::string& s() const;
4490   template <typename Arg_ = const std::string&, typename... Args_>
4491   void set_s(Arg_&& arg, Args_... args);
4492   std::string* mutable_s();
4493   PROTOBUF_NODISCARD std::string* release_s();
4494   void set_allocated_s(std::string* value);
4495
4496   private:
4497   const std::string& _internal_s() const;
4498   inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(
4499       const std::string& value);
4500   std::string* _internal_mutable_s();
4501
4502   public:
4503   // optional string doc_string = 13;
4504   bool has_doc_string() const;
4505   void clear_doc_string() ;
4506   const std::string& doc_string() const;
4507   template <typename Arg_ = const std::string&, typename... Args_>
4508   void set_doc_string(Arg_&& arg, Args_... args);
4509   std::string* mutable_doc_string();
4510   PROTOBUF_NODISCARD std::string* release_doc_string();
4511   void set_allocated_doc_string(std::string* value);
4512
4513   private:
4514   const std::string& _internal_doc_string() const;
4515   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
4516       const std::string& value);
4517   std::string* _internal_mutable_doc_string();
4518
4519   public:
4520   // optional string ref_attr_name = 21;
4521   bool has_ref_attr_name() const;
4522   void clear_ref_attr_name() ;
4523   const std::string& ref_attr_name() const;
4524   template <typename Arg_ = const std::string&, typename... Args_>
4525   void set_ref_attr_name(Arg_&& arg, Args_... args);
4526   std::string* mutable_ref_attr_name();
4527   PROTOBUF_NODISCARD std::string* release_ref_attr_name();
4528   void set_allocated_ref_attr_name(std::string* value);
4529
4530   private:
4531   const std::string& _internal_ref_attr_name() const;
4532   inline PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(
4533       const std::string& value);
4534   std::string* _internal_mutable_ref_attr_name();
4535
4536   public:
4537   // optional .onnx.TensorProto t = 5;
4538   bool has_t() const;
4539   void clear_t() ;
4540   const ::onnx::TensorProto& t() const;
4541   PROTOBUF_NODISCARD ::onnx::TensorProto* release_t();
4542   ::onnx::TensorProto* mutable_t();
4543   void set_allocated_t(::onnx::TensorProto* value);
4544   void unsafe_arena_set_allocated_t(::onnx::TensorProto* value);
4545   ::onnx::TensorProto* unsafe_arena_release_t();
4546
4547   private:
4548   const ::onnx::TensorProto& _internal_t() const;
4549   ::onnx::TensorProto* _internal_mutable_t();
4550
4551   public:
4552   // optional .onnx.GraphProto g = 6;
4553   bool has_g() const;
4554   void clear_g() ;
4555   const ::onnx::GraphProto& g() const;
4556   PROTOBUF_NODISCARD ::onnx::GraphProto* release_g();
4557   ::onnx::GraphProto* mutable_g();
4558   void set_allocated_g(::onnx::GraphProto* value);
4559   void unsafe_arena_set_allocated_g(::onnx::GraphProto* value);
4560   ::onnx::GraphProto* unsafe_arena_release_g();
4561
4562   private:
4563   const ::onnx::GraphProto& _internal_g() const;
4564   ::onnx::GraphProto* _internal_mutable_g();
4565
4566   public:
4567   // optional .onnx.TypeProto tp = 14;
4568   bool has_tp() const;
4569   void clear_tp() ;
4570   const ::onnx::TypeProto& tp() const;
4571   PROTOBUF_NODISCARD ::onnx::TypeProto* release_tp();
4572   ::onnx::TypeProto* mutable_tp();
4573   void set_allocated_tp(::onnx::TypeProto* value);
4574   void unsafe_arena_set_allocated_tp(::onnx::TypeProto* value);
4575   ::onnx::TypeProto* unsafe_arena_release_tp();
4576
4577   private:
4578   const ::onnx::TypeProto& _internal_tp() const;
4579   ::onnx::TypeProto* _internal_mutable_tp();
4580
4581   public:
4582   // optional .onnx.SparseTensorProto sparse_tensor = 22;
4583   bool has_sparse_tensor() const;
4584   void clear_sparse_tensor() ;
4585   const ::onnx::SparseTensorProto& sparse_tensor() const;
4586   PROTOBUF_NODISCARD ::onnx::SparseTensorProto* release_sparse_tensor();
4587   ::onnx::SparseTensorProto* mutable_sparse_tensor();
4588   void set_allocated_sparse_tensor(::onnx::SparseTensorProto* value);
4589   void unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* value);
4590   ::onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor();
4591
4592   private:
4593   const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
4594   ::onnx::SparseTensorProto* _internal_mutable_sparse_tensor();
4595
4596   public:
4597   // optional int64 i = 3;
4598   bool has_i() const;
4599   void clear_i() ;
4600   ::int64_t i() const;
4601   void set_i(::int64_t value);
4602
4603   private:
4604   ::int64_t _internal_i() const;
4605   void _internal_set_i(::int64_t value);
4606
4607   public:
4608   // optional float f = 2;
4609   bool has_f() const;
4610   void clear_f() ;
4611   float f() const;
4612   void set_f(float value);
4613
4614   private:
4615   float _internal_f() const;
4616   void _internal_set_f(float value);
4617
4618   public:
4619   // optional .onnx.AttributeProto.AttributeType type = 20;
4620   bool has_type() const;
4621   void clear_type() ;
4622   ::onnx::AttributeProto_AttributeType type() const;
4623   void set_type(::onnx::AttributeProto_AttributeType value);
4624
4625   private:
4626   ::onnx::AttributeProto_AttributeType _internal_type() const;
4627   void _internal_set_type(::onnx::AttributeProto_AttributeType value);
4628
4629   public:
4630   // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
4631  private:
4632   class _Internal;
4633   friend class ::google::protobuf::internal::TcParser;
4634   static const ::google::protobuf::internal::TcParseTable<
4635       5, 18, 9,
4636       71, 2>
4637       _table_;
4638
4639
4640   friend class ::google::protobuf::MessageLite;
4641   friend class ::google::protobuf::Arena;
4642   template <typename T>
4643   friend class ::google::protobuf::Arena::InternalHelper;
4644   using InternalArenaConstructable_ = void;
4645   using DestructorSkippable_ = void;
4646   struct Impl_ {
4647     inline explicit constexpr Impl_(
4648         ::google::protobuf::internal::ConstantInitialized) noexcept;
4649     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
4650                           ::google::protobuf::Arena* arena);
4651     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
4652                           ::google::protobuf::Arena* arena, const Impl_& from,
4653                           const AttributeProto& from_msg);
4654     ::google::protobuf::internal::HasBits<1> _has_bits_;
4655     mutable ::google::protobuf::internal::CachedSize _cached_size_;
4656     ::google::protobuf::RepeatedField<float> floats_;
4657     ::google::protobuf::RepeatedField<::int64_t> ints_;
4658     ::google::protobuf::RepeatedPtrField<std::string> strings_;
4659     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensors_;
4660     ::google::protobuf::RepeatedPtrField< ::onnx::GraphProto > graphs_;
4661     ::google::protobuf::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
4662     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
4663     ::google::protobuf::internal::ArenaStringPtr name_;
4664     ::google::protobuf::internal::ArenaStringPtr s_;
4665     ::google::protobuf::internal::ArenaStringPtr doc_string_;
4666     ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
4667     ::onnx::TensorProto* t_;
4668     ::onnx::GraphProto* g_;
4669     ::onnx::TypeProto* tp_;
4670     ::onnx::SparseTensorProto* sparse_tensor_;
4671     ::int64_t i_;
4672     float f_;
4673     int type_;
4674     PROTOBUF_TSAN_DECLARE_MEMBER
4675   };
4676   union { Impl_ _impl_; };
4677   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
4678 };
4679 // -------------------------------------------------------------------
4680
4681 class ONNX_API GraphProto final : public ::google::protobuf::Message
4682 /* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
4683  public:
4684   inline GraphProto() : GraphProto(nullptr) {}
4685   ~GraphProto() PROTOBUF_FINAL;
4686   template <typename = void>
4687   explicit PROTOBUF_CONSTEXPR GraphProto(
4688       ::google::protobuf::internal::ConstantInitialized);
4689
4690   inline GraphProto(const GraphProto& from) : GraphProto(nullptr, from) {}
4691   inline GraphProto(GraphProto&& from) noexcept
4692       : GraphProto(nullptr, std::move(from)) {}
4693   inline GraphProto& operator=(const GraphProto& from) {
4694     CopyFrom(from);
4695     return *this;
4696   }
4697   inline GraphProto& operator=(GraphProto&& from) noexcept {
4698     if (this == &from) return *this;
4699     if (GetArena() == from.GetArena()
4700 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4701         && GetArena() != nullptr
4702 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4703     ) {
4704       InternalSwap(&from);
4705     } else {
4706       CopyFrom(from);
4707     }
4708     return *this;
4709   }
4710
4711   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
4712       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4713     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
4714   }
4715   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
4716       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4717     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
4718   }
4719
4720   static const ::google::protobuf::Descriptor* descriptor() {
4721     return GetDescriptor();
4722   }
4723   static const ::google::protobuf::Descriptor* GetDescriptor() {
4724     return default_instance().GetMetadata().descriptor;
4725   }
4726   static const ::google::protobuf::Reflection* GetReflection() {
4727     return default_instance().GetMetadata().reflection;
4728   }
4729   static const GraphProto& default_instance() {
4730     return *internal_default_instance();
4731   }
4732   static inline const GraphProto* internal_default_instance() {
4733     return reinterpret_cast<const GraphProto*>(
4734         &_GraphProto_default_instance_);
4735   }
4736   static constexpr int kIndexInFileMessages = 7;
4737   friend void swap(GraphProto& a, GraphProto& b) { a.Swap(&b); }
4738   inline void Swap(GraphProto* other) {
4739     if (other == this) return;
4740 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4741     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
4742 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
4743     if (GetArena() == other->GetArena()) {
4744 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4745       InternalSwap(other);
4746     } else {
4747       ::google::protobuf::internal::GenericSwap(this, other);
4748     }
4749   }
4750   void UnsafeArenaSwap(GraphProto* other) {
4751     if (other == this) return;
4752     ABSL_DCHECK(GetArena() == other->GetArena());
4753     InternalSwap(other);
4754   }
4755
4756   // implements Message ----------------------------------------------
4757
4758   GraphProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
4759     return ::google::protobuf::Message::DefaultConstruct<GraphProto>(arena);
4760   }
4761   using ::google::protobuf::Message::CopyFrom;
4762   void CopyFrom(const GraphProto& from);
4763   using ::google::protobuf::Message::MergeFrom;
4764   void MergeFrom(const GraphProto& from) { GraphProto::MergeImpl(*this, from); }
4765
4766   private:
4767   static void MergeImpl(
4768       ::google::protobuf::MessageLite& to_msg,
4769       const ::google::protobuf::MessageLite& from_msg);
4770
4771   public:
4772   bool IsInitialized() const {
4773     return true;
4774   }
4775   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
4776   #if defined(PROTOBUF_CUSTOM_VTABLE)
4777   private:
4778   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4779   static ::uint8_t* _InternalSerialize(
4780       const MessageLite& msg, ::uint8_t* target,
4781       ::google::protobuf::io::EpsCopyOutputStream* stream);
4782
4783   public:
4784   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4785   ::uint8_t* _InternalSerialize(
4786       ::uint8_t* target,
4787       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
4788     return _InternalSerialize(*this, target, stream);
4789   }
4790   #else   // PROTOBUF_CUSTOM_VTABLE
4791   ::size_t ByteSizeLong() const final;
4792   ::uint8_t* _InternalSerialize(
4793       ::uint8_t* target,
4794       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
4795   #endif  // PROTOBUF_CUSTOM_VTABLE
4796   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4797
4798   private:
4799   void SharedCtor(::google::protobuf::Arena* arena);
4800   void SharedDtor();
4801   void InternalSwap(GraphProto* other);
4802  private:
4803   friend class ::google::protobuf::internal::AnyMetadata;
4804   static ::absl::string_view FullMessageName() { return "onnx.GraphProto"; }
4805
4806  protected:
4807   explicit GraphProto(::google::protobuf::Arena* arena);
4808   GraphProto(::google::protobuf::Arena* arena, const GraphProto& from);
4809   GraphProto(::google::protobuf::Arena* arena, GraphProto&& from) noexcept
4810       : GraphProto(arena) {
4811     *this = ::std::move(from);
4812   }
4813   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
4814   static const ::google::protobuf::Message::ClassDataFull _class_data_;
4815
4816  public:
4817   ::google::protobuf::Metadata GetMetadata() const;
4818   // nested types ----------------------------------------------------
4819
4820   // accessors -------------------------------------------------------
4821   enum : int {
4822     kNodeFieldNumber = 1,
4823     kInitializerFieldNumber = 5,
4824     kInputFieldNumber = 11,
4825     kOutputFieldNumber = 12,
4826     kValueInfoFieldNumber = 13,
4827     kQuantizationAnnotationFieldNumber = 14,
4828     kSparseInitializerFieldNumber = 15,
4829     kMetadataPropsFieldNumber = 16,
4830     kNameFieldNumber = 2,
4831     kDocStringFieldNumber = 10,
4832   };
4833   // repeated .onnx.NodeProto node = 1;
4834   int node_size() const;
4835   private:
4836   int _internal_node_size() const;
4837
4838   public:
4839   void clear_node() ;
4840   ::onnx::NodeProto* mutable_node(int index);
4841   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* mutable_node();
4842
4843   private:
4844   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
4845   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* _internal_mutable_node();
4846   public:
4847   const ::onnx::NodeProto& node(int index) const;
4848   ::onnx::NodeProto* add_node();
4849   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
4850   // repeated .onnx.TensorProto initializer = 5;
4851   int initializer_size() const;
4852   private:
4853   int _internal_initializer_size() const;
4854
4855   public:
4856   void clear_initializer() ;
4857   ::onnx::TensorProto* mutable_initializer(int index);
4858   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* mutable_initializer();
4859
4860   private:
4861   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_initializer() const;
4862   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* _internal_mutable_initializer();
4863   public:
4864   const ::onnx::TensorProto& initializer(int index) const;
4865   ::onnx::TensorProto* add_initializer();
4866   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& initializer() const;
4867   // repeated .onnx.ValueInfoProto input = 11;
4868   int input_size() const;
4869   private:
4870   int _internal_input_size() const;
4871
4872   public:
4873   void clear_input() ;
4874   ::onnx::ValueInfoProto* mutable_input(int index);
4875   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_input();
4876
4877   private:
4878   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_input() const;
4879   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_input();
4880   public:
4881   const ::onnx::ValueInfoProto& input(int index) const;
4882   ::onnx::ValueInfoProto* add_input();
4883   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& input() const;
4884   // repeated .onnx.ValueInfoProto output = 12;
4885   int output_size() const;
4886   private:
4887   int _internal_output_size() const;
4888
4889   public:
4890   void clear_output() ;
4891   ::onnx::ValueInfoProto* mutable_output(int index);
4892   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_output();
4893
4894   private:
4895   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_output() const;
4896   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_output();
4897   public:
4898   const ::onnx::ValueInfoProto& output(int index) const;
4899   ::onnx::ValueInfoProto* add_output();
4900   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& output() const;
4901   // repeated .onnx.ValueInfoProto value_info = 13;
4902   int value_info_size() const;
4903   private:
4904   int _internal_value_info_size() const;
4905
4906   public:
4907   void clear_value_info() ;
4908   ::onnx::ValueInfoProto* mutable_value_info(int index);
4909   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_value_info();
4910
4911   private:
4912   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
4913   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_value_info();
4914   public:
4915   const ::onnx::ValueInfoProto& value_info(int index) const;
4916   ::onnx::ValueInfoProto* add_value_info();
4917   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info() const;
4918   // repeated .onnx.TensorAnnotation quantization_annotation = 14;
4919   int quantization_annotation_size() const;
4920   private:
4921   int _internal_quantization_annotation_size() const;
4922
4923   public:
4924   void clear_quantization_annotation() ;
4925   ::onnx::TensorAnnotation* mutable_quantization_annotation(int index);
4926   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* mutable_quantization_annotation();
4927
4928   private:
4929   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& _internal_quantization_annotation() const;
4930   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* _internal_mutable_quantization_annotation();
4931   public:
4932   const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
4933   ::onnx::TensorAnnotation* add_quantization_annotation();
4934   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& quantization_annotation() const;
4935   // repeated .onnx.SparseTensorProto sparse_initializer = 15;
4936   int sparse_initializer_size() const;
4937   private:
4938   int _internal_sparse_initializer_size() const;
4939
4940   public:
4941   void clear_sparse_initializer() ;
4942   ::onnx::SparseTensorProto* mutable_sparse_initializer(int index);
4943   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* mutable_sparse_initializer();
4944
4945   private:
4946   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_initializer() const;
4947   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* _internal_mutable_sparse_initializer();
4948   public:
4949   const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
4950   ::onnx::SparseTensorProto* add_sparse_initializer();
4951   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_initializer() const;
4952   // repeated .onnx.StringStringEntryProto metadata_props = 16;
4953   int metadata_props_size() const;
4954   private:
4955   int _internal_metadata_props_size() const;
4956
4957   public:
4958   void clear_metadata_props() ;
4959   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
4960   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
4961
4962   private:
4963   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
4964   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
4965   public:
4966   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
4967   ::onnx::StringStringEntryProto* add_metadata_props();
4968   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
4969   // optional string name = 2;
4970   bool has_name() const;
4971   void clear_name() ;
4972   const std::string& name() const;
4973   template <typename Arg_ = const std::string&, typename... Args_>
4974   void set_name(Arg_&& arg, Args_... args);
4975   std::string* mutable_name();
4976   PROTOBUF_NODISCARD std::string* release_name();
4977   void set_allocated_name(std::string* value);
4978
4979   private:
4980   const std::string& _internal_name() const;
4981   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
4982       const std::string& value);
4983   std::string* _internal_mutable_name();
4984
4985   public:
4986   // optional string doc_string = 10;
4987   bool has_doc_string() const;
4988   void clear_doc_string() ;
4989   const std::string& doc_string() const;
4990   template <typename Arg_ = const std::string&, typename... Args_>
4991   void set_doc_string(Arg_&& arg, Args_... args);
4992   std::string* mutable_doc_string();
4993   PROTOBUF_NODISCARD std::string* release_doc_string();
4994   void set_allocated_doc_string(std::string* value);
4995
4996   private:
4997   const std::string& _internal_doc_string() const;
4998   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
4999       const std::string& value);
5000   std::string* _internal_mutable_doc_string();
5001
5002   public:
5003   // @@protoc_insertion_point(class_scope:onnx.GraphProto)
5004  private:
5005   class _Internal;
5006   friend class ::google::protobuf::internal::TcParser;
5007   static const ::google::protobuf::internal::TcParseTable<
5008       4, 10, 8,
5009       46, 2>
5010       _table_;
5011
5012
5013   friend class ::google::protobuf::MessageLite;
5014   friend class ::google::protobuf::Arena;
5015   template <typename T>
5016   friend class ::google::protobuf::Arena::InternalHelper;
5017   using InternalArenaConstructable_ = void;
5018   using DestructorSkippable_ = void;
5019   struct Impl_ {
5020     inline explicit constexpr Impl_(
5021         ::google::protobuf::internal::ConstantInitialized) noexcept;
5022     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5023                           ::google::protobuf::Arena* arena);
5024     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5025                           ::google::protobuf::Arena* arena, const Impl_& from,
5026                           const GraphProto& from_msg);
5027     ::google::protobuf::internal::HasBits<1> _has_bits_;
5028     mutable ::google::protobuf::internal::CachedSize _cached_size_;
5029     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
5030     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > initializer_;
5031     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
5032     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
5033     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
5034     ::google::protobuf::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
5035     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
5036     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
5037     ::google::protobuf::internal::ArenaStringPtr name_;
5038     ::google::protobuf::internal::ArenaStringPtr doc_string_;
5039     PROTOBUF_TSAN_DECLARE_MEMBER
5040   };
5041   union { Impl_ _impl_; };
5042   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5043 };
5044 // -------------------------------------------------------------------
5045
5046 class ONNX_API NodeProto final : public ::google::protobuf::Message
5047 /* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
5048  public:
5049   inline NodeProto() : NodeProto(nullptr) {}
5050   ~NodeProto() PROTOBUF_FINAL;
5051   template <typename = void>
5052   explicit PROTOBUF_CONSTEXPR NodeProto(
5053       ::google::protobuf::internal::ConstantInitialized);
5054
5055   inline NodeProto(const NodeProto& from) : NodeProto(nullptr, from) {}
5056   inline NodeProto(NodeProto&& from) noexcept
5057       : NodeProto(nullptr, std::move(from)) {}
5058   inline NodeProto& operator=(const NodeProto& from) {
5059     CopyFrom(from);
5060     return *this;
5061   }
5062   inline NodeProto& operator=(NodeProto&& from) noexcept {
5063     if (this == &from) return *this;
5064     if (GetArena() == from.GetArena()
5065 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5066         && GetArena() != nullptr
5067 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5068     ) {
5069       InternalSwap(&from);
5070     } else {
5071       CopyFrom(from);
5072     }
5073     return *this;
5074   }
5075
5076   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5077       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5078     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5079   }
5080   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
5081       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5082     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5083   }
5084
5085   static const ::google::protobuf::Descriptor* descriptor() {
5086     return GetDescriptor();
5087   }
5088   static const ::google::protobuf::Descriptor* GetDescriptor() {
5089     return default_instance().GetMetadata().descriptor;
5090   }
5091   static const ::google::protobuf::Reflection* GetReflection() {
5092     return default_instance().GetMetadata().reflection;
5093   }
5094   static const NodeProto& default_instance() {
5095     return *internal_default_instance();
5096   }
5097   static inline const NodeProto* internal_default_instance() {
5098     return reinterpret_cast<const NodeProto*>(
5099         &_NodeProto_default_instance_);
5100   }
5101   static constexpr int kIndexInFileMessages = 2;
5102   friend void swap(NodeProto& a, NodeProto& b) { a.Swap(&b); }
5103   inline void Swap(NodeProto* other) {
5104     if (other == this) return;
5105 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5106     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
5107 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
5108     if (GetArena() == other->GetArena()) {
5109 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5110       InternalSwap(other);
5111     } else {
5112       ::google::protobuf::internal::GenericSwap(this, other);
5113     }
5114   }
5115   void UnsafeArenaSwap(NodeProto* other) {
5116     if (other == this) return;
5117     ABSL_DCHECK(GetArena() == other->GetArena());
5118     InternalSwap(other);
5119   }
5120
5121   // implements Message ----------------------------------------------
5122
5123   NodeProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
5124     return ::google::protobuf::Message::DefaultConstruct<NodeProto>(arena);
5125   }
5126   using ::google::protobuf::Message::CopyFrom;
5127   void CopyFrom(const NodeProto& from);
5128   using ::google::protobuf::Message::MergeFrom;
5129   void MergeFrom(const NodeProto& from) { NodeProto::MergeImpl(*this, from); }
5130
5131   private:
5132   static void MergeImpl(
5133       ::google::protobuf::MessageLite& to_msg,
5134       const ::google::protobuf::MessageLite& from_msg);
5135
5136   public:
5137   bool IsInitialized() const {
5138     return true;
5139   }
5140   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5141   #if defined(PROTOBUF_CUSTOM_VTABLE)
5142   private:
5143   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5144   static ::uint8_t* _InternalSerialize(
5145       const MessageLite& msg, ::uint8_t* target,
5146       ::google::protobuf::io::EpsCopyOutputStream* stream);
5147
5148   public:
5149   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5150   ::uint8_t* _InternalSerialize(
5151       ::uint8_t* target,
5152       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
5153     return _InternalSerialize(*this, target, stream);
5154   }
5155   #else   // PROTOBUF_CUSTOM_VTABLE
5156   ::size_t ByteSizeLong() const final;
5157   ::uint8_t* _InternalSerialize(
5158       ::uint8_t* target,
5159       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
5160   #endif  // PROTOBUF_CUSTOM_VTABLE
5161   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5162
5163   private:
5164   void SharedCtor(::google::protobuf::Arena* arena);
5165   void SharedDtor();
5166   void InternalSwap(NodeProto* other);
5167  private:
5168   friend class ::google::protobuf::internal::AnyMetadata;
5169   static ::absl::string_view FullMessageName() { return "onnx.NodeProto"; }
5170
5171  protected:
5172   explicit NodeProto(::google::protobuf::Arena* arena);
5173   NodeProto(::google::protobuf::Arena* arena, const NodeProto& from);
5174   NodeProto(::google::protobuf::Arena* arena, NodeProto&& from) noexcept
5175       : NodeProto(arena) {
5176     *this = ::std::move(from);
5177   }
5178   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
5179   static const ::google::protobuf::Message::ClassDataFull _class_data_;
5180
5181  public:
5182   ::google::protobuf::Metadata GetMetadata() const;
5183   // nested types ----------------------------------------------------
5184
5185   // accessors -------------------------------------------------------
5186   enum : int {
5187     kInputFieldNumber = 1,
5188     kOutputFieldNumber = 2,
5189     kAttributeFieldNumber = 5,
5190     kMetadataPropsFieldNumber = 9,
5191     kNameFieldNumber = 3,
5192     kOpTypeFieldNumber = 4,
5193     kDocStringFieldNumber = 6,
5194     kDomainFieldNumber = 7,
5195     kOverloadFieldNumber = 8,
5196   };
5197   // repeated string input = 1;
5198   int input_size() const;
5199   private:
5200   int _internal_input_size() const;
5201
5202   public:
5203   void clear_input() ;
5204   const std::string& input(int index) const;
5205   std::string* mutable_input(int index);
5206   template <typename Arg_ = const std::string&, typename... Args_>
5207   void set_input(int index, Arg_&& value, Args_... args);
5208   std::string* add_input();
5209   template <typename Arg_ = const std::string&, typename... Args_>
5210   void add_input(Arg_&& value, Args_... args);
5211   const ::google::protobuf::RepeatedPtrField<std::string>& input() const;
5212   ::google::protobuf::RepeatedPtrField<std::string>* mutable_input();
5213
5214   private:
5215   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_input() const;
5216   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_input();
5217
5218   public:
5219   // repeated string output = 2;
5220   int output_size() const;
5221   private:
5222   int _internal_output_size() const;
5223
5224   public:
5225   void clear_output() ;
5226   const std::string& output(int index) const;
5227   std::string* mutable_output(int index);
5228   template <typename Arg_ = const std::string&, typename... Args_>
5229   void set_output(int index, Arg_&& value, Args_... args);
5230   std::string* add_output();
5231   template <typename Arg_ = const std::string&, typename... Args_>
5232   void add_output(Arg_&& value, Args_... args);
5233   const ::google::protobuf::RepeatedPtrField<std::string>& output() const;
5234   ::google::protobuf::RepeatedPtrField<std::string>* mutable_output();
5235
5236   private:
5237   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_output() const;
5238   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_output();
5239
5240   public:
5241   // repeated .onnx.AttributeProto attribute = 5;
5242   int attribute_size() const;
5243   private:
5244   int _internal_attribute_size() const;
5245
5246   public:
5247   void clear_attribute() ;
5248   ::onnx::AttributeProto* mutable_attribute(int index);
5249   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* mutable_attribute();
5250
5251   private:
5252   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute() const;
5253   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* _internal_mutable_attribute();
5254   public:
5255   const ::onnx::AttributeProto& attribute(int index) const;
5256   ::onnx::AttributeProto* add_attribute();
5257   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute() const;
5258   // repeated .onnx.StringStringEntryProto metadata_props = 9;
5259   int metadata_props_size() const;
5260   private:
5261   int _internal_metadata_props_size() const;
5262
5263   public:
5264   void clear_metadata_props() ;
5265   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
5266   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
5267
5268   private:
5269   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
5270   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
5271   public:
5272   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
5273   ::onnx::StringStringEntryProto* add_metadata_props();
5274   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
5275   // optional string name = 3;
5276   bool has_name() const;
5277   void clear_name() ;
5278   const std::string& name() const;
5279   template <typename Arg_ = const std::string&, typename... Args_>
5280   void set_name(Arg_&& arg, Args_... args);
5281   std::string* mutable_name();
5282   PROTOBUF_NODISCARD std::string* release_name();
5283   void set_allocated_name(std::string* value);
5284
5285   private:
5286   const std::string& _internal_name() const;
5287   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
5288       const std::string& value);
5289   std::string* _internal_mutable_name();
5290
5291   public:
5292   // optional string op_type = 4;
5293   bool has_op_type() const;
5294   void clear_op_type() ;
5295   const std::string& op_type() const;
5296   template <typename Arg_ = const std::string&, typename... Args_>
5297   void set_op_type(Arg_&& arg, Args_... args);
5298   std::string* mutable_op_type();
5299   PROTOBUF_NODISCARD std::string* release_op_type();
5300   void set_allocated_op_type(std::string* value);
5301
5302   private:
5303   const std::string& _internal_op_type() const;
5304   inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(
5305       const std::string& value);
5306   std::string* _internal_mutable_op_type();
5307
5308   public:
5309   // optional string doc_string = 6;
5310   bool has_doc_string() const;
5311   void clear_doc_string() ;
5312   const std::string& doc_string() const;
5313   template <typename Arg_ = const std::string&, typename... Args_>
5314   void set_doc_string(Arg_&& arg, Args_... args);
5315   std::string* mutable_doc_string();
5316   PROTOBUF_NODISCARD std::string* release_doc_string();
5317   void set_allocated_doc_string(std::string* value);
5318
5319   private:
5320   const std::string& _internal_doc_string() const;
5321   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
5322       const std::string& value);
5323   std::string* _internal_mutable_doc_string();
5324
5325   public:
5326   // optional string domain = 7;
5327   bool has_domain() const;
5328   void clear_domain() ;
5329   const std::string& domain() const;
5330   template <typename Arg_ = const std::string&, typename... Args_>
5331   void set_domain(Arg_&& arg, Args_... args);
5332   std::string* mutable_domain();
5333   PROTOBUF_NODISCARD std::string* release_domain();
5334   void set_allocated_domain(std::string* value);
5335
5336   private:
5337   const std::string& _internal_domain() const;
5338   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
5339       const std::string& value);
5340   std::string* _internal_mutable_domain();
5341
5342   public:
5343   // optional string overload = 8;
5344   bool has_overload() const;
5345   void clear_overload() ;
5346   const std::string& overload() const;
5347   template <typename Arg_ = const std::string&, typename... Args_>
5348   void set_overload(Arg_&& arg, Args_... args);
5349   std::string* mutable_overload();
5350   PROTOBUF_NODISCARD std::string* release_overload();
5351   void set_allocated_overload(std::string* value);
5352
5353   private:
5354   const std::string& _internal_overload() const;
5355   inline PROTOBUF_ALWAYS_INLINE void _internal_set_overload(
5356       const std::string& value);
5357   std::string* _internal_mutable_overload();
5358
5359   public:
5360   // @@protoc_insertion_point(class_scope:onnx.NodeProto)
5361  private:
5362   class _Internal;
5363   friend class ::google::protobuf::internal::TcParser;
5364   static const ::google::protobuf::internal::TcParseTable<
5365       4, 9, 2,
5366       77, 2>
5367       _table_;
5368
5369
5370   friend class ::google::protobuf::MessageLite;
5371   friend class ::google::protobuf::Arena;
5372   template <typename T>
5373   friend class ::google::protobuf::Arena::InternalHelper;
5374   using InternalArenaConstructable_ = void;
5375   using DestructorSkippable_ = void;
5376   struct Impl_ {
5377     inline explicit constexpr Impl_(
5378         ::google::protobuf::internal::ConstantInitialized) noexcept;
5379     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5380                           ::google::protobuf::Arena* arena);
5381     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5382                           ::google::protobuf::Arena* arena, const Impl_& from,
5383                           const NodeProto& from_msg);
5384     ::google::protobuf::internal::HasBits<1> _has_bits_;
5385     mutable ::google::protobuf::internal::CachedSize _cached_size_;
5386     ::google::protobuf::RepeatedPtrField<std::string> input_;
5387     ::google::protobuf::RepeatedPtrField<std::string> output_;
5388     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
5389     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
5390     ::google::protobuf::internal::ArenaStringPtr name_;
5391     ::google::protobuf::internal::ArenaStringPtr op_type_;
5392     ::google::protobuf::internal::ArenaStringPtr doc_string_;
5393     ::google::protobuf::internal::ArenaStringPtr domain_;
5394     ::google::protobuf::internal::ArenaStringPtr overload_;
5395     PROTOBUF_TSAN_DECLARE_MEMBER
5396   };
5397   union { Impl_ _impl_; };
5398   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5399 };
5400 // -------------------------------------------------------------------
5401
5402 class ONNX_API TrainingInfoProto final : public ::google::protobuf::Message
5403 /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
5404  public:
5405   inline TrainingInfoProto() : TrainingInfoProto(nullptr) {}
5406   ~TrainingInfoProto() PROTOBUF_FINAL;
5407   template <typename = void>
5408   explicit PROTOBUF_CONSTEXPR TrainingInfoProto(
5409       ::google::protobuf::internal::ConstantInitialized);
5410
5411   inline TrainingInfoProto(const TrainingInfoProto& from) : TrainingInfoProto(nullptr, from) {}
5412   inline TrainingInfoProto(TrainingInfoProto&& from) noexcept
5413       : TrainingInfoProto(nullptr, std::move(from)) {}
5414   inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
5415     CopyFrom(from);
5416     return *this;
5417   }
5418   inline TrainingInfoProto& operator=(TrainingInfoProto&& from) noexcept {
5419     if (this == &from) return *this;
5420     if (GetArena() == from.GetArena()
5421 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5422         && GetArena() != nullptr
5423 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5424     ) {
5425       InternalSwap(&from);
5426     } else {
5427       CopyFrom(from);
5428     }
5429     return *this;
5430   }
5431
5432   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5433       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5434     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5435   }
5436   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
5437       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5438     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5439   }
5440
5441   static const ::google::protobuf::Descriptor* descriptor() {
5442     return GetDescriptor();
5443   }
5444   static const ::google::protobuf::Descriptor* GetDescriptor() {
5445     return default_instance().GetMetadata().descriptor;
5446   }
5447   static const ::google::protobuf::Reflection* GetReflection() {
5448     return default_instance().GetMetadata().reflection;
5449   }
5450   static const TrainingInfoProto& default_instance() {
5451     return *internal_default_instance();
5452   }
5453   static inline const TrainingInfoProto* internal_default_instance() {
5454     return reinterpret_cast<const TrainingInfoProto*>(
5455         &_TrainingInfoProto_default_instance_);
5456   }
5457   static constexpr int kIndexInFileMessages = 3;
5458   friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) { a.Swap(&b); }
5459   inline void Swap(TrainingInfoProto* other) {
5460     if (other == this) return;
5461 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5462     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
5463 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
5464     if (GetArena() == other->GetArena()) {
5465 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5466       InternalSwap(other);
5467     } else {
5468       ::google::protobuf::internal::GenericSwap(this, other);
5469     }
5470   }
5471   void UnsafeArenaSwap(TrainingInfoProto* other) {
5472     if (other == this) return;
5473     ABSL_DCHECK(GetArena() == other->GetArena());
5474     InternalSwap(other);
5475   }
5476
5477   // implements Message ----------------------------------------------
5478
5479   TrainingInfoProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
5480     return ::google::protobuf::Message::DefaultConstruct<TrainingInfoProto>(arena);
5481   }
5482   using ::google::protobuf::Message::CopyFrom;
5483   void CopyFrom(const TrainingInfoProto& from);
5484   using ::google::protobuf::Message::MergeFrom;
5485   void MergeFrom(const TrainingInfoProto& from) { TrainingInfoProto::MergeImpl(*this, from); }
5486
5487   private:
5488   static void MergeImpl(
5489       ::google::protobuf::MessageLite& to_msg,
5490       const ::google::protobuf::MessageLite& from_msg);
5491
5492   public:
5493   bool IsInitialized() const {
5494     return true;
5495   }
5496   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5497   #if defined(PROTOBUF_CUSTOM_VTABLE)
5498   private:
5499   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5500   static ::uint8_t* _InternalSerialize(
5501       const MessageLite& msg, ::uint8_t* target,
5502       ::google::protobuf::io::EpsCopyOutputStream* stream);
5503
5504   public:
5505   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5506   ::uint8_t* _InternalSerialize(
5507       ::uint8_t* target,
5508       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
5509     return _InternalSerialize(*this, target, stream);
5510   }
5511   #else   // PROTOBUF_CUSTOM_VTABLE
5512   ::size_t ByteSizeLong() const final;
5513   ::uint8_t* _InternalSerialize(
5514       ::uint8_t* target,
5515       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
5516   #endif  // PROTOBUF_CUSTOM_VTABLE
5517   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5518
5519   private:
5520   void SharedCtor(::google::protobuf::Arena* arena);
5521   void SharedDtor();
5522   void InternalSwap(TrainingInfoProto* other);
5523  private:
5524   friend class ::google::protobuf::internal::AnyMetadata;
5525   static ::absl::string_view FullMessageName() { return "onnx.TrainingInfoProto"; }
5526
5527  protected:
5528   explicit TrainingInfoProto(::google::protobuf::Arena* arena);
5529   TrainingInfoProto(::google::protobuf::Arena* arena, const TrainingInfoProto& from);
5530   TrainingInfoProto(::google::protobuf::Arena* arena, TrainingInfoProto&& from) noexcept
5531       : TrainingInfoProto(arena) {
5532     *this = ::std::move(from);
5533   }
5534   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
5535   static const ::google::protobuf::Message::ClassDataFull _class_data_;
5536
5537  public:
5538   ::google::protobuf::Metadata GetMetadata() const;
5539   // nested types ----------------------------------------------------
5540
5541   // accessors -------------------------------------------------------
5542   enum : int {
5543     kInitializationBindingFieldNumber = 3,
5544     kUpdateBindingFieldNumber = 4,
5545     kInitializationFieldNumber = 1,
5546     kAlgorithmFieldNumber = 2,
5547   };
5548   // repeated .onnx.StringStringEntryProto initialization_binding = 3;
5549   int initialization_binding_size() const;
5550   private:
5551   int _internal_initialization_binding_size() const;
5552
5553   public:
5554   void clear_initialization_binding() ;
5555   ::onnx::StringStringEntryProto* mutable_initialization_binding(int index);
5556   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_initialization_binding();
5557
5558   private:
5559   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_initialization_binding() const;
5560   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_initialization_binding();
5561   public:
5562   const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
5563   ::onnx::StringStringEntryProto* add_initialization_binding();
5564   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& initialization_binding() const;
5565   // repeated .onnx.StringStringEntryProto update_binding = 4;
5566   int update_binding_size() const;
5567   private:
5568   int _internal_update_binding_size() const;
5569
5570   public:
5571   void clear_update_binding() ;
5572   ::onnx::StringStringEntryProto* mutable_update_binding(int index);
5573   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_update_binding();
5574
5575   private:
5576   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_update_binding() const;
5577   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_update_binding();
5578   public:
5579   const ::onnx::StringStringEntryProto& update_binding(int index) const;
5580   ::onnx::StringStringEntryProto* add_update_binding();
5581   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& update_binding() const;
5582   // optional .onnx.GraphProto initialization = 1;
5583   bool has_initialization() const;
5584   void clear_initialization() ;
5585   const ::onnx::GraphProto& initialization() const;
5586   PROTOBUF_NODISCARD ::onnx::GraphProto* release_initialization();
5587   ::onnx::GraphProto* mutable_initialization();
5588   void set_allocated_initialization(::onnx::GraphProto* value);
5589   void unsafe_arena_set_allocated_initialization(::onnx::GraphProto* value);
5590   ::onnx::GraphProto* unsafe_arena_release_initialization();
5591
5592   private:
5593   const ::onnx::GraphProto& _internal_initialization() const;
5594   ::onnx::GraphProto* _internal_mutable_initialization();
5595
5596   public:
5597   // optional .onnx.GraphProto algorithm = 2;
5598   bool has_algorithm() const;
5599   void clear_algorithm() ;
5600   const ::onnx::GraphProto& algorithm() const;
5601   PROTOBUF_NODISCARD ::onnx::GraphProto* release_algorithm();
5602   ::onnx::GraphProto* mutable_algorithm();
5603   void set_allocated_algorithm(::onnx::GraphProto* value);
5604   void unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* value);
5605   ::onnx::GraphProto* unsafe_arena_release_algorithm();
5606
5607   private:
5608   const ::onnx::GraphProto& _internal_algorithm() const;
5609   ::onnx::GraphProto* _internal_mutable_algorithm();
5610
5611   public:
5612   // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
5613  private:
5614   class _Internal;
5615   friend class ::google::protobuf::internal::TcParser;
5616   static const ::google::protobuf::internal::TcParseTable<
5617       2, 4, 4,
5618       0, 2>
5619       _table_;
5620
5621
5622   friend class ::google::protobuf::MessageLite;
5623   friend class ::google::protobuf::Arena;
5624   template <typename T>
5625   friend class ::google::protobuf::Arena::InternalHelper;
5626   using InternalArenaConstructable_ = void;
5627   using DestructorSkippable_ = void;
5628   struct Impl_ {
5629     inline explicit constexpr Impl_(
5630         ::google::protobuf::internal::ConstantInitialized) noexcept;
5631     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5632                           ::google::protobuf::Arena* arena);
5633     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
5634                           ::google::protobuf::Arena* arena, const Impl_& from,
5635                           const TrainingInfoProto& from_msg);
5636     ::google::protobuf::internal::HasBits<1> _has_bits_;
5637     mutable ::google::protobuf::internal::CachedSize _cached_size_;
5638     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
5639     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
5640     ::onnx::GraphProto* initialization_;
5641     ::onnx::GraphProto* algorithm_;
5642     PROTOBUF_TSAN_DECLARE_MEMBER
5643   };
5644   union { Impl_ _impl_; };
5645   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5646 };
5647 // -------------------------------------------------------------------
5648
5649 class ONNX_API FunctionProto final : public ::google::protobuf::Message
5650 /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
5651  public:
5652   inline FunctionProto() : FunctionProto(nullptr) {}
5653   ~FunctionProto() PROTOBUF_FINAL;
5654   template <typename = void>
5655   explicit PROTOBUF_CONSTEXPR FunctionProto(
5656       ::google::protobuf::internal::ConstantInitialized);
5657
5658   inline FunctionProto(const FunctionProto& from) : FunctionProto(nullptr, from) {}
5659   inline FunctionProto(FunctionProto&& from) noexcept
5660       : FunctionProto(nullptr, std::move(from)) {}
5661   inline FunctionProto& operator=(const FunctionProto& from) {
5662     CopyFrom(from);
5663     return *this;
5664   }
5665   inline FunctionProto& operator=(FunctionProto&& from) noexcept {
5666     if (this == &from) return *this;
5667     if (GetArena() == from.GetArena()
5668 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5669         && GetArena() != nullptr
5670 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5671     ) {
5672       InternalSwap(&from);
5673     } else {
5674       CopyFrom(from);
5675     }
5676     return *this;
5677   }
5678
5679   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5680       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5681     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5682   }
5683   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
5684       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5685     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5686   }
5687
5688   static const ::google::protobuf::Descriptor* descriptor() {
5689     return GetDescriptor();
5690   }
5691   static const ::google::protobuf::Descriptor* GetDescriptor() {
5692     return default_instance().GetMetadata().descriptor;
5693   }
5694   static const ::google::protobuf::Reflection* GetReflection() {
5695     return default_instance().GetMetadata().reflection;
5696   }
5697   static const FunctionProto& default_instance() {
5698     return *internal_default_instance();
5699   }
5700   static inline const FunctionProto* internal_default_instance() {
5701     return reinterpret_cast<const FunctionProto*>(
5702         &_FunctionProto_default_instance_);
5703   }
5704   static constexpr int kIndexInFileMessages = 21;
5705   friend void swap(FunctionProto& a, FunctionProto& b) { a.Swap(&b); }
5706   inline void Swap(FunctionProto* other) {
5707     if (other == this) return;
5708 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5709     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
5710 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
5711     if (GetArena() == other->GetArena()) {
5712 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5713       InternalSwap(other);
5714     } else {
5715       ::google::protobuf::internal::GenericSwap(this, other);
5716     }
5717   }
5718   void UnsafeArenaSwap(FunctionProto* other) {
5719     if (other == this) return;
5720     ABSL_DCHECK(GetArena() == other->GetArena());
5721     InternalSwap(other);
5722   }
5723
5724   // implements Message ----------------------------------------------
5725
5726   FunctionProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
5727     return ::google::protobuf::Message::DefaultConstruct<FunctionProto>(arena);
5728   }
5729   using ::google::protobuf::Message::CopyFrom;
5730   void CopyFrom(const FunctionProto& from);
5731   using ::google::protobuf::Message::MergeFrom;
5732   void MergeFrom(const FunctionProto& from) { FunctionProto::MergeImpl(*this, from); }
5733
5734   private:
5735   static void MergeImpl(
5736       ::google::protobuf::MessageLite& to_msg,
5737       const ::google::protobuf::MessageLite& from_msg);
5738
5739   public:
5740   bool IsInitialized() const {
5741     return true;
5742   }
5743   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5744   #if defined(PROTOBUF_CUSTOM_VTABLE)
5745   private:
5746   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5747   static ::uint8_t* _InternalSerialize(
5748       const MessageLite& msg, ::uint8_t* target,
5749       ::google::protobuf::io::EpsCopyOutputStream* stream);
5750
5751   public:
5752   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5753   ::uint8_t* _InternalSerialize(
5754       ::uint8_t* target,
5755       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
5756     return _InternalSerialize(*this, target, stream);
5757   }
5758   #else   // PROTOBUF_CUSTOM_VTABLE
5759   ::size_t ByteSizeLong() const final;
5760   ::uint8_t* _InternalSerialize(
5761       ::uint8_t* target,
5762       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
5763   #endif  // PROTOBUF_CUSTOM_VTABLE
5764   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5765
5766   private:
5767   void SharedCtor(::google::protobuf::Arena* arena);
5768   void SharedDtor();
5769   void InternalSwap(FunctionProto* other);
5770  private:
5771   friend class ::google::protobuf::internal::AnyMetadata;
5772   static ::absl::string_view FullMessageName() { return "onnx.FunctionProto"; }
5773
5774  protected:
5775   explicit FunctionProto(::google::protobuf::Arena* arena);
5776   FunctionProto(::google::protobuf::Arena* arena, const FunctionProto& from);
5777   FunctionProto(::google::protobuf::Arena* arena, FunctionProto&& from) noexcept
5778       : FunctionProto(arena) {
5779     *this = ::std::move(from);
5780   }
5781   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
5782   static const ::google::protobuf::Message::ClassDataFull _class_data_;
5783
5784  public:
5785   ::google::protobuf::Metadata GetMetadata() const;
5786   // nested types ----------------------------------------------------
5787
5788   // accessors -------------------------------------------------------
5789   enum : int {
5790     kInputFieldNumber = 4,
5791     kOutputFieldNumber = 5,
5792     kAttributeFieldNumber = 6,
5793     kNodeFieldNumber = 7,
5794     kOpsetImportFieldNumber = 9,
5795     kAttributeProtoFieldNumber = 11,
5796     kValueInfoFieldNumber = 12,
5797     kMetadataPropsFieldNumber = 14,
5798     kNameFieldNumber = 1,
5799     kDocStringFieldNumber = 8,
5800     kDomainFieldNumber = 10,
5801     kOverloadFieldNumber = 13,
5802   };
5803   // repeated string input = 4;
5804   int input_size() const;
5805   private:
5806   int _internal_input_size() const;
5807
5808   public:
5809   void clear_input() ;
5810   const std::string& input(int index) const;
5811   std::string* mutable_input(int index);
5812   template <typename Arg_ = const std::string&, typename... Args_>
5813   void set_input(int index, Arg_&& value, Args_... args);
5814   std::string* add_input();
5815   template <typename Arg_ = const std::string&, typename... Args_>
5816   void add_input(Arg_&& value, Args_... args);
5817   const ::google::protobuf::RepeatedPtrField<std::string>& input() const;
5818   ::google::protobuf::RepeatedPtrField<std::string>* mutable_input();
5819
5820   private:
5821   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_input() const;
5822   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_input();
5823
5824   public:
5825   // repeated string output = 5;
5826   int output_size() const;
5827   private:
5828   int _internal_output_size() const;
5829
5830   public:
5831   void clear_output() ;
5832   const std::string& output(int index) const;
5833   std::string* mutable_output(int index);
5834   template <typename Arg_ = const std::string&, typename... Args_>
5835   void set_output(int index, Arg_&& value, Args_... args);
5836   std::string* add_output();
5837   template <typename Arg_ = const std::string&, typename... Args_>
5838   void add_output(Arg_&& value, Args_... args);
5839   const ::google::protobuf::RepeatedPtrField<std::string>& output() const;
5840   ::google::protobuf::RepeatedPtrField<std::string>* mutable_output();
5841
5842   private:
5843   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_output() const;
5844   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_output();
5845
5846   public:
5847   // repeated string attribute = 6;
5848   int attribute_size() const;
5849   private:
5850   int _internal_attribute_size() const;
5851
5852   public:
5853   void clear_attribute() ;
5854   const std::string& attribute(int index) const;
5855   std::string* mutable_attribute(int index);
5856   template <typename Arg_ = const std::string&, typename... Args_>
5857   void set_attribute(int index, Arg_&& value, Args_... args);
5858   std::string* add_attribute();
5859   template <typename Arg_ = const std::string&, typename... Args_>
5860   void add_attribute(Arg_&& value, Args_... args);
5861   const ::google::protobuf::RepeatedPtrField<std::string>& attribute() const;
5862   ::google::protobuf::RepeatedPtrField<std::string>* mutable_attribute();
5863
5864   private:
5865   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_attribute() const;
5866   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_attribute();
5867
5868   public:
5869   // repeated .onnx.NodeProto node = 7;
5870   int node_size() const;
5871   private:
5872   int _internal_node_size() const;
5873
5874   public:
5875   void clear_node() ;
5876   ::onnx::NodeProto* mutable_node(int index);
5877   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* mutable_node();
5878
5879   private:
5880   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
5881   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* _internal_mutable_node();
5882   public:
5883   const ::onnx::NodeProto& node(int index) const;
5884   ::onnx::NodeProto* add_node();
5885   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
5886   // repeated .onnx.OperatorSetIdProto opset_import = 9;
5887   int opset_import_size() const;
5888   private:
5889   int _internal_opset_import_size() const;
5890
5891   public:
5892   void clear_opset_import() ;
5893   ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
5894   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* mutable_opset_import();
5895
5896   private:
5897   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
5898   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* _internal_mutable_opset_import();
5899   public:
5900   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
5901   ::onnx::OperatorSetIdProto* add_opset_import();
5902   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
5903   // repeated .onnx.AttributeProto attribute_proto = 11;
5904   int attribute_proto_size() const;
5905   private:
5906   int _internal_attribute_proto_size() const;
5907
5908   public:
5909   void clear_attribute_proto() ;
5910   ::onnx::AttributeProto* mutable_attribute_proto(int index);
5911   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* mutable_attribute_proto();
5912
5913   private:
5914   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute_proto() const;
5915   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* _internal_mutable_attribute_proto();
5916   public:
5917   const ::onnx::AttributeProto& attribute_proto(int index) const;
5918   ::onnx::AttributeProto* add_attribute_proto();
5919   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute_proto() const;
5920   // repeated .onnx.ValueInfoProto value_info = 12;
5921   int value_info_size() const;
5922   private:
5923   int _internal_value_info_size() const;
5924
5925   public:
5926   void clear_value_info() ;
5927   ::onnx::ValueInfoProto* mutable_value_info(int index);
5928   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* mutable_value_info();
5929
5930   private:
5931   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
5932   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* _internal_mutable_value_info();
5933   public:
5934   const ::onnx::ValueInfoProto& value_info(int index) const;
5935   ::onnx::ValueInfoProto* add_value_info();
5936   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info() const;
5937   // repeated .onnx.StringStringEntryProto metadata_props = 14;
5938   int metadata_props_size() const;
5939   private:
5940   int _internal_metadata_props_size() const;
5941
5942   public:
5943   void clear_metadata_props() ;
5944   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
5945   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
5946
5947   private:
5948   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
5949   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
5950   public:
5951   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
5952   ::onnx::StringStringEntryProto* add_metadata_props();
5953   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
5954   // optional string name = 1;
5955   bool has_name() const;
5956   void clear_name() ;
5957   const std::string& name() const;
5958   template <typename Arg_ = const std::string&, typename... Args_>
5959   void set_name(Arg_&& arg, Args_... args);
5960   std::string* mutable_name();
5961   PROTOBUF_NODISCARD std::string* release_name();
5962   void set_allocated_name(std::string* value);
5963
5964   private:
5965   const std::string& _internal_name() const;
5966   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
5967       const std::string& value);
5968   std::string* _internal_mutable_name();
5969
5970   public:
5971   // optional string doc_string = 8;
5972   bool has_doc_string() const;
5973   void clear_doc_string() ;
5974   const std::string& doc_string() const;
5975   template <typename Arg_ = const std::string&, typename... Args_>
5976   void set_doc_string(Arg_&& arg, Args_... args);
5977   std::string* mutable_doc_string();
5978   PROTOBUF_NODISCARD std::string* release_doc_string();
5979   void set_allocated_doc_string(std::string* value);
5980
5981   private:
5982   const std::string& _internal_doc_string() const;
5983   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
5984       const std::string& value);
5985   std::string* _internal_mutable_doc_string();
5986
5987   public:
5988   // optional string domain = 10;
5989   bool has_domain() const;
5990   void clear_domain() ;
5991   const std::string& domain() const;
5992   template <typename Arg_ = const std::string&, typename... Args_>
5993   void set_domain(Arg_&& arg, Args_... args);
5994   std::string* mutable_domain();
5995   PROTOBUF_NODISCARD std::string* release_domain();
5996   void set_allocated_domain(std::string* value);
5997
5998   private:
5999   const std::string& _internal_domain() const;
6000   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
6001       const std::string& value);
6002   std::string* _internal_mutable_domain();
6003
6004   public:
6005   // optional string overload = 13;
6006   bool has_overload() const;
6007   void clear_overload() ;
6008   const std::string& overload() const;
6009   template <typename Arg_ = const std::string&, typename... Args_>
6010   void set_overload(Arg_&& arg, Args_... args);
6011   std::string* mutable_overload();
6012   PROTOBUF_NODISCARD std::string* release_overload();
6013   void set_allocated_overload(std::string* value);
6014
6015   private:
6016   const std::string& _internal_overload() const;
6017   inline PROTOBUF_ALWAYS_INLINE void _internal_set_overload(
6018       const std::string& value);
6019   std::string* _internal_mutable_overload();
6020
6021   public:
6022   // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
6023  private:
6024   class _Internal;
6025   friend class ::google::protobuf::internal::TcParser;
6026   static const ::google::protobuf::internal::TcParseTable<
6027       4, 12, 5,
6028       83, 2>
6029       _table_;
6030
6031
6032   friend class ::google::protobuf::MessageLite;
6033   friend class ::google::protobuf::Arena;
6034   template <typename T>
6035   friend class ::google::protobuf::Arena::InternalHelper;
6036   using InternalArenaConstructable_ = void;
6037   using DestructorSkippable_ = void;
6038   struct Impl_ {
6039     inline explicit constexpr Impl_(
6040         ::google::protobuf::internal::ConstantInitialized) noexcept;
6041     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
6042                           ::google::protobuf::Arena* arena);
6043     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
6044                           ::google::protobuf::Arena* arena, const Impl_& from,
6045                           const FunctionProto& from_msg);
6046     ::google::protobuf::internal::HasBits<1> _has_bits_;
6047     mutable ::google::protobuf::internal::CachedSize _cached_size_;
6048     ::google::protobuf::RepeatedPtrField<std::string> input_;
6049     ::google::protobuf::RepeatedPtrField<std::string> output_;
6050     ::google::protobuf::RepeatedPtrField<std::string> attribute_;
6051     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
6052     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
6053     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
6054     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
6055     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
6056     ::google::protobuf::internal::ArenaStringPtr name_;
6057     ::google::protobuf::internal::ArenaStringPtr doc_string_;
6058     ::google::protobuf::internal::ArenaStringPtr domain_;
6059     ::google::protobuf::internal::ArenaStringPtr overload_;
6060     PROTOBUF_TSAN_DECLARE_MEMBER
6061   };
6062   union { Impl_ _impl_; };
6063   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
6064 };
6065 // -------------------------------------------------------------------
6066
6067 class ONNX_API ModelProto final : public ::google::protobuf::Message
6068 /* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
6069  public:
6070   inline ModelProto() : ModelProto(nullptr) {}
6071   ~ModelProto() PROTOBUF_FINAL;
6072   template <typename = void>
6073   explicit PROTOBUF_CONSTEXPR ModelProto(
6074       ::google::protobuf::internal::ConstantInitialized);
6075
6076   inline ModelProto(const ModelProto& from) : ModelProto(nullptr, from) {}
6077   inline ModelProto(ModelProto&& from) noexcept
6078       : ModelProto(nullptr, std::move(from)) {}
6079   inline ModelProto& operator=(const ModelProto& from) {
6080     CopyFrom(from);
6081     return *this;
6082   }
6083   inline ModelProto& operator=(ModelProto&& from) noexcept {
6084     if (this == &from) return *this;
6085     if (GetArena() == from.GetArena()
6086 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
6087         && GetArena() != nullptr
6088 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
6089     ) {
6090       InternalSwap(&from);
6091     } else {
6092       CopyFrom(from);
6093     }
6094     return *this;
6095   }
6096
6097   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
6098       ABSL_ATTRIBUTE_LIFETIME_BOUND {
6099     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
6100   }
6101   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
6102       ABSL_ATTRIBUTE_LIFETIME_BOUND {
6103     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
6104   }
6105
6106   static const ::google::protobuf::Descriptor* descriptor() {
6107     return GetDescriptor();
6108   }
6109   static const ::google::protobuf::Descriptor* GetDescriptor() {
6110     return default_instance().GetMetadata().descriptor;
6111   }
6112   static const ::google::protobuf::Reflection* GetReflection() {
6113     return default_instance().GetMetadata().reflection;
6114   }
6115   static const ModelProto& default_instance() {
6116     return *internal_default_instance();
6117   }
6118   static inline const ModelProto* internal_default_instance() {
6119     return reinterpret_cast<const ModelProto*>(
6120         &_ModelProto_default_instance_);
6121   }
6122   static constexpr int kIndexInFileMessages = 4;
6123   friend void swap(ModelProto& a, ModelProto& b) { a.Swap(&b); }
6124   inline void Swap(ModelProto* other) {
6125     if (other == this) return;
6126 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
6127     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
6128 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
6129     if (GetArena() == other->GetArena()) {
6130 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
6131       InternalSwap(other);
6132     } else {
6133       ::google::protobuf::internal::GenericSwap(this, other);
6134     }
6135   }
6136   void UnsafeArenaSwap(ModelProto* other) {
6137     if (other == this) return;
6138     ABSL_DCHECK(GetArena() == other->GetArena());
6139     InternalSwap(other);
6140   }
6141
6142   // implements Message ----------------------------------------------
6143
6144   ModelProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
6145     return ::google::protobuf::Message::DefaultConstruct<ModelProto>(arena);
6146   }
6147   using ::google::protobuf::Message::CopyFrom;
6148   void CopyFrom(const ModelProto& from);
6149   using ::google::protobuf::Message::MergeFrom;
6150   void MergeFrom(const ModelProto& from) { ModelProto::MergeImpl(*this, from); }
6151
6152   private:
6153   static void MergeImpl(
6154       ::google::protobuf::MessageLite& to_msg,
6155       const ::google::protobuf::MessageLite& from_msg);
6156
6157   public:
6158   bool IsInitialized() const {
6159     return true;
6160   }
6161   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
6162   #if defined(PROTOBUF_CUSTOM_VTABLE)
6163   private:
6164   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
6165   static ::uint8_t* _InternalSerialize(
6166       const MessageLite& msg, ::uint8_t* target,
6167       ::google::protobuf::io::EpsCopyOutputStream* stream);
6168
6169   public:
6170   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
6171   ::uint8_t* _InternalSerialize(
6172       ::uint8_t* target,
6173       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
6174     return _InternalSerialize(*this, target, stream);
6175   }
6176   #else   // PROTOBUF_CUSTOM_VTABLE
6177   ::size_t ByteSizeLong() const final;
6178   ::uint8_t* _InternalSerialize(
6179       ::uint8_t* target,
6180       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
6181   #endif  // PROTOBUF_CUSTOM_VTABLE
6182   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
6183
6184   private:
6185   void SharedCtor(::google::protobuf::Arena* arena);
6186   void SharedDtor();
6187   void InternalSwap(ModelProto* other);
6188  private:
6189   friend class ::google::protobuf::internal::AnyMetadata;
6190   static ::absl::string_view FullMessageName() { return "onnx.ModelProto"; }
6191
6192  protected:
6193   explicit ModelProto(::google::protobuf::Arena* arena);
6194   ModelProto(::google::protobuf::Arena* arena, const ModelProto& from);
6195   ModelProto(::google::protobuf::Arena* arena, ModelProto&& from) noexcept
6196       : ModelProto(arena) {
6197     *this = ::std::move(from);
6198   }
6199   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
6200   static const ::google::protobuf::Message::ClassDataFull _class_data_;
6201
6202  public:
6203   ::google::protobuf::Metadata GetMetadata() const;
6204   // nested types ----------------------------------------------------
6205
6206   // accessors -------------------------------------------------------
6207   enum : int {
6208     kOpsetImportFieldNumber = 8,
6209     kMetadataPropsFieldNumber = 14,
6210     kTrainingInfoFieldNumber = 20,
6211     kFunctionsFieldNumber = 25,
6212     kProducerNameFieldNumber = 2,
6213     kProducerVersionFieldNumber = 3,
6214     kDomainFieldNumber = 4,
6215     kDocStringFieldNumber = 6,
6216     kGraphFieldNumber = 7,
6217     kIrVersionFieldNumber = 1,
6218     kModelVersionFieldNumber = 5,
6219   };
6220   // repeated .onnx.OperatorSetIdProto opset_import = 8;
6221   int opset_import_size() const;
6222   private:
6223   int _internal_opset_import_size() const;
6224
6225   public:
6226   void clear_opset_import() ;
6227   ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
6228   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* mutable_opset_import();
6229
6230   private:
6231   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
6232   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* _internal_mutable_opset_import();
6233   public:
6234   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
6235   ::onnx::OperatorSetIdProto* add_opset_import();
6236   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
6237   // repeated .onnx.StringStringEntryProto metadata_props = 14;
6238   int metadata_props_size() const;
6239   private:
6240   int _internal_metadata_props_size() const;
6241
6242   public:
6243   void clear_metadata_props() ;
6244   ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
6245   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* mutable_metadata_props();
6246
6247   private:
6248   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
6249   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* _internal_mutable_metadata_props();
6250   public:
6251   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
6252   ::onnx::StringStringEntryProto* add_metadata_props();
6253   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
6254   // repeated .onnx.TrainingInfoProto training_info = 20;
6255   int training_info_size() const;
6256   private:
6257   int _internal_training_info_size() const;
6258
6259   public:
6260   void clear_training_info() ;
6261   ::onnx::TrainingInfoProto* mutable_training_info(int index);
6262   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* mutable_training_info();
6263
6264   private:
6265   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& _internal_training_info() const;
6266   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* _internal_mutable_training_info();
6267   public:
6268   const ::onnx::TrainingInfoProto& training_info(int index) const;
6269   ::onnx::TrainingInfoProto* add_training_info();
6270   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& training_info() const;
6271   // repeated .onnx.FunctionProto functions = 25;
6272   int functions_size() const;
6273   private:
6274   int _internal_functions_size() const;
6275
6276   public:
6277   void clear_functions() ;
6278   ::onnx::FunctionProto* mutable_functions(int index);
6279   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* mutable_functions();
6280
6281   private:
6282   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& _internal_functions() const;
6283   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* _internal_mutable_functions();
6284   public:
6285   const ::onnx::FunctionProto& functions(int index) const;
6286   ::onnx::FunctionProto* add_functions();
6287   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& functions() const;
6288   // optional string producer_name = 2;
6289   bool has_producer_name() const;
6290   void clear_producer_name() ;
6291   const std::string& producer_name() const;
6292   template <typename Arg_ = const std::string&, typename... Args_>
6293   void set_producer_name(Arg_&& arg, Args_... args);
6294   std::string* mutable_producer_name();
6295   PROTOBUF_NODISCARD std::string* release_producer_name();
6296   void set_allocated_producer_name(std::string* value);
6297
6298   private:
6299   const std::string& _internal_producer_name() const;
6300   inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(
6301       const std::string& value);
6302   std::string* _internal_mutable_producer_name();
6303
6304   public:
6305   // optional string producer_version = 3;
6306   bool has_producer_version() const;
6307   void clear_producer_version() ;
6308   const std::string& producer_version() const;
6309   template <typename Arg_ = const std::string&, typename... Args_>
6310   void set_producer_version(Arg_&& arg, Args_... args);
6311   std::string* mutable_producer_version();
6312   PROTOBUF_NODISCARD std::string* release_producer_version();
6313   void set_allocated_producer_version(std::string* value);
6314
6315   private:
6316   const std::string& _internal_producer_version() const;
6317   inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(
6318       const std::string& value);
6319   std::string* _internal_mutable_producer_version();
6320
6321   public:
6322   // optional string domain = 4;
6323   bool has_domain() const;
6324   void clear_domain() ;
6325   const std::string& domain() const;
6326   template <typename Arg_ = const std::string&, typename... Args_>
6327   void set_domain(Arg_&& arg, Args_... args);
6328   std::string* mutable_domain();
6329   PROTOBUF_NODISCARD std::string* release_domain();
6330   void set_allocated_domain(std::string* value);
6331
6332   private:
6333   const std::string& _internal_domain() const;
6334   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
6335       const std::string& value);
6336   std::string* _internal_mutable_domain();
6337
6338   public:
6339   // optional string doc_string = 6;
6340   bool has_doc_string() const;
6341   void clear_doc_string() ;
6342   const std::string& doc_string() const;
6343   template <typename Arg_ = const std::string&, typename... Args_>
6344   void set_doc_string(Arg_&& arg, Args_... args);
6345   std::string* mutable_doc_string();
6346   PROTOBUF_NODISCARD std::string* release_doc_string();
6347   void set_allocated_doc_string(std::string* value);
6348
6349   private:
6350   const std::string& _internal_doc_string() const;
6351   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
6352       const std::string& value);
6353   std::string* _internal_mutable_doc_string();
6354
6355   public:
6356   // optional .onnx.GraphProto graph = 7;
6357   bool has_graph() const;
6358   void clear_graph() ;
6359   const ::onnx::GraphProto& graph() const;
6360   PROTOBUF_NODISCARD ::onnx::GraphProto* release_graph();
6361   ::onnx::GraphProto* mutable_graph();
6362   void set_allocated_graph(::onnx::GraphProto* value);
6363   void unsafe_arena_set_allocated_graph(::onnx::GraphProto* value);
6364   ::onnx::GraphProto* unsafe_arena_release_graph();
6365
6366   private:
6367   const ::onnx::GraphProto& _internal_graph() const;
6368   ::onnx::GraphProto* _internal_mutable_graph();
6369
6370   public:
6371   // optional int64 ir_version = 1;
6372   bool has_ir_version() const;
6373   void clear_ir_version() ;
6374   ::int64_t ir_version() const;
6375   void set_ir_version(::int64_t value);
6376
6377   private:
6378   ::int64_t _internal_ir_version() const;
6379   void _internal_set_ir_version(::int64_t value);
6380
6381   public:
6382   // optional int64 model_version = 5;
6383   bool has_model_version() const;
6384   void clear_model_version() ;
6385   ::int64_t model_version() const;
6386   void set_model_version(::int64_t value);
6387
6388   private:
6389   ::int64_t _internal_model_version() const;
6390   void _internal_set_model_version(::int64_t value);
6391
6392   public:
6393   // @@protoc_insertion_point(class_scope:onnx.ModelProto)
6394  private:
6395   class _Internal;
6396   friend class ::google::protobuf::internal::TcParser;
6397   static const ::google::protobuf::internal::TcParseTable<
6398       4, 11, 5,
6399       77, 2>
6400       _table_;
6401
6402
6403   friend class ::google::protobuf::MessageLite;
6404   friend class ::google::protobuf::Arena;
6405   template <typename T>
6406   friend class ::google::protobuf::Arena::InternalHelper;
6407   using InternalArenaConstructable_ = void;
6408   using DestructorSkippable_ = void;
6409   struct Impl_ {
6410     inline explicit constexpr Impl_(
6411         ::google::protobuf::internal::ConstantInitialized) noexcept;
6412     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
6413                           ::google::protobuf::Arena* arena);
6414     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
6415                           ::google::protobuf::Arena* arena, const Impl_& from,
6416                           const ModelProto& from_msg);
6417     ::google::protobuf::internal::HasBits<1> _has_bits_;
6418     mutable ::google::protobuf::internal::CachedSize _cached_size_;
6419     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
6420     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
6421     ::google::protobuf::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
6422     ::google::protobuf::RepeatedPtrField< ::onnx::FunctionProto > functions_;
6423     ::google::protobuf::internal::ArenaStringPtr producer_name_;
6424     ::google::protobuf::internal::ArenaStringPtr producer_version_;
6425     ::google::protobuf::internal::ArenaStringPtr domain_;
6426     ::google::protobuf::internal::ArenaStringPtr doc_string_;
6427     ::onnx::GraphProto* graph_;
6428     ::int64_t ir_version_;
6429     ::int64_t model_version_;
6430     PROTOBUF_TSAN_DECLARE_MEMBER
6431   };
6432   union { Impl_ _impl_; };
6433   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
6434 };
6435
6436 // ===================================================================
6437
6438
6439
6440
6441 // ===================================================================
6442
6443
6444 #ifdef __GNUC__
6445 #pragma GCC diagnostic push
6446 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
6447 #endif  // __GNUC__
6448 // -------------------------------------------------------------------
6449
6450 // AttributeProto
6451
6452 // optional string name = 1;
6453 inline bool AttributeProto::has_name() const {
6454   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6455   return value;
6456 }
6457 inline void AttributeProto::clear_name() {
6458   ::google::protobuf::internal::TSanWrite(&_impl_);
6459   _impl_.name_.ClearToEmpty();
6460   _impl_._has_bits_[0] &= ~0x00000001u;
6461 }
6462 inline const std::string& AttributeProto::name() const
6463     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6464   // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
6465   return _internal_name();
6466 }
6467 template <typename Arg_, typename... Args_>
6468 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_name(Arg_&& arg,
6469                                                      Args_... args) {
6470   ::google::protobuf::internal::TSanWrite(&_impl_);
6471   _impl_._has_bits_[0] |= 0x00000001u;
6472   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6473   // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
6474 }
6475 inline std::string* AttributeProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6476   std::string* _s = _internal_mutable_name();
6477   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
6478   return _s;
6479 }
6480 inline const std::string& AttributeProto::_internal_name() const {
6481   ::google::protobuf::internal::TSanRead(&_impl_);
6482   return _impl_.name_.Get();
6483 }
6484 inline void AttributeProto::_internal_set_name(const std::string& value) {
6485   ::google::protobuf::internal::TSanWrite(&_impl_);
6486   _impl_._has_bits_[0] |= 0x00000001u;
6487   _impl_.name_.Set(value, GetArena());
6488 }
6489 inline std::string* AttributeProto::_internal_mutable_name() {
6490   ::google::protobuf::internal::TSanWrite(&_impl_);
6491   _impl_._has_bits_[0] |= 0x00000001u;
6492   return _impl_.name_.Mutable( GetArena());
6493 }
6494 inline std::string* AttributeProto::release_name() {
6495   ::google::protobuf::internal::TSanWrite(&_impl_);
6496   // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
6497   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
6498     return nullptr;
6499   }
6500   _impl_._has_bits_[0] &= ~0x00000001u;
6501   auto* released = _impl_.name_.Release();
6502   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6503   _impl_.name_.Set("", GetArena());
6504   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6505   return released;
6506 }
6507 inline void AttributeProto::set_allocated_name(std::string* value) {
6508   ::google::protobuf::internal::TSanWrite(&_impl_);
6509   if (value != nullptr) {
6510     _impl_._has_bits_[0] |= 0x00000001u;
6511   } else {
6512     _impl_._has_bits_[0] &= ~0x00000001u;
6513   }
6514   _impl_.name_.SetAllocated(value, GetArena());
6515   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6516         if (_impl_.name_.IsDefault()) {
6517           _impl_.name_.Set("", GetArena());
6518         }
6519   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6520   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
6521 }
6522
6523 // optional string ref_attr_name = 21;
6524 inline bool AttributeProto::has_ref_attr_name() const {
6525   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
6526   return value;
6527 }
6528 inline void AttributeProto::clear_ref_attr_name() {
6529   ::google::protobuf::internal::TSanWrite(&_impl_);
6530   _impl_.ref_attr_name_.ClearToEmpty();
6531   _impl_._has_bits_[0] &= ~0x00000008u;
6532 }
6533 inline const std::string& AttributeProto::ref_attr_name() const
6534     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6535   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
6536   return _internal_ref_attr_name();
6537 }
6538 template <typename Arg_, typename... Args_>
6539 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_ref_attr_name(Arg_&& arg,
6540                                                      Args_... args) {
6541   ::google::protobuf::internal::TSanWrite(&_impl_);
6542   _impl_._has_bits_[0] |= 0x00000008u;
6543   _impl_.ref_attr_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6544   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
6545 }
6546 inline std::string* AttributeProto::mutable_ref_attr_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6547   std::string* _s = _internal_mutable_ref_attr_name();
6548   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
6549   return _s;
6550 }
6551 inline const std::string& AttributeProto::_internal_ref_attr_name() const {
6552   ::google::protobuf::internal::TSanRead(&_impl_);
6553   return _impl_.ref_attr_name_.Get();
6554 }
6555 inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
6556   ::google::protobuf::internal::TSanWrite(&_impl_);
6557   _impl_._has_bits_[0] |= 0x00000008u;
6558   _impl_.ref_attr_name_.Set(value, GetArena());
6559 }
6560 inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
6561   ::google::protobuf::internal::TSanWrite(&_impl_);
6562   _impl_._has_bits_[0] |= 0x00000008u;
6563   return _impl_.ref_attr_name_.Mutable( GetArena());
6564 }
6565 inline std::string* AttributeProto::release_ref_attr_name() {
6566   ::google::protobuf::internal::TSanWrite(&_impl_);
6567   // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
6568   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
6569     return nullptr;
6570   }
6571   _impl_._has_bits_[0] &= ~0x00000008u;
6572   auto* released = _impl_.ref_attr_name_.Release();
6573   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6574   _impl_.ref_attr_name_.Set("", GetArena());
6575   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6576   return released;
6577 }
6578 inline void AttributeProto::set_allocated_ref_attr_name(std::string* value) {
6579   ::google::protobuf::internal::TSanWrite(&_impl_);
6580   if (value != nullptr) {
6581     _impl_._has_bits_[0] |= 0x00000008u;
6582   } else {
6583     _impl_._has_bits_[0] &= ~0x00000008u;
6584   }
6585   _impl_.ref_attr_name_.SetAllocated(value, GetArena());
6586   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6587         if (_impl_.ref_attr_name_.IsDefault()) {
6588           _impl_.ref_attr_name_.Set("", GetArena());
6589         }
6590   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6591   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
6592 }
6593
6594 // optional string doc_string = 13;
6595 inline bool AttributeProto::has_doc_string() const {
6596   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
6597   return value;
6598 }
6599 inline void AttributeProto::clear_doc_string() {
6600   ::google::protobuf::internal::TSanWrite(&_impl_);
6601   _impl_.doc_string_.ClearToEmpty();
6602   _impl_._has_bits_[0] &= ~0x00000004u;
6603 }
6604 inline const std::string& AttributeProto::doc_string() const
6605     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6606   // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
6607   return _internal_doc_string();
6608 }
6609 template <typename Arg_, typename... Args_>
6610 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_doc_string(Arg_&& arg,
6611                                                      Args_... args) {
6612   ::google::protobuf::internal::TSanWrite(&_impl_);
6613   _impl_._has_bits_[0] |= 0x00000004u;
6614   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6615   // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
6616 }
6617 inline std::string* AttributeProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6618   std::string* _s = _internal_mutable_doc_string();
6619   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
6620   return _s;
6621 }
6622 inline const std::string& AttributeProto::_internal_doc_string() const {
6623   ::google::protobuf::internal::TSanRead(&_impl_);
6624   return _impl_.doc_string_.Get();
6625 }
6626 inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
6627   ::google::protobuf::internal::TSanWrite(&_impl_);
6628   _impl_._has_bits_[0] |= 0x00000004u;
6629   _impl_.doc_string_.Set(value, GetArena());
6630 }
6631 inline std::string* AttributeProto::_internal_mutable_doc_string() {
6632   ::google::protobuf::internal::TSanWrite(&_impl_);
6633   _impl_._has_bits_[0] |= 0x00000004u;
6634   return _impl_.doc_string_.Mutable( GetArena());
6635 }
6636 inline std::string* AttributeProto::release_doc_string() {
6637   ::google::protobuf::internal::TSanWrite(&_impl_);
6638   // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
6639   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
6640     return nullptr;
6641   }
6642   _impl_._has_bits_[0] &= ~0x00000004u;
6643   auto* released = _impl_.doc_string_.Release();
6644   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6645   _impl_.doc_string_.Set("", GetArena());
6646   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6647   return released;
6648 }
6649 inline void AttributeProto::set_allocated_doc_string(std::string* value) {
6650   ::google::protobuf::internal::TSanWrite(&_impl_);
6651   if (value != nullptr) {
6652     _impl_._has_bits_[0] |= 0x00000004u;
6653   } else {
6654     _impl_._has_bits_[0] &= ~0x00000004u;
6655   }
6656   _impl_.doc_string_.SetAllocated(value, GetArena());
6657   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6658         if (_impl_.doc_string_.IsDefault()) {
6659           _impl_.doc_string_.Set("", GetArena());
6660         }
6661   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6662   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
6663 }
6664
6665 // optional .onnx.AttributeProto.AttributeType type = 20;
6666 inline bool AttributeProto::has_type() const {
6667   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
6668   return value;
6669 }
6670 inline void AttributeProto::clear_type() {
6671   ::google::protobuf::internal::TSanWrite(&_impl_);
6672   _impl_.type_ = 0;
6673   _impl_._has_bits_[0] &= ~0x00000400u;
6674 }
6675 inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
6676   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
6677   return _internal_type();
6678 }
6679 inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
6680   _internal_set_type(value);
6681   _impl_._has_bits_[0] |= 0x00000400u;
6682   // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
6683 }
6684 inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
6685   ::google::protobuf::internal::TSanRead(&_impl_);
6686   return static_cast<::onnx::AttributeProto_AttributeType>(_impl_.type_);
6687 }
6688 inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
6689   ::google::protobuf::internal::TSanWrite(&_impl_);
6690   assert(::onnx::AttributeProto_AttributeType_IsValid(value));
6691   _impl_.type_ = value;
6692 }
6693
6694 // optional float f = 2;
6695 inline bool AttributeProto::has_f() const {
6696   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
6697   return value;
6698 }
6699 inline void AttributeProto::clear_f() {
6700   ::google::protobuf::internal::TSanWrite(&_impl_);
6701   _impl_.f_ = 0;
6702   _impl_._has_bits_[0] &= ~0x00000200u;
6703 }
6704 inline float AttributeProto::f() const {
6705   // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
6706   return _internal_f();
6707 }
6708 inline void AttributeProto::set_f(float value) {
6709   _internal_set_f(value);
6710   _impl_._has_bits_[0] |= 0x00000200u;
6711   // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
6712 }
6713 inline float AttributeProto::_internal_f() const {
6714   ::google::protobuf::internal::TSanRead(&_impl_);
6715   return _impl_.f_;
6716 }
6717 inline void AttributeProto::_internal_set_f(float value) {
6718   ::google::protobuf::internal::TSanWrite(&_impl_);
6719   _impl_.f_ = value;
6720 }
6721
6722 // optional int64 i = 3;
6723 inline bool AttributeProto::has_i() const {
6724   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
6725   return value;
6726 }
6727 inline void AttributeProto::clear_i() {
6728   ::google::protobuf::internal::TSanWrite(&_impl_);
6729   _impl_.i_ = ::int64_t{0};
6730   _impl_._has_bits_[0] &= ~0x00000100u;
6731 }
6732 inline ::int64_t AttributeProto::i() const {
6733   // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
6734   return _internal_i();
6735 }
6736 inline void AttributeProto::set_i(::int64_t value) {
6737   _internal_set_i(value);
6738   _impl_._has_bits_[0] |= 0x00000100u;
6739   // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
6740 }
6741 inline ::int64_t AttributeProto::_internal_i() const {
6742   ::google::protobuf::internal::TSanRead(&_impl_);
6743   return _impl_.i_;
6744 }
6745 inline void AttributeProto::_internal_set_i(::int64_t value) {
6746   ::google::protobuf::internal::TSanWrite(&_impl_);
6747   _impl_.i_ = value;
6748 }
6749
6750 // optional bytes s = 4;
6751 inline bool AttributeProto::has_s() const {
6752   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6753   return value;
6754 }
6755 inline void AttributeProto::clear_s() {
6756   ::google::protobuf::internal::TSanWrite(&_impl_);
6757   _impl_.s_.ClearToEmpty();
6758   _impl_._has_bits_[0] &= ~0x00000002u;
6759 }
6760 inline const std::string& AttributeProto::s() const
6761     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6762   // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
6763   return _internal_s();
6764 }
6765 template <typename Arg_, typename... Args_>
6766 inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_s(Arg_&& arg,
6767                                                      Args_... args) {
6768   ::google::protobuf::internal::TSanWrite(&_impl_);
6769   _impl_._has_bits_[0] |= 0x00000002u;
6770   _impl_.s_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
6771   // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
6772 }
6773 inline std::string* AttributeProto::mutable_s() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6774   std::string* _s = _internal_mutable_s();
6775   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
6776   return _s;
6777 }
6778 inline const std::string& AttributeProto::_internal_s() const {
6779   ::google::protobuf::internal::TSanRead(&_impl_);
6780   return _impl_.s_.Get();
6781 }
6782 inline void AttributeProto::_internal_set_s(const std::string& value) {
6783   ::google::protobuf::internal::TSanWrite(&_impl_);
6784   _impl_._has_bits_[0] |= 0x00000002u;
6785   _impl_.s_.Set(value, GetArena());
6786 }
6787 inline std::string* AttributeProto::_internal_mutable_s() {
6788   ::google::protobuf::internal::TSanWrite(&_impl_);
6789   _impl_._has_bits_[0] |= 0x00000002u;
6790   return _impl_.s_.Mutable( GetArena());
6791 }
6792 inline std::string* AttributeProto::release_s() {
6793   ::google::protobuf::internal::TSanWrite(&_impl_);
6794   // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
6795   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
6796     return nullptr;
6797   }
6798   _impl_._has_bits_[0] &= ~0x00000002u;
6799   auto* released = _impl_.s_.Release();
6800   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6801   _impl_.s_.Set("", GetArena());
6802   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6803   return released;
6804 }
6805 inline void AttributeProto::set_allocated_s(std::string* value) {
6806   ::google::protobuf::internal::TSanWrite(&_impl_);
6807   if (value != nullptr) {
6808     _impl_._has_bits_[0] |= 0x00000002u;
6809   } else {
6810     _impl_._has_bits_[0] &= ~0x00000002u;
6811   }
6812   _impl_.s_.SetAllocated(value, GetArena());
6813   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6814         if (_impl_.s_.IsDefault()) {
6815           _impl_.s_.Set("", GetArena());
6816         }
6817   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6818   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
6819 }
6820
6821 // optional .onnx.TensorProto t = 5;
6822 inline bool AttributeProto::has_t() const {
6823   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
6824   PROTOBUF_ASSUME(!value || _impl_.t_ != nullptr);
6825   return value;
6826 }
6827 inline void AttributeProto::clear_t() {
6828   ::google::protobuf::internal::TSanWrite(&_impl_);
6829   if (_impl_.t_ != nullptr) _impl_.t_->Clear();
6830   _impl_._has_bits_[0] &= ~0x00000010u;
6831 }
6832 inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
6833   ::google::protobuf::internal::TSanRead(&_impl_);
6834   const ::onnx::TensorProto* p = _impl_.t_;
6835   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
6836 }
6837 inline const ::onnx::TensorProto& AttributeProto::t() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
6838   // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
6839   return _internal_t();
6840 }
6841 inline void AttributeProto::unsafe_arena_set_allocated_t(::onnx::TensorProto* value) {
6842   ::google::protobuf::internal::TSanWrite(&_impl_);
6843   if (GetArena() == nullptr) {
6844     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
6845   }
6846   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
6847   if (value != nullptr) {
6848     _impl_._has_bits_[0] |= 0x00000010u;
6849   } else {
6850     _impl_._has_bits_[0] &= ~0x00000010u;
6851   }
6852   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
6853 }
6854 inline ::onnx::TensorProto* AttributeProto::release_t() {
6855   ::google::protobuf::internal::TSanWrite(&_impl_);
6856
6857   _impl_._has_bits_[0] &= ~0x00000010u;
6858   ::onnx::TensorProto* released = _impl_.t_;
6859   _impl_.t_ = nullptr;
6860 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6861   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
6862   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6863   if (GetArena() == nullptr) {
6864     delete old;
6865   }
6866 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
6867   if (GetArena() != nullptr) {
6868     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6869   }
6870 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6871   return released;
6872 }
6873 inline ::onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
6874   ::google::protobuf::internal::TSanWrite(&_impl_);
6875   // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)
6876
6877   _impl_._has_bits_[0] &= ~0x00000010u;
6878   ::onnx::TensorProto* temp = _impl_.t_;
6879   _impl_.t_ = nullptr;
6880   return temp;
6881 }
6882 inline ::onnx::TensorProto* AttributeProto::_internal_mutable_t() {
6883   ::google::protobuf::internal::TSanWrite(&_impl_);
6884   if (_impl_.t_ == nullptr) {
6885     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
6886     _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(p);
6887   }
6888   return _impl_.t_;
6889 }
6890 inline ::onnx::TensorProto* AttributeProto::mutable_t() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6891   _impl_._has_bits_[0] |= 0x00000010u;
6892   ::onnx::TensorProto* _msg = _internal_mutable_t();
6893   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
6894   return _msg;
6895 }
6896 inline void AttributeProto::set_allocated_t(::onnx::TensorProto* value) {
6897   ::google::protobuf::Arena* message_arena = GetArena();
6898   ::google::protobuf::internal::TSanWrite(&_impl_);
6899   if (message_arena == nullptr) {
6900     delete (_impl_.t_);
6901   }
6902
6903   if (value != nullptr) {
6904     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
6905     if (message_arena != submessage_arena) {
6906       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
6907     }
6908     _impl_._has_bits_[0] |= 0x00000010u;
6909   } else {
6910     _impl_._has_bits_[0] &= ~0x00000010u;
6911   }
6912
6913   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
6914   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
6915 }
6916
6917 // optional .onnx.GraphProto g = 6;
6918 inline bool AttributeProto::has_g() const {
6919   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
6920   PROTOBUF_ASSUME(!value || _impl_.g_ != nullptr);
6921   return value;
6922 }
6923 inline void AttributeProto::clear_g() {
6924   ::google::protobuf::internal::TSanWrite(&_impl_);
6925   if (_impl_.g_ != nullptr) _impl_.g_->Clear();
6926   _impl_._has_bits_[0] &= ~0x00000020u;
6927 }
6928 inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
6929   ::google::protobuf::internal::TSanRead(&_impl_);
6930   const ::onnx::GraphProto* p = _impl_.g_;
6931   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
6932 }
6933 inline const ::onnx::GraphProto& AttributeProto::g() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
6934   // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
6935   return _internal_g();
6936 }
6937 inline void AttributeProto::unsafe_arena_set_allocated_g(::onnx::GraphProto* value) {
6938   ::google::protobuf::internal::TSanWrite(&_impl_);
6939   if (GetArena() == nullptr) {
6940     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
6941   }
6942   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
6943   if (value != nullptr) {
6944     _impl_._has_bits_[0] |= 0x00000020u;
6945   } else {
6946     _impl_._has_bits_[0] &= ~0x00000020u;
6947   }
6948   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
6949 }
6950 inline ::onnx::GraphProto* AttributeProto::release_g() {
6951   ::google::protobuf::internal::TSanWrite(&_impl_);
6952
6953   _impl_._has_bits_[0] &= ~0x00000020u;
6954   ::onnx::GraphProto* released = _impl_.g_;
6955   _impl_.g_ = nullptr;
6956 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6957   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
6958   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6959   if (GetArena() == nullptr) {
6960     delete old;
6961   }
6962 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
6963   if (GetArena() != nullptr) {
6964     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6965   }
6966 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6967   return released;
6968 }
6969 inline ::onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
6970   ::google::protobuf::internal::TSanWrite(&_impl_);
6971   // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)
6972
6973   _impl_._has_bits_[0] &= ~0x00000020u;
6974   ::onnx::GraphProto* temp = _impl_.g_;
6975   _impl_.g_ = nullptr;
6976   return temp;
6977 }
6978 inline ::onnx::GraphProto* AttributeProto::_internal_mutable_g() {
6979   ::google::protobuf::internal::TSanWrite(&_impl_);
6980   if (_impl_.g_ == nullptr) {
6981     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
6982     _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(p);
6983   }
6984   return _impl_.g_;
6985 }
6986 inline ::onnx::GraphProto* AttributeProto::mutable_g() ABSL_ATTRIBUTE_LIFETIME_BOUND {
6987   _impl_._has_bits_[0] |= 0x00000020u;
6988   ::onnx::GraphProto* _msg = _internal_mutable_g();
6989   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
6990   return _msg;
6991 }
6992 inline void AttributeProto::set_allocated_g(::onnx::GraphProto* value) {
6993   ::google::protobuf::Arena* message_arena = GetArena();
6994   ::google::protobuf::internal::TSanWrite(&_impl_);
6995   if (message_arena == nullptr) {
6996     delete (_impl_.g_);
6997   }
6998
6999   if (value != nullptr) {
7000     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
7001     if (message_arena != submessage_arena) {
7002       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7003     }
7004     _impl_._has_bits_[0] |= 0x00000020u;
7005   } else {
7006     _impl_._has_bits_[0] &= ~0x00000020u;
7007   }
7008
7009   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
7010   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
7011 }
7012
7013 // optional .onnx.SparseTensorProto sparse_tensor = 22;
7014 inline bool AttributeProto::has_sparse_tensor() const {
7015   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
7016   PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_ != nullptr);
7017   return value;
7018 }
7019 inline void AttributeProto::clear_sparse_tensor() {
7020   ::google::protobuf::internal::TSanWrite(&_impl_);
7021   if (_impl_.sparse_tensor_ != nullptr) _impl_.sparse_tensor_->Clear();
7022   _impl_._has_bits_[0] &= ~0x00000080u;
7023 }
7024 inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
7025   ::google::protobuf::internal::TSanRead(&_impl_);
7026   const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_;
7027   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
7028 }
7029 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7030   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
7031   return _internal_sparse_tensor();
7032 }
7033 inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* value) {
7034   ::google::protobuf::internal::TSanWrite(&_impl_);
7035   if (GetArena() == nullptr) {
7036     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
7037   }
7038   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
7039   if (value != nullptr) {
7040     _impl_._has_bits_[0] |= 0x00000080u;
7041   } else {
7042     _impl_._has_bits_[0] &= ~0x00000080u;
7043   }
7044   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
7045 }
7046 inline ::onnx::SparseTensorProto* AttributeProto::release_sparse_tensor() {
7047   ::google::protobuf::internal::TSanWrite(&_impl_);
7048
7049   _impl_._has_bits_[0] &= ~0x00000080u;
7050   ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_;
7051   _impl_.sparse_tensor_ = nullptr;
7052 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7053   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7054   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7055   if (GetArena() == nullptr) {
7056     delete old;
7057   }
7058 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
7059   if (GetArena() != nullptr) {
7060     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7061   }
7062 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7063   return released;
7064 }
7065 inline ::onnx::SparseTensorProto* AttributeProto::unsafe_arena_release_sparse_tensor() {
7066   ::google::protobuf::internal::TSanWrite(&_impl_);
7067   // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)
7068
7069   _impl_._has_bits_[0] &= ~0x00000080u;
7070   ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_;
7071   _impl_.sparse_tensor_ = nullptr;
7072   return temp;
7073 }
7074 inline ::onnx::SparseTensorProto* AttributeProto::_internal_mutable_sparse_tensor() {
7075   ::google::protobuf::internal::TSanWrite(&_impl_);
7076   if (_impl_.sparse_tensor_ == nullptr) {
7077     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
7078     _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
7079   }
7080   return _impl_.sparse_tensor_;
7081 }
7082 inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7083   _impl_._has_bits_[0] |= 0x00000080u;
7084   ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor();
7085   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
7086   return _msg;
7087 }
7088 inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* value) {
7089   ::google::protobuf::Arena* message_arena = GetArena();
7090   ::google::protobuf::internal::TSanWrite(&_impl_);
7091   if (message_arena == nullptr) {
7092     delete (_impl_.sparse_tensor_);
7093   }
7094
7095   if (value != nullptr) {
7096     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
7097     if (message_arena != submessage_arena) {
7098       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7099     }
7100     _impl_._has_bits_[0] |= 0x00000080u;
7101   } else {
7102     _impl_._has_bits_[0] &= ~0x00000080u;
7103   }
7104
7105   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
7106   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
7107 }
7108
7109 // optional .onnx.TypeProto tp = 14;
7110 inline bool AttributeProto::has_tp() const {
7111   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
7112   PROTOBUF_ASSUME(!value || _impl_.tp_ != nullptr);
7113   return value;
7114 }
7115 inline void AttributeProto::clear_tp() {
7116   ::google::protobuf::internal::TSanWrite(&_impl_);
7117   if (_impl_.tp_ != nullptr) _impl_.tp_->Clear();
7118   _impl_._has_bits_[0] &= ~0x00000040u;
7119 }
7120 inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
7121   ::google::protobuf::internal::TSanRead(&_impl_);
7122   const ::onnx::TypeProto* p = _impl_.tp_;
7123   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
7124 }
7125 inline const ::onnx::TypeProto& AttributeProto::tp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7126   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
7127   return _internal_tp();
7128 }
7129 inline void AttributeProto::unsafe_arena_set_allocated_tp(::onnx::TypeProto* value) {
7130   ::google::protobuf::internal::TSanWrite(&_impl_);
7131   if (GetArena() == nullptr) {
7132     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
7133   }
7134   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
7135   if (value != nullptr) {
7136     _impl_._has_bits_[0] |= 0x00000040u;
7137   } else {
7138     _impl_._has_bits_[0] &= ~0x00000040u;
7139   }
7140   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
7141 }
7142 inline ::onnx::TypeProto* AttributeProto::release_tp() {
7143   ::google::protobuf::internal::TSanWrite(&_impl_);
7144
7145   _impl_._has_bits_[0] &= ~0x00000040u;
7146   ::onnx::TypeProto* released = _impl_.tp_;
7147   _impl_.tp_ = nullptr;
7148 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7149   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7150   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7151   if (GetArena() == nullptr) {
7152     delete old;
7153   }
7154 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
7155   if (GetArena() != nullptr) {
7156     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7157   }
7158 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7159   return released;
7160 }
7161 inline ::onnx::TypeProto* AttributeProto::unsafe_arena_release_tp() {
7162   ::google::protobuf::internal::TSanWrite(&_impl_);
7163   // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)
7164
7165   _impl_._has_bits_[0] &= ~0x00000040u;
7166   ::onnx::TypeProto* temp = _impl_.tp_;
7167   _impl_.tp_ = nullptr;
7168   return temp;
7169 }
7170 inline ::onnx::TypeProto* AttributeProto::_internal_mutable_tp() {
7171   ::google::protobuf::internal::TSanWrite(&_impl_);
7172   if (_impl_.tp_ == nullptr) {
7173     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
7174     _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(p);
7175   }
7176   return _impl_.tp_;
7177 }
7178 inline ::onnx::TypeProto* AttributeProto::mutable_tp() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7179   _impl_._has_bits_[0] |= 0x00000040u;
7180   ::onnx::TypeProto* _msg = _internal_mutable_tp();
7181   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
7182   return _msg;
7183 }
7184 inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* value) {
7185   ::google::protobuf::Arena* message_arena = GetArena();
7186   ::google::protobuf::internal::TSanWrite(&_impl_);
7187   if (message_arena == nullptr) {
7188     delete (_impl_.tp_);
7189   }
7190
7191   if (value != nullptr) {
7192     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
7193     if (message_arena != submessage_arena) {
7194       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7195     }
7196     _impl_._has_bits_[0] |= 0x00000040u;
7197   } else {
7198     _impl_._has_bits_[0] &= ~0x00000040u;
7199   }
7200
7201   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
7202   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
7203 }
7204
7205 // repeated float floats = 7;
7206 inline int AttributeProto::_internal_floats_size() const {
7207   return _internal_floats().size();
7208 }
7209 inline int AttributeProto::floats_size() const {
7210   return _internal_floats_size();
7211 }
7212 inline void AttributeProto::clear_floats() {
7213   ::google::protobuf::internal::TSanWrite(&_impl_);
7214   _impl_.floats_.Clear();
7215 }
7216 inline float AttributeProto::floats(int index) const {
7217   // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
7218   return _internal_floats().Get(index);
7219 }
7220 inline void AttributeProto::set_floats(int index, float value) {
7221   _internal_mutable_floats()->Set(index, value);
7222   // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
7223 }
7224 inline void AttributeProto::add_floats(float value) {
7225   ::google::protobuf::internal::TSanWrite(&_impl_);
7226   _internal_mutable_floats()->Add(value);
7227   // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
7228 }
7229 inline const ::google::protobuf::RepeatedField<float>& AttributeProto::floats() const
7230     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7231   // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
7232   return _internal_floats();
7233 }
7234 inline ::google::protobuf::RepeatedField<float>* AttributeProto::mutable_floats()
7235     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7236   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
7237   ::google::protobuf::internal::TSanWrite(&_impl_);
7238   return _internal_mutable_floats();
7239 }
7240 inline const ::google::protobuf::RepeatedField<float>&
7241 AttributeProto::_internal_floats() const {
7242   ::google::protobuf::internal::TSanRead(&_impl_);
7243   return _impl_.floats_;
7244 }
7245 inline ::google::protobuf::RepeatedField<float>* AttributeProto::_internal_mutable_floats() {
7246   ::google::protobuf::internal::TSanRead(&_impl_);
7247   return &_impl_.floats_;
7248 }
7249
7250 // repeated int64 ints = 8;
7251 inline int AttributeProto::_internal_ints_size() const {
7252   return _internal_ints().size();
7253 }
7254 inline int AttributeProto::ints_size() const {
7255   return _internal_ints_size();
7256 }
7257 inline void AttributeProto::clear_ints() {
7258   ::google::protobuf::internal::TSanWrite(&_impl_);
7259   _impl_.ints_.Clear();
7260 }
7261 inline ::int64_t AttributeProto::ints(int index) const {
7262   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
7263   return _internal_ints().Get(index);
7264 }
7265 inline void AttributeProto::set_ints(int index, ::int64_t value) {
7266   _internal_mutable_ints()->Set(index, value);
7267   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
7268 }
7269 inline void AttributeProto::add_ints(::int64_t value) {
7270   ::google::protobuf::internal::TSanWrite(&_impl_);
7271   _internal_mutable_ints()->Add(value);
7272   // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
7273 }
7274 inline const ::google::protobuf::RepeatedField<::int64_t>& AttributeProto::ints() const
7275     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7276   // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
7277   return _internal_ints();
7278 }
7279 inline ::google::protobuf::RepeatedField<::int64_t>* AttributeProto::mutable_ints()
7280     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7281   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
7282   ::google::protobuf::internal::TSanWrite(&_impl_);
7283   return _internal_mutable_ints();
7284 }
7285 inline const ::google::protobuf::RepeatedField<::int64_t>&
7286 AttributeProto::_internal_ints() const {
7287   ::google::protobuf::internal::TSanRead(&_impl_);
7288   return _impl_.ints_;
7289 }
7290 inline ::google::protobuf::RepeatedField<::int64_t>* AttributeProto::_internal_mutable_ints() {
7291   ::google::protobuf::internal::TSanRead(&_impl_);
7292   return &_impl_.ints_;
7293 }
7294
7295 // repeated bytes strings = 9;
7296 inline int AttributeProto::_internal_strings_size() const {
7297   return _internal_strings().size();
7298 }
7299 inline int AttributeProto::strings_size() const {
7300   return _internal_strings_size();
7301 }
7302 inline void AttributeProto::clear_strings() {
7303   ::google::protobuf::internal::TSanWrite(&_impl_);
7304   _impl_.strings_.Clear();
7305 }
7306 inline std::string* AttributeProto::add_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7307   ::google::protobuf::internal::TSanWrite(&_impl_);
7308   std::string* _s = _internal_mutable_strings()->Add();
7309   // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
7310   return _s;
7311 }
7312 inline const std::string& AttributeProto::strings(int index) const
7313     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7314   // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
7315   return _internal_strings().Get(index);
7316 }
7317 inline std::string* AttributeProto::mutable_strings(int index)
7318     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7319   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
7320   return _internal_mutable_strings()->Mutable(index);
7321 }
7322 template <typename Arg_, typename... Args_>
7323 inline void AttributeProto::set_strings(int index, Arg_&& value, Args_... args) {
7324   ::google::protobuf::internal::AssignToString(
7325       *_internal_mutable_strings()->Mutable(index),
7326       std::forward<Arg_>(value), args... , ::google::protobuf::internal::BytesTag{});
7327   // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
7328 }
7329 template <typename Arg_, typename... Args_>
7330 inline void AttributeProto::add_strings(Arg_&& value, Args_... args) {
7331   ::google::protobuf::internal::TSanWrite(&_impl_);
7332   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_strings(),
7333                                std::forward<Arg_>(value),
7334                                args... , ::google::protobuf::internal::BytesTag{});
7335   // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
7336 }
7337 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7338 AttributeProto::strings() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7339   // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
7340   return _internal_strings();
7341 }
7342 inline ::google::protobuf::RepeatedPtrField<std::string>*
7343 AttributeProto::mutable_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7344   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
7345   ::google::protobuf::internal::TSanWrite(&_impl_);
7346   return _internal_mutable_strings();
7347 }
7348 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7349 AttributeProto::_internal_strings() const {
7350   ::google::protobuf::internal::TSanRead(&_impl_);
7351   return _impl_.strings_;
7352 }
7353 inline ::google::protobuf::RepeatedPtrField<std::string>*
7354 AttributeProto::_internal_mutable_strings() {
7355   ::google::protobuf::internal::TSanRead(&_impl_);
7356   return &_impl_.strings_;
7357 }
7358
7359 // repeated .onnx.TensorProto tensors = 10;
7360 inline int AttributeProto::_internal_tensors_size() const {
7361   return _internal_tensors().size();
7362 }
7363 inline int AttributeProto::tensors_size() const {
7364   return _internal_tensors_size();
7365 }
7366 inline void AttributeProto::clear_tensors() {
7367   ::google::protobuf::internal::TSanWrite(&_impl_);
7368   _impl_.tensors_.Clear();
7369 }
7370 inline ::onnx::TensorProto* AttributeProto::mutable_tensors(int index)
7371     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7372   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
7373   return _internal_mutable_tensors()->Mutable(index);
7374 }
7375 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* AttributeProto::mutable_tensors()
7376     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7377   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
7378   ::google::protobuf::internal::TSanWrite(&_impl_);
7379   return _internal_mutable_tensors();
7380 }
7381 inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const
7382     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7383   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
7384   return _internal_tensors().Get(index);
7385 }
7386 inline ::onnx::TensorProto* AttributeProto::add_tensors() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7387   ::google::protobuf::internal::TSanWrite(&_impl_);
7388   ::onnx::TensorProto* _add = _internal_mutable_tensors()->Add();
7389   // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
7390   return _add;
7391 }
7392 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& AttributeProto::tensors() const
7393     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7394   // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
7395   return _internal_tensors();
7396 }
7397 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
7398 AttributeProto::_internal_tensors() const {
7399   ::google::protobuf::internal::TSanRead(&_impl_);
7400   return _impl_.tensors_;
7401 }
7402 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>*
7403 AttributeProto::_internal_mutable_tensors() {
7404   ::google::protobuf::internal::TSanRead(&_impl_);
7405   return &_impl_.tensors_;
7406 }
7407
7408 // repeated .onnx.GraphProto graphs = 11;
7409 inline int AttributeProto::_internal_graphs_size() const {
7410   return _internal_graphs().size();
7411 }
7412 inline int AttributeProto::graphs_size() const {
7413   return _internal_graphs_size();
7414 }
7415 inline void AttributeProto::clear_graphs() {
7416   ::google::protobuf::internal::TSanWrite(&_impl_);
7417   _impl_.graphs_.Clear();
7418 }
7419 inline ::onnx::GraphProto* AttributeProto::mutable_graphs(int index)
7420     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7421   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
7422   return _internal_mutable_graphs()->Mutable(index);
7423 }
7424 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* AttributeProto::mutable_graphs()
7425     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7426   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
7427   ::google::protobuf::internal::TSanWrite(&_impl_);
7428   return _internal_mutable_graphs();
7429 }
7430 inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const
7431     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7432   // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
7433   return _internal_graphs().Get(index);
7434 }
7435 inline ::onnx::GraphProto* AttributeProto::add_graphs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7436   ::google::protobuf::internal::TSanWrite(&_impl_);
7437   ::onnx::GraphProto* _add = _internal_mutable_graphs()->Add();
7438   // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
7439   return _add;
7440 }
7441 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& AttributeProto::graphs() const
7442     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7443   // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
7444   return _internal_graphs();
7445 }
7446 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>&
7447 AttributeProto::_internal_graphs() const {
7448   ::google::protobuf::internal::TSanRead(&_impl_);
7449   return _impl_.graphs_;
7450 }
7451 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>*
7452 AttributeProto::_internal_mutable_graphs() {
7453   ::google::protobuf::internal::TSanRead(&_impl_);
7454   return &_impl_.graphs_;
7455 }
7456
7457 // repeated .onnx.SparseTensorProto sparse_tensors = 23;
7458 inline int AttributeProto::_internal_sparse_tensors_size() const {
7459   return _internal_sparse_tensors().size();
7460 }
7461 inline int AttributeProto::sparse_tensors_size() const {
7462   return _internal_sparse_tensors_size();
7463 }
7464 inline void AttributeProto::clear_sparse_tensors() {
7465   ::google::protobuf::internal::TSanWrite(&_impl_);
7466   _impl_.sparse_tensors_.Clear();
7467 }
7468 inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensors(int index)
7469     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7470   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
7471   return _internal_mutable_sparse_tensors()->Mutable(index);
7472 }
7473 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* AttributeProto::mutable_sparse_tensors()
7474     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7475   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
7476   ::google::protobuf::internal::TSanWrite(&_impl_);
7477   return _internal_mutable_sparse_tensors();
7478 }
7479 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const
7480     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7481   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
7482   return _internal_sparse_tensors().Get(index);
7483 }
7484 inline ::onnx::SparseTensorProto* AttributeProto::add_sparse_tensors() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7485   ::google::protobuf::internal::TSanWrite(&_impl_);
7486   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_tensors()->Add();
7487   // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
7488   return _add;
7489 }
7490 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& AttributeProto::sparse_tensors() const
7491     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7492   // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
7493   return _internal_sparse_tensors();
7494 }
7495 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
7496 AttributeProto::_internal_sparse_tensors() const {
7497   ::google::protobuf::internal::TSanRead(&_impl_);
7498   return _impl_.sparse_tensors_;
7499 }
7500 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>*
7501 AttributeProto::_internal_mutable_sparse_tensors() {
7502   ::google::protobuf::internal::TSanRead(&_impl_);
7503   return &_impl_.sparse_tensors_;
7504 }
7505
7506 // repeated .onnx.TypeProto type_protos = 15;
7507 inline int AttributeProto::_internal_type_protos_size() const {
7508   return _internal_type_protos().size();
7509 }
7510 inline int AttributeProto::type_protos_size() const {
7511   return _internal_type_protos_size();
7512 }
7513 inline void AttributeProto::clear_type_protos() {
7514   ::google::protobuf::internal::TSanWrite(&_impl_);
7515   _impl_.type_protos_.Clear();
7516 }
7517 inline ::onnx::TypeProto* AttributeProto::mutable_type_protos(int index)
7518     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7519   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
7520   return _internal_mutable_type_protos()->Mutable(index);
7521 }
7522 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* AttributeProto::mutable_type_protos()
7523     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7524   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
7525   ::google::protobuf::internal::TSanWrite(&_impl_);
7526   return _internal_mutable_type_protos();
7527 }
7528 inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const
7529     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7530   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
7531   return _internal_type_protos().Get(index);
7532 }
7533 inline ::onnx::TypeProto* AttributeProto::add_type_protos() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7534   ::google::protobuf::internal::TSanWrite(&_impl_);
7535   ::onnx::TypeProto* _add = _internal_mutable_type_protos()->Add();
7536   // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
7537   return _add;
7538 }
7539 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& AttributeProto::type_protos() const
7540     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7541   // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
7542   return _internal_type_protos();
7543 }
7544 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>&
7545 AttributeProto::_internal_type_protos() const {
7546   ::google::protobuf::internal::TSanRead(&_impl_);
7547   return _impl_.type_protos_;
7548 }
7549 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>*
7550 AttributeProto::_internal_mutable_type_protos() {
7551   ::google::protobuf::internal::TSanRead(&_impl_);
7552   return &_impl_.type_protos_;
7553 }
7554
7555 // -------------------------------------------------------------------
7556
7557 // ValueInfoProto
7558
7559 // optional string name = 1;
7560 inline bool ValueInfoProto::has_name() const {
7561   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
7562   return value;
7563 }
7564 inline void ValueInfoProto::clear_name() {
7565   ::google::protobuf::internal::TSanWrite(&_impl_);
7566   _impl_.name_.ClearToEmpty();
7567   _impl_._has_bits_[0] &= ~0x00000001u;
7568 }
7569 inline const std::string& ValueInfoProto::name() const
7570     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7571   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
7572   return _internal_name();
7573 }
7574 template <typename Arg_, typename... Args_>
7575 inline PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_name(Arg_&& arg,
7576                                                      Args_... args) {
7577   ::google::protobuf::internal::TSanWrite(&_impl_);
7578   _impl_._has_bits_[0] |= 0x00000001u;
7579   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
7580   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
7581 }
7582 inline std::string* ValueInfoProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7583   std::string* _s = _internal_mutable_name();
7584   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
7585   return _s;
7586 }
7587 inline const std::string& ValueInfoProto::_internal_name() const {
7588   ::google::protobuf::internal::TSanRead(&_impl_);
7589   return _impl_.name_.Get();
7590 }
7591 inline void ValueInfoProto::_internal_set_name(const std::string& value) {
7592   ::google::protobuf::internal::TSanWrite(&_impl_);
7593   _impl_._has_bits_[0] |= 0x00000001u;
7594   _impl_.name_.Set(value, GetArena());
7595 }
7596 inline std::string* ValueInfoProto::_internal_mutable_name() {
7597   ::google::protobuf::internal::TSanWrite(&_impl_);
7598   _impl_._has_bits_[0] |= 0x00000001u;
7599   return _impl_.name_.Mutable( GetArena());
7600 }
7601 inline std::string* ValueInfoProto::release_name() {
7602   ::google::protobuf::internal::TSanWrite(&_impl_);
7603   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
7604   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
7605     return nullptr;
7606   }
7607   _impl_._has_bits_[0] &= ~0x00000001u;
7608   auto* released = _impl_.name_.Release();
7609   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7610   _impl_.name_.Set("", GetArena());
7611   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7612   return released;
7613 }
7614 inline void ValueInfoProto::set_allocated_name(std::string* value) {
7615   ::google::protobuf::internal::TSanWrite(&_impl_);
7616   if (value != nullptr) {
7617     _impl_._has_bits_[0] |= 0x00000001u;
7618   } else {
7619     _impl_._has_bits_[0] &= ~0x00000001u;
7620   }
7621   _impl_.name_.SetAllocated(value, GetArena());
7622   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7623         if (_impl_.name_.IsDefault()) {
7624           _impl_.name_.Set("", GetArena());
7625         }
7626   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7627   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
7628 }
7629
7630 // optional .onnx.TypeProto type = 2;
7631 inline bool ValueInfoProto::has_type() const {
7632   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
7633   PROTOBUF_ASSUME(!value || _impl_.type_ != nullptr);
7634   return value;
7635 }
7636 inline void ValueInfoProto::clear_type() {
7637   ::google::protobuf::internal::TSanWrite(&_impl_);
7638   if (_impl_.type_ != nullptr) _impl_.type_->Clear();
7639   _impl_._has_bits_[0] &= ~0x00000004u;
7640 }
7641 inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
7642   ::google::protobuf::internal::TSanRead(&_impl_);
7643   const ::onnx::TypeProto* p = _impl_.type_;
7644   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
7645 }
7646 inline const ::onnx::TypeProto& ValueInfoProto::type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7647   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
7648   return _internal_type();
7649 }
7650 inline void ValueInfoProto::unsafe_arena_set_allocated_type(::onnx::TypeProto* value) {
7651   ::google::protobuf::internal::TSanWrite(&_impl_);
7652   if (GetArena() == nullptr) {
7653     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
7654   }
7655   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
7656   if (value != nullptr) {
7657     _impl_._has_bits_[0] |= 0x00000004u;
7658   } else {
7659     _impl_._has_bits_[0] &= ~0x00000004u;
7660   }
7661   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
7662 }
7663 inline ::onnx::TypeProto* ValueInfoProto::release_type() {
7664   ::google::protobuf::internal::TSanWrite(&_impl_);
7665
7666   _impl_._has_bits_[0] &= ~0x00000004u;
7667   ::onnx::TypeProto* released = _impl_.type_;
7668   _impl_.type_ = nullptr;
7669 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7670   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7671   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7672   if (GetArena() == nullptr) {
7673     delete old;
7674   }
7675 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
7676   if (GetArena() != nullptr) {
7677     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7678   }
7679 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7680   return released;
7681 }
7682 inline ::onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
7683   ::google::protobuf::internal::TSanWrite(&_impl_);
7684   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)
7685
7686   _impl_._has_bits_[0] &= ~0x00000004u;
7687   ::onnx::TypeProto* temp = _impl_.type_;
7688   _impl_.type_ = nullptr;
7689   return temp;
7690 }
7691 inline ::onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
7692   ::google::protobuf::internal::TSanWrite(&_impl_);
7693   if (_impl_.type_ == nullptr) {
7694     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
7695     _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(p);
7696   }
7697   return _impl_.type_;
7698 }
7699 inline ::onnx::TypeProto* ValueInfoProto::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7700   _impl_._has_bits_[0] |= 0x00000004u;
7701   ::onnx::TypeProto* _msg = _internal_mutable_type();
7702   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
7703   return _msg;
7704 }
7705 inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* value) {
7706   ::google::protobuf::Arena* message_arena = GetArena();
7707   ::google::protobuf::internal::TSanWrite(&_impl_);
7708   if (message_arena == nullptr) {
7709     delete (_impl_.type_);
7710   }
7711
7712   if (value != nullptr) {
7713     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
7714     if (message_arena != submessage_arena) {
7715       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7716     }
7717     _impl_._has_bits_[0] |= 0x00000004u;
7718   } else {
7719     _impl_._has_bits_[0] &= ~0x00000004u;
7720   }
7721
7722   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
7723   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
7724 }
7725
7726 // optional string doc_string = 3;
7727 inline bool ValueInfoProto::has_doc_string() const {
7728   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
7729   return value;
7730 }
7731 inline void ValueInfoProto::clear_doc_string() {
7732   ::google::protobuf::internal::TSanWrite(&_impl_);
7733   _impl_.doc_string_.ClearToEmpty();
7734   _impl_._has_bits_[0] &= ~0x00000002u;
7735 }
7736 inline const std::string& ValueInfoProto::doc_string() const
7737     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7738   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
7739   return _internal_doc_string();
7740 }
7741 template <typename Arg_, typename... Args_>
7742 inline PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_doc_string(Arg_&& arg,
7743                                                      Args_... args) {
7744   ::google::protobuf::internal::TSanWrite(&_impl_);
7745   _impl_._has_bits_[0] |= 0x00000002u;
7746   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
7747   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
7748 }
7749 inline std::string* ValueInfoProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7750   std::string* _s = _internal_mutable_doc_string();
7751   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
7752   return _s;
7753 }
7754 inline const std::string& ValueInfoProto::_internal_doc_string() const {
7755   ::google::protobuf::internal::TSanRead(&_impl_);
7756   return _impl_.doc_string_.Get();
7757 }
7758 inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
7759   ::google::protobuf::internal::TSanWrite(&_impl_);
7760   _impl_._has_bits_[0] |= 0x00000002u;
7761   _impl_.doc_string_.Set(value, GetArena());
7762 }
7763 inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
7764   ::google::protobuf::internal::TSanWrite(&_impl_);
7765   _impl_._has_bits_[0] |= 0x00000002u;
7766   return _impl_.doc_string_.Mutable( GetArena());
7767 }
7768 inline std::string* ValueInfoProto::release_doc_string() {
7769   ::google::protobuf::internal::TSanWrite(&_impl_);
7770   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
7771   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
7772     return nullptr;
7773   }
7774   _impl_._has_bits_[0] &= ~0x00000002u;
7775   auto* released = _impl_.doc_string_.Release();
7776   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7777   _impl_.doc_string_.Set("", GetArena());
7778   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7779   return released;
7780 }
7781 inline void ValueInfoProto::set_allocated_doc_string(std::string* value) {
7782   ::google::protobuf::internal::TSanWrite(&_impl_);
7783   if (value != nullptr) {
7784     _impl_._has_bits_[0] |= 0x00000002u;
7785   } else {
7786     _impl_._has_bits_[0] &= ~0x00000002u;
7787   }
7788   _impl_.doc_string_.SetAllocated(value, GetArena());
7789   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7790         if (_impl_.doc_string_.IsDefault()) {
7791           _impl_.doc_string_.Set("", GetArena());
7792         }
7793   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7794   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
7795 }
7796
7797 // repeated .onnx.StringStringEntryProto metadata_props = 4;
7798 inline int ValueInfoProto::_internal_metadata_props_size() const {
7799   return _internal_metadata_props().size();
7800 }
7801 inline int ValueInfoProto::metadata_props_size() const {
7802   return _internal_metadata_props_size();
7803 }
7804 inline void ValueInfoProto::clear_metadata_props() {
7805   ::google::protobuf::internal::TSanWrite(&_impl_);
7806   _impl_.metadata_props_.Clear();
7807 }
7808 inline ::onnx::StringStringEntryProto* ValueInfoProto::mutable_metadata_props(int index)
7809     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7810   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props)
7811   return _internal_mutable_metadata_props()->Mutable(index);
7812 }
7813 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* ValueInfoProto::mutable_metadata_props()
7814     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7815   // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props)
7816   ::google::protobuf::internal::TSanWrite(&_impl_);
7817   return _internal_mutable_metadata_props();
7818 }
7819 inline const ::onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const
7820     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7821   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props)
7822   return _internal_metadata_props().Get(index);
7823 }
7824 inline ::onnx::StringStringEntryProto* ValueInfoProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7825   ::google::protobuf::internal::TSanWrite(&_impl_);
7826   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
7827   // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props)
7828   return _add;
7829 }
7830 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ValueInfoProto::metadata_props() const
7831     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7832   // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props)
7833   return _internal_metadata_props();
7834 }
7835 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
7836 ValueInfoProto::_internal_metadata_props() const {
7837   ::google::protobuf::internal::TSanRead(&_impl_);
7838   return _impl_.metadata_props_;
7839 }
7840 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
7841 ValueInfoProto::_internal_mutable_metadata_props() {
7842   ::google::protobuf::internal::TSanRead(&_impl_);
7843   return &_impl_.metadata_props_;
7844 }
7845
7846 // -------------------------------------------------------------------
7847
7848 // NodeProto
7849
7850 // repeated string input = 1;
7851 inline int NodeProto::_internal_input_size() const {
7852   return _internal_input().size();
7853 }
7854 inline int NodeProto::input_size() const {
7855   return _internal_input_size();
7856 }
7857 inline void NodeProto::clear_input() {
7858   ::google::protobuf::internal::TSanWrite(&_impl_);
7859   _impl_.input_.Clear();
7860 }
7861 inline std::string* NodeProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7862   ::google::protobuf::internal::TSanWrite(&_impl_);
7863   std::string* _s = _internal_mutable_input()->Add();
7864   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
7865   return _s;
7866 }
7867 inline const std::string& NodeProto::input(int index) const
7868     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7869   // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
7870   return _internal_input().Get(index);
7871 }
7872 inline std::string* NodeProto::mutable_input(int index)
7873     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7874   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
7875   return _internal_mutable_input()->Mutable(index);
7876 }
7877 template <typename Arg_, typename... Args_>
7878 inline void NodeProto::set_input(int index, Arg_&& value, Args_... args) {
7879   ::google::protobuf::internal::AssignToString(
7880       *_internal_mutable_input()->Mutable(index),
7881       std::forward<Arg_>(value), args... );
7882   // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
7883 }
7884 template <typename Arg_, typename... Args_>
7885 inline void NodeProto::add_input(Arg_&& value, Args_... args) {
7886   ::google::protobuf::internal::TSanWrite(&_impl_);
7887   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
7888                                std::forward<Arg_>(value),
7889                                args... );
7890   // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
7891 }
7892 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7893 NodeProto::input() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7894   // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
7895   return _internal_input();
7896 }
7897 inline ::google::protobuf::RepeatedPtrField<std::string>*
7898 NodeProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7899   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
7900   ::google::protobuf::internal::TSanWrite(&_impl_);
7901   return _internal_mutable_input();
7902 }
7903 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7904 NodeProto::_internal_input() const {
7905   ::google::protobuf::internal::TSanRead(&_impl_);
7906   return _impl_.input_;
7907 }
7908 inline ::google::protobuf::RepeatedPtrField<std::string>*
7909 NodeProto::_internal_mutable_input() {
7910   ::google::protobuf::internal::TSanRead(&_impl_);
7911   return &_impl_.input_;
7912 }
7913
7914 // repeated string output = 2;
7915 inline int NodeProto::_internal_output_size() const {
7916   return _internal_output().size();
7917 }
7918 inline int NodeProto::output_size() const {
7919   return _internal_output_size();
7920 }
7921 inline void NodeProto::clear_output() {
7922   ::google::protobuf::internal::TSanWrite(&_impl_);
7923   _impl_.output_.Clear();
7924 }
7925 inline std::string* NodeProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7926   ::google::protobuf::internal::TSanWrite(&_impl_);
7927   std::string* _s = _internal_mutable_output()->Add();
7928   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
7929   return _s;
7930 }
7931 inline const std::string& NodeProto::output(int index) const
7932     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7933   // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
7934   return _internal_output().Get(index);
7935 }
7936 inline std::string* NodeProto::mutable_output(int index)
7937     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7938   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
7939   return _internal_mutable_output()->Mutable(index);
7940 }
7941 template <typename Arg_, typename... Args_>
7942 inline void NodeProto::set_output(int index, Arg_&& value, Args_... args) {
7943   ::google::protobuf::internal::AssignToString(
7944       *_internal_mutable_output()->Mutable(index),
7945       std::forward<Arg_>(value), args... );
7946   // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
7947 }
7948 template <typename Arg_, typename... Args_>
7949 inline void NodeProto::add_output(Arg_&& value, Args_... args) {
7950   ::google::protobuf::internal::TSanWrite(&_impl_);
7951   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
7952                                std::forward<Arg_>(value),
7953                                args... );
7954   // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
7955 }
7956 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7957 NodeProto::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7958   // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
7959   return _internal_output();
7960 }
7961 inline ::google::protobuf::RepeatedPtrField<std::string>*
7962 NodeProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7963   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
7964   ::google::protobuf::internal::TSanWrite(&_impl_);
7965   return _internal_mutable_output();
7966 }
7967 inline const ::google::protobuf::RepeatedPtrField<std::string>&
7968 NodeProto::_internal_output() const {
7969   ::google::protobuf::internal::TSanRead(&_impl_);
7970   return _impl_.output_;
7971 }
7972 inline ::google::protobuf::RepeatedPtrField<std::string>*
7973 NodeProto::_internal_mutable_output() {
7974   ::google::protobuf::internal::TSanRead(&_impl_);
7975   return &_impl_.output_;
7976 }
7977
7978 // optional string name = 3;
7979 inline bool NodeProto::has_name() const {
7980   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
7981   return value;
7982 }
7983 inline void NodeProto::clear_name() {
7984   ::google::protobuf::internal::TSanWrite(&_impl_);
7985   _impl_.name_.ClearToEmpty();
7986   _impl_._has_bits_[0] &= ~0x00000001u;
7987 }
7988 inline const std::string& NodeProto::name() const
7989     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7990   // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
7991   return _internal_name();
7992 }
7993 template <typename Arg_, typename... Args_>
7994 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_name(Arg_&& arg,
7995                                                      Args_... args) {
7996   ::google::protobuf::internal::TSanWrite(&_impl_);
7997   _impl_._has_bits_[0] |= 0x00000001u;
7998   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
7999   // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
8000 }
8001 inline std::string* NodeProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8002   std::string* _s = _internal_mutable_name();
8003   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
8004   return _s;
8005 }
8006 inline const std::string& NodeProto::_internal_name() const {
8007   ::google::protobuf::internal::TSanRead(&_impl_);
8008   return _impl_.name_.Get();
8009 }
8010 inline void NodeProto::_internal_set_name(const std::string& value) {
8011   ::google::protobuf::internal::TSanWrite(&_impl_);
8012   _impl_._has_bits_[0] |= 0x00000001u;
8013   _impl_.name_.Set(value, GetArena());
8014 }
8015 inline std::string* NodeProto::_internal_mutable_name() {
8016   ::google::protobuf::internal::TSanWrite(&_impl_);
8017   _impl_._has_bits_[0] |= 0x00000001u;
8018   return _impl_.name_.Mutable( GetArena());
8019 }
8020 inline std::string* NodeProto::release_name() {
8021   ::google::protobuf::internal::TSanWrite(&_impl_);
8022   // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
8023   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
8024     return nullptr;
8025   }
8026   _impl_._has_bits_[0] &= ~0x00000001u;
8027   auto* released = _impl_.name_.Release();
8028   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8029   _impl_.name_.Set("", GetArena());
8030   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8031   return released;
8032 }
8033 inline void NodeProto::set_allocated_name(std::string* value) {
8034   ::google::protobuf::internal::TSanWrite(&_impl_);
8035   if (value != nullptr) {
8036     _impl_._has_bits_[0] |= 0x00000001u;
8037   } else {
8038     _impl_._has_bits_[0] &= ~0x00000001u;
8039   }
8040   _impl_.name_.SetAllocated(value, GetArena());
8041   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8042         if (_impl_.name_.IsDefault()) {
8043           _impl_.name_.Set("", GetArena());
8044         }
8045   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8046   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
8047 }
8048
8049 // optional string op_type = 4;
8050 inline bool NodeProto::has_op_type() const {
8051   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
8052   return value;
8053 }
8054 inline void NodeProto::clear_op_type() {
8055   ::google::protobuf::internal::TSanWrite(&_impl_);
8056   _impl_.op_type_.ClearToEmpty();
8057   _impl_._has_bits_[0] &= ~0x00000002u;
8058 }
8059 inline const std::string& NodeProto::op_type() const
8060     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8061   // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
8062   return _internal_op_type();
8063 }
8064 template <typename Arg_, typename... Args_>
8065 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_op_type(Arg_&& arg,
8066                                                      Args_... args) {
8067   ::google::protobuf::internal::TSanWrite(&_impl_);
8068   _impl_._has_bits_[0] |= 0x00000002u;
8069   _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8070   // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
8071 }
8072 inline std::string* NodeProto::mutable_op_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8073   std::string* _s = _internal_mutable_op_type();
8074   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
8075   return _s;
8076 }
8077 inline const std::string& NodeProto::_internal_op_type() const {
8078   ::google::protobuf::internal::TSanRead(&_impl_);
8079   return _impl_.op_type_.Get();
8080 }
8081 inline void NodeProto::_internal_set_op_type(const std::string& value) {
8082   ::google::protobuf::internal::TSanWrite(&_impl_);
8083   _impl_._has_bits_[0] |= 0x00000002u;
8084   _impl_.op_type_.Set(value, GetArena());
8085 }
8086 inline std::string* NodeProto::_internal_mutable_op_type() {
8087   ::google::protobuf::internal::TSanWrite(&_impl_);
8088   _impl_._has_bits_[0] |= 0x00000002u;
8089   return _impl_.op_type_.Mutable( GetArena());
8090 }
8091 inline std::string* NodeProto::release_op_type() {
8092   ::google::protobuf::internal::TSanWrite(&_impl_);
8093   // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
8094   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
8095     return nullptr;
8096   }
8097   _impl_._has_bits_[0] &= ~0x00000002u;
8098   auto* released = _impl_.op_type_.Release();
8099   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8100   _impl_.op_type_.Set("", GetArena());
8101   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8102   return released;
8103 }
8104 inline void NodeProto::set_allocated_op_type(std::string* value) {
8105   ::google::protobuf::internal::TSanWrite(&_impl_);
8106   if (value != nullptr) {
8107     _impl_._has_bits_[0] |= 0x00000002u;
8108   } else {
8109     _impl_._has_bits_[0] &= ~0x00000002u;
8110   }
8111   _impl_.op_type_.SetAllocated(value, GetArena());
8112   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8113         if (_impl_.op_type_.IsDefault()) {
8114           _impl_.op_type_.Set("", GetArena());
8115         }
8116   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8117   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type)
8118 }
8119
8120 // optional string domain = 7;
8121 inline bool NodeProto::has_domain() const {
8122   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
8123   return value;
8124 }
8125 inline void NodeProto::clear_domain() {
8126   ::google::protobuf::internal::TSanWrite(&_impl_);
8127   _impl_.domain_.ClearToEmpty();
8128   _impl_._has_bits_[0] &= ~0x00000008u;
8129 }
8130 inline const std::string& NodeProto::domain() const
8131     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8132   // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
8133   return _internal_domain();
8134 }
8135 template <typename Arg_, typename... Args_>
8136 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_domain(Arg_&& arg,
8137                                                      Args_... args) {
8138   ::google::protobuf::internal::TSanWrite(&_impl_);
8139   _impl_._has_bits_[0] |= 0x00000008u;
8140   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8141   // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
8142 }
8143 inline std::string* NodeProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8144   std::string* _s = _internal_mutable_domain();
8145   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
8146   return _s;
8147 }
8148 inline const std::string& NodeProto::_internal_domain() const {
8149   ::google::protobuf::internal::TSanRead(&_impl_);
8150   return _impl_.domain_.Get();
8151 }
8152 inline void NodeProto::_internal_set_domain(const std::string& value) {
8153   ::google::protobuf::internal::TSanWrite(&_impl_);
8154   _impl_._has_bits_[0] |= 0x00000008u;
8155   _impl_.domain_.Set(value, GetArena());
8156 }
8157 inline std::string* NodeProto::_internal_mutable_domain() {
8158   ::google::protobuf::internal::TSanWrite(&_impl_);
8159   _impl_._has_bits_[0] |= 0x00000008u;
8160   return _impl_.domain_.Mutable( GetArena());
8161 }
8162 inline std::string* NodeProto::release_domain() {
8163   ::google::protobuf::internal::TSanWrite(&_impl_);
8164   // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
8165   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
8166     return nullptr;
8167   }
8168   _impl_._has_bits_[0] &= ~0x00000008u;
8169   auto* released = _impl_.domain_.Release();
8170   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8171   _impl_.domain_.Set("", GetArena());
8172   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8173   return released;
8174 }
8175 inline void NodeProto::set_allocated_domain(std::string* value) {
8176   ::google::protobuf::internal::TSanWrite(&_impl_);
8177   if (value != nullptr) {
8178     _impl_._has_bits_[0] |= 0x00000008u;
8179   } else {
8180     _impl_._has_bits_[0] &= ~0x00000008u;
8181   }
8182   _impl_.domain_.SetAllocated(value, GetArena());
8183   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8184         if (_impl_.domain_.IsDefault()) {
8185           _impl_.domain_.Set("", GetArena());
8186         }
8187   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8188   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
8189 }
8190
8191 // optional string overload = 8;
8192 inline bool NodeProto::has_overload() const {
8193   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
8194   return value;
8195 }
8196 inline void NodeProto::clear_overload() {
8197   ::google::protobuf::internal::TSanWrite(&_impl_);
8198   _impl_.overload_.ClearToEmpty();
8199   _impl_._has_bits_[0] &= ~0x00000010u;
8200 }
8201 inline const std::string& NodeProto::overload() const
8202     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8203   // @@protoc_insertion_point(field_get:onnx.NodeProto.overload)
8204   return _internal_overload();
8205 }
8206 template <typename Arg_, typename... Args_>
8207 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_overload(Arg_&& arg,
8208                                                      Args_... args) {
8209   ::google::protobuf::internal::TSanWrite(&_impl_);
8210   _impl_._has_bits_[0] |= 0x00000010u;
8211   _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8212   // @@protoc_insertion_point(field_set:onnx.NodeProto.overload)
8213 }
8214 inline std::string* NodeProto::mutable_overload() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8215   std::string* _s = _internal_mutable_overload();
8216   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload)
8217   return _s;
8218 }
8219 inline const std::string& NodeProto::_internal_overload() const {
8220   ::google::protobuf::internal::TSanRead(&_impl_);
8221   return _impl_.overload_.Get();
8222 }
8223 inline void NodeProto::_internal_set_overload(const std::string& value) {
8224   ::google::protobuf::internal::TSanWrite(&_impl_);
8225   _impl_._has_bits_[0] |= 0x00000010u;
8226   _impl_.overload_.Set(value, GetArena());
8227 }
8228 inline std::string* NodeProto::_internal_mutable_overload() {
8229   ::google::protobuf::internal::TSanWrite(&_impl_);
8230   _impl_._has_bits_[0] |= 0x00000010u;
8231   return _impl_.overload_.Mutable( GetArena());
8232 }
8233 inline std::string* NodeProto::release_overload() {
8234   ::google::protobuf::internal::TSanWrite(&_impl_);
8235   // @@protoc_insertion_point(field_release:onnx.NodeProto.overload)
8236   if ((_impl_._has_bits_[0] & 0x00000010u) == 0) {
8237     return nullptr;
8238   }
8239   _impl_._has_bits_[0] &= ~0x00000010u;
8240   auto* released = _impl_.overload_.Release();
8241   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8242   _impl_.overload_.Set("", GetArena());
8243   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8244   return released;
8245 }
8246 inline void NodeProto::set_allocated_overload(std::string* value) {
8247   ::google::protobuf::internal::TSanWrite(&_impl_);
8248   if (value != nullptr) {
8249     _impl_._has_bits_[0] |= 0x00000010u;
8250   } else {
8251     _impl_._has_bits_[0] &= ~0x00000010u;
8252   }
8253   _impl_.overload_.SetAllocated(value, GetArena());
8254   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8255         if (_impl_.overload_.IsDefault()) {
8256           _impl_.overload_.Set("", GetArena());
8257         }
8258   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8259   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload)
8260 }
8261
8262 // repeated .onnx.AttributeProto attribute = 5;
8263 inline int NodeProto::_internal_attribute_size() const {
8264   return _internal_attribute().size();
8265 }
8266 inline int NodeProto::attribute_size() const {
8267   return _internal_attribute_size();
8268 }
8269 inline void NodeProto::clear_attribute() {
8270   ::google::protobuf::internal::TSanWrite(&_impl_);
8271   _impl_.attribute_.Clear();
8272 }
8273 inline ::onnx::AttributeProto* NodeProto::mutable_attribute(int index)
8274     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8275   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
8276   return _internal_mutable_attribute()->Mutable(index);
8277 }
8278 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* NodeProto::mutable_attribute()
8279     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8280   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
8281   ::google::protobuf::internal::TSanWrite(&_impl_);
8282   return _internal_mutable_attribute();
8283 }
8284 inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const
8285     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8286   // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
8287   return _internal_attribute().Get(index);
8288 }
8289 inline ::onnx::AttributeProto* NodeProto::add_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8290   ::google::protobuf::internal::TSanWrite(&_impl_);
8291   ::onnx::AttributeProto* _add = _internal_mutable_attribute()->Add();
8292   // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
8293   return _add;
8294 }
8295 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& NodeProto::attribute() const
8296     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8297   // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
8298   return _internal_attribute();
8299 }
8300 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
8301 NodeProto::_internal_attribute() const {
8302   ::google::protobuf::internal::TSanRead(&_impl_);
8303   return _impl_.attribute_;
8304 }
8305 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>*
8306 NodeProto::_internal_mutable_attribute() {
8307   ::google::protobuf::internal::TSanRead(&_impl_);
8308   return &_impl_.attribute_;
8309 }
8310
8311 // optional string doc_string = 6;
8312 inline bool NodeProto::has_doc_string() const {
8313   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
8314   return value;
8315 }
8316 inline void NodeProto::clear_doc_string() {
8317   ::google::protobuf::internal::TSanWrite(&_impl_);
8318   _impl_.doc_string_.ClearToEmpty();
8319   _impl_._has_bits_[0] &= ~0x00000004u;
8320 }
8321 inline const std::string& NodeProto::doc_string() const
8322     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8323   // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
8324   return _internal_doc_string();
8325 }
8326 template <typename Arg_, typename... Args_>
8327 inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_doc_string(Arg_&& arg,
8328                                                      Args_... args) {
8329   ::google::protobuf::internal::TSanWrite(&_impl_);
8330   _impl_._has_bits_[0] |= 0x00000004u;
8331   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8332   // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
8333 }
8334 inline std::string* NodeProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8335   std::string* _s = _internal_mutable_doc_string();
8336   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
8337   return _s;
8338 }
8339 inline const std::string& NodeProto::_internal_doc_string() const {
8340   ::google::protobuf::internal::TSanRead(&_impl_);
8341   return _impl_.doc_string_.Get();
8342 }
8343 inline void NodeProto::_internal_set_doc_string(const std::string& value) {
8344   ::google::protobuf::internal::TSanWrite(&_impl_);
8345   _impl_._has_bits_[0] |= 0x00000004u;
8346   _impl_.doc_string_.Set(value, GetArena());
8347 }
8348 inline std::string* NodeProto::_internal_mutable_doc_string() {
8349   ::google::protobuf::internal::TSanWrite(&_impl_);
8350   _impl_._has_bits_[0] |= 0x00000004u;
8351   return _impl_.doc_string_.Mutable( GetArena());
8352 }
8353 inline std::string* NodeProto::release_doc_string() {
8354   ::google::protobuf::internal::TSanWrite(&_impl_);
8355   // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
8356   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
8357     return nullptr;
8358   }
8359   _impl_._has_bits_[0] &= ~0x00000004u;
8360   auto* released = _impl_.doc_string_.Release();
8361   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8362   _impl_.doc_string_.Set("", GetArena());
8363   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8364   return released;
8365 }
8366 inline void NodeProto::set_allocated_doc_string(std::string* value) {
8367   ::google::protobuf::internal::TSanWrite(&_impl_);
8368   if (value != nullptr) {
8369     _impl_._has_bits_[0] |= 0x00000004u;
8370   } else {
8371     _impl_._has_bits_[0] &= ~0x00000004u;
8372   }
8373   _impl_.doc_string_.SetAllocated(value, GetArena());
8374   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8375         if (_impl_.doc_string_.IsDefault()) {
8376           _impl_.doc_string_.Set("", GetArena());
8377         }
8378   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8379   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
8380 }
8381
8382 // repeated .onnx.StringStringEntryProto metadata_props = 9;
8383 inline int NodeProto::_internal_metadata_props_size() const {
8384   return _internal_metadata_props().size();
8385 }
8386 inline int NodeProto::metadata_props_size() const {
8387   return _internal_metadata_props_size();
8388 }
8389 inline void NodeProto::clear_metadata_props() {
8390   ::google::protobuf::internal::TSanWrite(&_impl_);
8391   _impl_.metadata_props_.Clear();
8392 }
8393 inline ::onnx::StringStringEntryProto* NodeProto::mutable_metadata_props(int index)
8394     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8395   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props)
8396   return _internal_mutable_metadata_props()->Mutable(index);
8397 }
8398 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* NodeProto::mutable_metadata_props()
8399     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8400   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props)
8401   ::google::protobuf::internal::TSanWrite(&_impl_);
8402   return _internal_mutable_metadata_props();
8403 }
8404 inline const ::onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const
8405     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8406   // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props)
8407   return _internal_metadata_props().Get(index);
8408 }
8409 inline ::onnx::StringStringEntryProto* NodeProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8410   ::google::protobuf::internal::TSanWrite(&_impl_);
8411   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
8412   // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props)
8413   return _add;
8414 }
8415 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& NodeProto::metadata_props() const
8416     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8417   // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props)
8418   return _internal_metadata_props();
8419 }
8420 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8421 NodeProto::_internal_metadata_props() const {
8422   ::google::protobuf::internal::TSanRead(&_impl_);
8423   return _impl_.metadata_props_;
8424 }
8425 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
8426 NodeProto::_internal_mutable_metadata_props() {
8427   ::google::protobuf::internal::TSanRead(&_impl_);
8428   return &_impl_.metadata_props_;
8429 }
8430
8431 // -------------------------------------------------------------------
8432
8433 // TrainingInfoProto
8434
8435 // optional .onnx.GraphProto initialization = 1;
8436 inline bool TrainingInfoProto::has_initialization() const {
8437   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
8438   PROTOBUF_ASSUME(!value || _impl_.initialization_ != nullptr);
8439   return value;
8440 }
8441 inline void TrainingInfoProto::clear_initialization() {
8442   ::google::protobuf::internal::TSanWrite(&_impl_);
8443   if (_impl_.initialization_ != nullptr) _impl_.initialization_->Clear();
8444   _impl_._has_bits_[0] &= ~0x00000001u;
8445 }
8446 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
8447   ::google::protobuf::internal::TSanRead(&_impl_);
8448   const ::onnx::GraphProto* p = _impl_.initialization_;
8449   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
8450 }
8451 inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8452   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
8453   return _internal_initialization();
8454 }
8455 inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(::onnx::GraphProto* value) {
8456   ::google::protobuf::internal::TSanWrite(&_impl_);
8457   if (GetArena() == nullptr) {
8458     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
8459   }
8460   _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
8461   if (value != nullptr) {
8462     _impl_._has_bits_[0] |= 0x00000001u;
8463   } else {
8464     _impl_._has_bits_[0] &= ~0x00000001u;
8465   }
8466   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
8467 }
8468 inline ::onnx::GraphProto* TrainingInfoProto::release_initialization() {
8469   ::google::protobuf::internal::TSanWrite(&_impl_);
8470
8471   _impl_._has_bits_[0] &= ~0x00000001u;
8472   ::onnx::GraphProto* released = _impl_.initialization_;
8473   _impl_.initialization_ = nullptr;
8474 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8475   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
8476   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8477   if (GetArena() == nullptr) {
8478     delete old;
8479   }
8480 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
8481   if (GetArena() != nullptr) {
8482     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8483   }
8484 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8485   return released;
8486 }
8487 inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_initialization() {
8488   ::google::protobuf::internal::TSanWrite(&_impl_);
8489   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)
8490
8491   _impl_._has_bits_[0] &= ~0x00000001u;
8492   ::onnx::GraphProto* temp = _impl_.initialization_;
8493   _impl_.initialization_ = nullptr;
8494   return temp;
8495 }
8496 inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_initialization() {
8497   ::google::protobuf::internal::TSanWrite(&_impl_);
8498   if (_impl_.initialization_ == nullptr) {
8499     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
8500     _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(p);
8501   }
8502   return _impl_.initialization_;
8503 }
8504 inline ::onnx::GraphProto* TrainingInfoProto::mutable_initialization() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8505   _impl_._has_bits_[0] |= 0x00000001u;
8506   ::onnx::GraphProto* _msg = _internal_mutable_initialization();
8507   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
8508   return _msg;
8509 }
8510 inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* value) {
8511   ::google::protobuf::Arena* message_arena = GetArena();
8512   ::google::protobuf::internal::TSanWrite(&_impl_);
8513   if (message_arena == nullptr) {
8514     delete (_impl_.initialization_);
8515   }
8516
8517   if (value != nullptr) {
8518     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
8519     if (message_arena != submessage_arena) {
8520       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
8521     }
8522     _impl_._has_bits_[0] |= 0x00000001u;
8523   } else {
8524     _impl_._has_bits_[0] &= ~0x00000001u;
8525   }
8526
8527   _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
8528   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
8529 }
8530
8531 // optional .onnx.GraphProto algorithm = 2;
8532 inline bool TrainingInfoProto::has_algorithm() const {
8533   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
8534   PROTOBUF_ASSUME(!value || _impl_.algorithm_ != nullptr);
8535   return value;
8536 }
8537 inline void TrainingInfoProto::clear_algorithm() {
8538   ::google::protobuf::internal::TSanWrite(&_impl_);
8539   if (_impl_.algorithm_ != nullptr) _impl_.algorithm_->Clear();
8540   _impl_._has_bits_[0] &= ~0x00000002u;
8541 }
8542 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
8543   ::google::protobuf::internal::TSanRead(&_impl_);
8544   const ::onnx::GraphProto* p = _impl_.algorithm_;
8545   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
8546 }
8547 inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8548   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
8549   return _internal_algorithm();
8550 }
8551 inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* value) {
8552   ::google::protobuf::internal::TSanWrite(&_impl_);
8553   if (GetArena() == nullptr) {
8554     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
8555   }
8556   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
8557   if (value != nullptr) {
8558     _impl_._has_bits_[0] |= 0x00000002u;
8559   } else {
8560     _impl_._has_bits_[0] &= ~0x00000002u;
8561   }
8562   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
8563 }
8564 inline ::onnx::GraphProto* TrainingInfoProto::release_algorithm() {
8565   ::google::protobuf::internal::TSanWrite(&_impl_);
8566
8567   _impl_._has_bits_[0] &= ~0x00000002u;
8568   ::onnx::GraphProto* released = _impl_.algorithm_;
8569   _impl_.algorithm_ = nullptr;
8570 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8571   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
8572   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8573   if (GetArena() == nullptr) {
8574     delete old;
8575   }
8576 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
8577   if (GetArena() != nullptr) {
8578     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8579   }
8580 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8581   return released;
8582 }
8583 inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_algorithm() {
8584   ::google::protobuf::internal::TSanWrite(&_impl_);
8585   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)
8586
8587   _impl_._has_bits_[0] &= ~0x00000002u;
8588   ::onnx::GraphProto* temp = _impl_.algorithm_;
8589   _impl_.algorithm_ = nullptr;
8590   return temp;
8591 }
8592 inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_algorithm() {
8593   ::google::protobuf::internal::TSanWrite(&_impl_);
8594   if (_impl_.algorithm_ == nullptr) {
8595     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
8596     _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(p);
8597   }
8598   return _impl_.algorithm_;
8599 }
8600 inline ::onnx::GraphProto* TrainingInfoProto::mutable_algorithm() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8601   _impl_._has_bits_[0] |= 0x00000002u;
8602   ::onnx::GraphProto* _msg = _internal_mutable_algorithm();
8603   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
8604   return _msg;
8605 }
8606 inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* value) {
8607   ::google::protobuf::Arena* message_arena = GetArena();
8608   ::google::protobuf::internal::TSanWrite(&_impl_);
8609   if (message_arena == nullptr) {
8610     delete (_impl_.algorithm_);
8611   }
8612
8613   if (value != nullptr) {
8614     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
8615     if (message_arena != submessage_arena) {
8616       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
8617     }
8618     _impl_._has_bits_[0] |= 0x00000002u;
8619   } else {
8620     _impl_._has_bits_[0] &= ~0x00000002u;
8621   }
8622
8623   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
8624   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
8625 }
8626
8627 // repeated .onnx.StringStringEntryProto initialization_binding = 3;
8628 inline int TrainingInfoProto::_internal_initialization_binding_size() const {
8629   return _internal_initialization_binding().size();
8630 }
8631 inline int TrainingInfoProto::initialization_binding_size() const {
8632   return _internal_initialization_binding_size();
8633 }
8634 inline void TrainingInfoProto::clear_initialization_binding() {
8635   ::google::protobuf::internal::TSanWrite(&_impl_);
8636   _impl_.initialization_binding_.Clear();
8637 }
8638 inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_initialization_binding(int index)
8639     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8640   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
8641   return _internal_mutable_initialization_binding()->Mutable(index);
8642 }
8643 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TrainingInfoProto::mutable_initialization_binding()
8644     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8645   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
8646   ::google::protobuf::internal::TSanWrite(&_impl_);
8647   return _internal_mutable_initialization_binding();
8648 }
8649 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const
8650     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8651   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
8652   return _internal_initialization_binding().Get(index);
8653 }
8654 inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_initialization_binding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8655   ::google::protobuf::internal::TSanWrite(&_impl_);
8656   ::onnx::StringStringEntryProto* _add = _internal_mutable_initialization_binding()->Add();
8657   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
8658   return _add;
8659 }
8660 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::initialization_binding() const
8661     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8662   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
8663   return _internal_initialization_binding();
8664 }
8665 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8666 TrainingInfoProto::_internal_initialization_binding() const {
8667   ::google::protobuf::internal::TSanRead(&_impl_);
8668   return _impl_.initialization_binding_;
8669 }
8670 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
8671 TrainingInfoProto::_internal_mutable_initialization_binding() {
8672   ::google::protobuf::internal::TSanRead(&_impl_);
8673   return &_impl_.initialization_binding_;
8674 }
8675
8676 // repeated .onnx.StringStringEntryProto update_binding = 4;
8677 inline int TrainingInfoProto::_internal_update_binding_size() const {
8678   return _internal_update_binding().size();
8679 }
8680 inline int TrainingInfoProto::update_binding_size() const {
8681   return _internal_update_binding_size();
8682 }
8683 inline void TrainingInfoProto::clear_update_binding() {
8684   ::google::protobuf::internal::TSanWrite(&_impl_);
8685   _impl_.update_binding_.Clear();
8686 }
8687 inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_update_binding(int index)
8688     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8689   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
8690   return _internal_mutable_update_binding()->Mutable(index);
8691 }
8692 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TrainingInfoProto::mutable_update_binding()
8693     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8694   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
8695   ::google::protobuf::internal::TSanWrite(&_impl_);
8696   return _internal_mutable_update_binding();
8697 }
8698 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const
8699     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8700   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
8701   return _internal_update_binding().Get(index);
8702 }
8703 inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_update_binding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8704   ::google::protobuf::internal::TSanWrite(&_impl_);
8705   ::onnx::StringStringEntryProto* _add = _internal_mutable_update_binding()->Add();
8706   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
8707   return _add;
8708 }
8709 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::update_binding() const
8710     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8711   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
8712   return _internal_update_binding();
8713 }
8714 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8715 TrainingInfoProto::_internal_update_binding() const {
8716   ::google::protobuf::internal::TSanRead(&_impl_);
8717   return _impl_.update_binding_;
8718 }
8719 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
8720 TrainingInfoProto::_internal_mutable_update_binding() {
8721   ::google::protobuf::internal::TSanRead(&_impl_);
8722   return &_impl_.update_binding_;
8723 }
8724
8725 // -------------------------------------------------------------------
8726
8727 // ModelProto
8728
8729 // optional int64 ir_version = 1;
8730 inline bool ModelProto::has_ir_version() const {
8731   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
8732   return value;
8733 }
8734 inline void ModelProto::clear_ir_version() {
8735   ::google::protobuf::internal::TSanWrite(&_impl_);
8736   _impl_.ir_version_ = ::int64_t{0};
8737   _impl_._has_bits_[0] &= ~0x00000020u;
8738 }
8739 inline ::int64_t ModelProto::ir_version() const {
8740   // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
8741   return _internal_ir_version();
8742 }
8743 inline void ModelProto::set_ir_version(::int64_t value) {
8744   _internal_set_ir_version(value);
8745   _impl_._has_bits_[0] |= 0x00000020u;
8746   // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
8747 }
8748 inline ::int64_t ModelProto::_internal_ir_version() const {
8749   ::google::protobuf::internal::TSanRead(&_impl_);
8750   return _impl_.ir_version_;
8751 }
8752 inline void ModelProto::_internal_set_ir_version(::int64_t value) {
8753   ::google::protobuf::internal::TSanWrite(&_impl_);
8754   _impl_.ir_version_ = value;
8755 }
8756
8757 // repeated .onnx.OperatorSetIdProto opset_import = 8;
8758 inline int ModelProto::_internal_opset_import_size() const {
8759   return _internal_opset_import().size();
8760 }
8761 inline int ModelProto::opset_import_size() const {
8762   return _internal_opset_import_size();
8763 }
8764 inline void ModelProto::clear_opset_import() {
8765   ::google::protobuf::internal::TSanWrite(&_impl_);
8766   _impl_.opset_import_.Clear();
8767 }
8768 inline ::onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index)
8769     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8770   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
8771   return _internal_mutable_opset_import()->Mutable(index);
8772 }
8773 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* ModelProto::mutable_opset_import()
8774     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8775   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
8776   ::google::protobuf::internal::TSanWrite(&_impl_);
8777   return _internal_mutable_opset_import();
8778 }
8779 inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const
8780     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8781   // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
8782   return _internal_opset_import().Get(index);
8783 }
8784 inline ::onnx::OperatorSetIdProto* ModelProto::add_opset_import() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8785   ::google::protobuf::internal::TSanWrite(&_impl_);
8786   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
8787   // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
8788   return _add;
8789 }
8790 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& ModelProto::opset_import() const
8791     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8792   // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
8793   return _internal_opset_import();
8794 }
8795 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
8796 ModelProto::_internal_opset_import() const {
8797   ::google::protobuf::internal::TSanRead(&_impl_);
8798   return _impl_.opset_import_;
8799 }
8800 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>*
8801 ModelProto::_internal_mutable_opset_import() {
8802   ::google::protobuf::internal::TSanRead(&_impl_);
8803   return &_impl_.opset_import_;
8804 }
8805
8806 // optional string producer_name = 2;
8807 inline bool ModelProto::has_producer_name() const {
8808   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
8809   return value;
8810 }
8811 inline void ModelProto::clear_producer_name() {
8812   ::google::protobuf::internal::TSanWrite(&_impl_);
8813   _impl_.producer_name_.ClearToEmpty();
8814   _impl_._has_bits_[0] &= ~0x00000001u;
8815 }
8816 inline const std::string& ModelProto::producer_name() const
8817     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8818   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
8819   return _internal_producer_name();
8820 }
8821 template <typename Arg_, typename... Args_>
8822 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_name(Arg_&& arg,
8823                                                      Args_... args) {
8824   ::google::protobuf::internal::TSanWrite(&_impl_);
8825   _impl_._has_bits_[0] |= 0x00000001u;
8826   _impl_.producer_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8827   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
8828 }
8829 inline std::string* ModelProto::mutable_producer_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8830   std::string* _s = _internal_mutable_producer_name();
8831   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
8832   return _s;
8833 }
8834 inline const std::string& ModelProto::_internal_producer_name() const {
8835   ::google::protobuf::internal::TSanRead(&_impl_);
8836   return _impl_.producer_name_.Get();
8837 }
8838 inline void ModelProto::_internal_set_producer_name(const std::string& value) {
8839   ::google::protobuf::internal::TSanWrite(&_impl_);
8840   _impl_._has_bits_[0] |= 0x00000001u;
8841   _impl_.producer_name_.Set(value, GetArena());
8842 }
8843 inline std::string* ModelProto::_internal_mutable_producer_name() {
8844   ::google::protobuf::internal::TSanWrite(&_impl_);
8845   _impl_._has_bits_[0] |= 0x00000001u;
8846   return _impl_.producer_name_.Mutable( GetArena());
8847 }
8848 inline std::string* ModelProto::release_producer_name() {
8849   ::google::protobuf::internal::TSanWrite(&_impl_);
8850   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
8851   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
8852     return nullptr;
8853   }
8854   _impl_._has_bits_[0] &= ~0x00000001u;
8855   auto* released = _impl_.producer_name_.Release();
8856   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8857   _impl_.producer_name_.Set("", GetArena());
8858   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8859   return released;
8860 }
8861 inline void ModelProto::set_allocated_producer_name(std::string* value) {
8862   ::google::protobuf::internal::TSanWrite(&_impl_);
8863   if (value != nullptr) {
8864     _impl_._has_bits_[0] |= 0x00000001u;
8865   } else {
8866     _impl_._has_bits_[0] &= ~0x00000001u;
8867   }
8868   _impl_.producer_name_.SetAllocated(value, GetArena());
8869   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8870         if (_impl_.producer_name_.IsDefault()) {
8871           _impl_.producer_name_.Set("", GetArena());
8872         }
8873   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8874   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
8875 }
8876
8877 // optional string producer_version = 3;
8878 inline bool ModelProto::has_producer_version() const {
8879   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
8880   return value;
8881 }
8882 inline void ModelProto::clear_producer_version() {
8883   ::google::protobuf::internal::TSanWrite(&_impl_);
8884   _impl_.producer_version_.ClearToEmpty();
8885   _impl_._has_bits_[0] &= ~0x00000002u;
8886 }
8887 inline const std::string& ModelProto::producer_version() const
8888     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8889   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
8890   return _internal_producer_version();
8891 }
8892 template <typename Arg_, typename... Args_>
8893 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_version(Arg_&& arg,
8894                                                      Args_... args) {
8895   ::google::protobuf::internal::TSanWrite(&_impl_);
8896   _impl_._has_bits_[0] |= 0x00000002u;
8897   _impl_.producer_version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8898   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
8899 }
8900 inline std::string* ModelProto::mutable_producer_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8901   std::string* _s = _internal_mutable_producer_version();
8902   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
8903   return _s;
8904 }
8905 inline const std::string& ModelProto::_internal_producer_version() const {
8906   ::google::protobuf::internal::TSanRead(&_impl_);
8907   return _impl_.producer_version_.Get();
8908 }
8909 inline void ModelProto::_internal_set_producer_version(const std::string& value) {
8910   ::google::protobuf::internal::TSanWrite(&_impl_);
8911   _impl_._has_bits_[0] |= 0x00000002u;
8912   _impl_.producer_version_.Set(value, GetArena());
8913 }
8914 inline std::string* ModelProto::_internal_mutable_producer_version() {
8915   ::google::protobuf::internal::TSanWrite(&_impl_);
8916   _impl_._has_bits_[0] |= 0x00000002u;
8917   return _impl_.producer_version_.Mutable( GetArena());
8918 }
8919 inline std::string* ModelProto::release_producer_version() {
8920   ::google::protobuf::internal::TSanWrite(&_impl_);
8921   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
8922   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
8923     return nullptr;
8924   }
8925   _impl_._has_bits_[0] &= ~0x00000002u;
8926   auto* released = _impl_.producer_version_.Release();
8927   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8928   _impl_.producer_version_.Set("", GetArena());
8929   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8930   return released;
8931 }
8932 inline void ModelProto::set_allocated_producer_version(std::string* value) {
8933   ::google::protobuf::internal::TSanWrite(&_impl_);
8934   if (value != nullptr) {
8935     _impl_._has_bits_[0] |= 0x00000002u;
8936   } else {
8937     _impl_._has_bits_[0] &= ~0x00000002u;
8938   }
8939   _impl_.producer_version_.SetAllocated(value, GetArena());
8940   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8941         if (_impl_.producer_version_.IsDefault()) {
8942           _impl_.producer_version_.Set("", GetArena());
8943         }
8944   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8945   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
8946 }
8947
8948 // optional string domain = 4;
8949 inline bool ModelProto::has_domain() const {
8950   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
8951   return value;
8952 }
8953 inline void ModelProto::clear_domain() {
8954   ::google::protobuf::internal::TSanWrite(&_impl_);
8955   _impl_.domain_.ClearToEmpty();
8956   _impl_._has_bits_[0] &= ~0x00000004u;
8957 }
8958 inline const std::string& ModelProto::domain() const
8959     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8960   // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
8961   return _internal_domain();
8962 }
8963 template <typename Arg_, typename... Args_>
8964 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_domain(Arg_&& arg,
8965                                                      Args_... args) {
8966   ::google::protobuf::internal::TSanWrite(&_impl_);
8967   _impl_._has_bits_[0] |= 0x00000004u;
8968   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8969   // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
8970 }
8971 inline std::string* ModelProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8972   std::string* _s = _internal_mutable_domain();
8973   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
8974   return _s;
8975 }
8976 inline const std::string& ModelProto::_internal_domain() const {
8977   ::google::protobuf::internal::TSanRead(&_impl_);
8978   return _impl_.domain_.Get();
8979 }
8980 inline void ModelProto::_internal_set_domain(const std::string& value) {
8981   ::google::protobuf::internal::TSanWrite(&_impl_);
8982   _impl_._has_bits_[0] |= 0x00000004u;
8983   _impl_.domain_.Set(value, GetArena());
8984 }
8985 inline std::string* ModelProto::_internal_mutable_domain() {
8986   ::google::protobuf::internal::TSanWrite(&_impl_);
8987   _impl_._has_bits_[0] |= 0x00000004u;
8988   return _impl_.domain_.Mutable( GetArena());
8989 }
8990 inline std::string* ModelProto::release_domain() {
8991   ::google::protobuf::internal::TSanWrite(&_impl_);
8992   // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
8993   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
8994     return nullptr;
8995   }
8996   _impl_._has_bits_[0] &= ~0x00000004u;
8997   auto* released = _impl_.domain_.Release();
8998   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8999   _impl_.domain_.Set("", GetArena());
9000   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9001   return released;
9002 }
9003 inline void ModelProto::set_allocated_domain(std::string* value) {
9004   ::google::protobuf::internal::TSanWrite(&_impl_);
9005   if (value != nullptr) {
9006     _impl_._has_bits_[0] |= 0x00000004u;
9007   } else {
9008     _impl_._has_bits_[0] &= ~0x00000004u;
9009   }
9010   _impl_.domain_.SetAllocated(value, GetArena());
9011   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9012         if (_impl_.domain_.IsDefault()) {
9013           _impl_.domain_.Set("", GetArena());
9014         }
9015   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9016   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
9017 }
9018
9019 // optional int64 model_version = 5;
9020 inline bool ModelProto::has_model_version() const {
9021   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
9022   return value;
9023 }
9024 inline void ModelProto::clear_model_version() {
9025   ::google::protobuf::internal::TSanWrite(&_impl_);
9026   _impl_.model_version_ = ::int64_t{0};
9027   _impl_._has_bits_[0] &= ~0x00000040u;
9028 }
9029 inline ::int64_t ModelProto::model_version() const {
9030   // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
9031   return _internal_model_version();
9032 }
9033 inline void ModelProto::set_model_version(::int64_t value) {
9034   _internal_set_model_version(value);
9035   _impl_._has_bits_[0] |= 0x00000040u;
9036   // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
9037 }
9038 inline ::int64_t ModelProto::_internal_model_version() const {
9039   ::google::protobuf::internal::TSanRead(&_impl_);
9040   return _impl_.model_version_;
9041 }
9042 inline void ModelProto::_internal_set_model_version(::int64_t value) {
9043   ::google::protobuf::internal::TSanWrite(&_impl_);
9044   _impl_.model_version_ = value;
9045 }
9046
9047 // optional string doc_string = 6;
9048 inline bool ModelProto::has_doc_string() const {
9049   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
9050   return value;
9051 }
9052 inline void ModelProto::clear_doc_string() {
9053   ::google::protobuf::internal::TSanWrite(&_impl_);
9054   _impl_.doc_string_.ClearToEmpty();
9055   _impl_._has_bits_[0] &= ~0x00000008u;
9056 }
9057 inline const std::string& ModelProto::doc_string() const
9058     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9059   // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
9060   return _internal_doc_string();
9061 }
9062 template <typename Arg_, typename... Args_>
9063 inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_doc_string(Arg_&& arg,
9064                                                      Args_... args) {
9065   ::google::protobuf::internal::TSanWrite(&_impl_);
9066   _impl_._has_bits_[0] |= 0x00000008u;
9067   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9068   // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
9069 }
9070 inline std::string* ModelProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9071   std::string* _s = _internal_mutable_doc_string();
9072   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
9073   return _s;
9074 }
9075 inline const std::string& ModelProto::_internal_doc_string() const {
9076   ::google::protobuf::internal::TSanRead(&_impl_);
9077   return _impl_.doc_string_.Get();
9078 }
9079 inline void ModelProto::_internal_set_doc_string(const std::string& value) {
9080   ::google::protobuf::internal::TSanWrite(&_impl_);
9081   _impl_._has_bits_[0] |= 0x00000008u;
9082   _impl_.doc_string_.Set(value, GetArena());
9083 }
9084 inline std::string* ModelProto::_internal_mutable_doc_string() {
9085   ::google::protobuf::internal::TSanWrite(&_impl_);
9086   _impl_._has_bits_[0] |= 0x00000008u;
9087   return _impl_.doc_string_.Mutable( GetArena());
9088 }
9089 inline std::string* ModelProto::release_doc_string() {
9090   ::google::protobuf::internal::TSanWrite(&_impl_);
9091   // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
9092   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
9093     return nullptr;
9094   }
9095   _impl_._has_bits_[0] &= ~0x00000008u;
9096   auto* released = _impl_.doc_string_.Release();
9097   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9098   _impl_.doc_string_.Set("", GetArena());
9099   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9100   return released;
9101 }
9102 inline void ModelProto::set_allocated_doc_string(std::string* value) {
9103   ::google::protobuf::internal::TSanWrite(&_impl_);
9104   if (value != nullptr) {
9105     _impl_._has_bits_[0] |= 0x00000008u;
9106   } else {
9107     _impl_._has_bits_[0] &= ~0x00000008u;
9108   }
9109   _impl_.doc_string_.SetAllocated(value, GetArena());
9110   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9111         if (_impl_.doc_string_.IsDefault()) {
9112           _impl_.doc_string_.Set("", GetArena());
9113         }
9114   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9115   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
9116 }
9117
9118 // optional .onnx.GraphProto graph = 7;
9119 inline bool ModelProto::has_graph() const {
9120   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
9121   PROTOBUF_ASSUME(!value || _impl_.graph_ != nullptr);
9122   return value;
9123 }
9124 inline void ModelProto::clear_graph() {
9125   ::google::protobuf::internal::TSanWrite(&_impl_);
9126   if (_impl_.graph_ != nullptr) _impl_.graph_->Clear();
9127   _impl_._has_bits_[0] &= ~0x00000010u;
9128 }
9129 inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
9130   ::google::protobuf::internal::TSanRead(&_impl_);
9131   const ::onnx::GraphProto* p = _impl_.graph_;
9132   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
9133 }
9134 inline const ::onnx::GraphProto& ModelProto::graph() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
9135   // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
9136   return _internal_graph();
9137 }
9138 inline void ModelProto::unsafe_arena_set_allocated_graph(::onnx::GraphProto* value) {
9139   ::google::protobuf::internal::TSanWrite(&_impl_);
9140   if (GetArena() == nullptr) {
9141     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
9142   }
9143   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
9144   if (value != nullptr) {
9145     _impl_._has_bits_[0] |= 0x00000010u;
9146   } else {
9147     _impl_._has_bits_[0] &= ~0x00000010u;
9148   }
9149   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
9150 }
9151 inline ::onnx::GraphProto* ModelProto::release_graph() {
9152   ::google::protobuf::internal::TSanWrite(&_impl_);
9153
9154   _impl_._has_bits_[0] &= ~0x00000010u;
9155   ::onnx::GraphProto* released = _impl_.graph_;
9156   _impl_.graph_ = nullptr;
9157 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9158   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
9159   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
9160   if (GetArena() == nullptr) {
9161     delete old;
9162   }
9163 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
9164   if (GetArena() != nullptr) {
9165     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
9166   }
9167 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9168   return released;
9169 }
9170 inline ::onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
9171   ::google::protobuf::internal::TSanWrite(&_impl_);
9172   // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)
9173
9174   _impl_._has_bits_[0] &= ~0x00000010u;
9175   ::onnx::GraphProto* temp = _impl_.graph_;
9176   _impl_.graph_ = nullptr;
9177   return temp;
9178 }
9179 inline ::onnx::GraphProto* ModelProto::_internal_mutable_graph() {
9180   ::google::protobuf::internal::TSanWrite(&_impl_);
9181   if (_impl_.graph_ == nullptr) {
9182     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
9183     _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(p);
9184   }
9185   return _impl_.graph_;
9186 }
9187 inline ::onnx::GraphProto* ModelProto::mutable_graph() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9188   _impl_._has_bits_[0] |= 0x00000010u;
9189   ::onnx::GraphProto* _msg = _internal_mutable_graph();
9190   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
9191   return _msg;
9192 }
9193 inline void ModelProto::set_allocated_graph(::onnx::GraphProto* value) {
9194   ::google::protobuf::Arena* message_arena = GetArena();
9195   ::google::protobuf::internal::TSanWrite(&_impl_);
9196   if (message_arena == nullptr) {
9197     delete (_impl_.graph_);
9198   }
9199
9200   if (value != nullptr) {
9201     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
9202     if (message_arena != submessage_arena) {
9203       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
9204     }
9205     _impl_._has_bits_[0] |= 0x00000010u;
9206   } else {
9207     _impl_._has_bits_[0] &= ~0x00000010u;
9208   }
9209
9210   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
9211   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
9212 }
9213
9214 // repeated .onnx.StringStringEntryProto metadata_props = 14;
9215 inline int ModelProto::_internal_metadata_props_size() const {
9216   return _internal_metadata_props().size();
9217 }
9218 inline int ModelProto::metadata_props_size() const {
9219   return _internal_metadata_props_size();
9220 }
9221 inline void ModelProto::clear_metadata_props() {
9222   ::google::protobuf::internal::TSanWrite(&_impl_);
9223   _impl_.metadata_props_.Clear();
9224 }
9225 inline ::onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index)
9226     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9227   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
9228   return _internal_mutable_metadata_props()->Mutable(index);
9229 }
9230 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* ModelProto::mutable_metadata_props()
9231     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9232   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
9233   ::google::protobuf::internal::TSanWrite(&_impl_);
9234   return _internal_mutable_metadata_props();
9235 }
9236 inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const
9237     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9238   // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
9239   return _internal_metadata_props().Get(index);
9240 }
9241 inline ::onnx::StringStringEntryProto* ModelProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9242   ::google::protobuf::internal::TSanWrite(&_impl_);
9243   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
9244   // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
9245   return _add;
9246 }
9247 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ModelProto::metadata_props() const
9248     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9249   // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
9250   return _internal_metadata_props();
9251 }
9252 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
9253 ModelProto::_internal_metadata_props() const {
9254   ::google::protobuf::internal::TSanRead(&_impl_);
9255   return _impl_.metadata_props_;
9256 }
9257 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
9258 ModelProto::_internal_mutable_metadata_props() {
9259   ::google::protobuf::internal::TSanRead(&_impl_);
9260   return &_impl_.metadata_props_;
9261 }
9262
9263 // repeated .onnx.TrainingInfoProto training_info = 20;
9264 inline int ModelProto::_internal_training_info_size() const {
9265   return _internal_training_info().size();
9266 }
9267 inline int ModelProto::training_info_size() const {
9268   return _internal_training_info_size();
9269 }
9270 inline void ModelProto::clear_training_info() {
9271   ::google::protobuf::internal::TSanWrite(&_impl_);
9272   _impl_.training_info_.Clear();
9273 }
9274 inline ::onnx::TrainingInfoProto* ModelProto::mutable_training_info(int index)
9275     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9276   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
9277   return _internal_mutable_training_info()->Mutable(index);
9278 }
9279 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* ModelProto::mutable_training_info()
9280     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9281   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
9282   ::google::protobuf::internal::TSanWrite(&_impl_);
9283   return _internal_mutable_training_info();
9284 }
9285 inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const
9286     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9287   // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
9288   return _internal_training_info().Get(index);
9289 }
9290 inline ::onnx::TrainingInfoProto* ModelProto::add_training_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9291   ::google::protobuf::internal::TSanWrite(&_impl_);
9292   ::onnx::TrainingInfoProto* _add = _internal_mutable_training_info()->Add();
9293   // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
9294   return _add;
9295 }
9296 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& ModelProto::training_info() const
9297     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9298   // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
9299   return _internal_training_info();
9300 }
9301 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>&
9302 ModelProto::_internal_training_info() const {
9303   ::google::protobuf::internal::TSanRead(&_impl_);
9304   return _impl_.training_info_;
9305 }
9306 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>*
9307 ModelProto::_internal_mutable_training_info() {
9308   ::google::protobuf::internal::TSanRead(&_impl_);
9309   return &_impl_.training_info_;
9310 }
9311
9312 // repeated .onnx.FunctionProto functions = 25;
9313 inline int ModelProto::_internal_functions_size() const {
9314   return _internal_functions().size();
9315 }
9316 inline int ModelProto::functions_size() const {
9317   return _internal_functions_size();
9318 }
9319 inline void ModelProto::clear_functions() {
9320   ::google::protobuf::internal::TSanWrite(&_impl_);
9321   _impl_.functions_.Clear();
9322 }
9323 inline ::onnx::FunctionProto* ModelProto::mutable_functions(int index)
9324     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9325   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
9326   return _internal_mutable_functions()->Mutable(index);
9327 }
9328 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* ModelProto::mutable_functions()
9329     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9330   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
9331   ::google::protobuf::internal::TSanWrite(&_impl_);
9332   return _internal_mutable_functions();
9333 }
9334 inline const ::onnx::FunctionProto& ModelProto::functions(int index) const
9335     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9336   // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
9337   return _internal_functions().Get(index);
9338 }
9339 inline ::onnx::FunctionProto* ModelProto::add_functions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9340   ::google::protobuf::internal::TSanWrite(&_impl_);
9341   ::onnx::FunctionProto* _add = _internal_mutable_functions()->Add();
9342   // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
9343   return _add;
9344 }
9345 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& ModelProto::functions() const
9346     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9347   // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
9348   return _internal_functions();
9349 }
9350 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>&
9351 ModelProto::_internal_functions() const {
9352   ::google::protobuf::internal::TSanRead(&_impl_);
9353   return _impl_.functions_;
9354 }
9355 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>*
9356 ModelProto::_internal_mutable_functions() {
9357   ::google::protobuf::internal::TSanRead(&_impl_);
9358   return &_impl_.functions_;
9359 }
9360
9361 // -------------------------------------------------------------------
9362
9363 // StringStringEntryProto
9364
9365 // optional string key = 1;
9366 inline bool StringStringEntryProto::has_key() const {
9367   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
9368   return value;
9369 }
9370 inline void StringStringEntryProto::clear_key() {
9371   ::google::protobuf::internal::TSanWrite(&_impl_);
9372   _impl_.key_.ClearToEmpty();
9373   _impl_._has_bits_[0] &= ~0x00000001u;
9374 }
9375 inline const std::string& StringStringEntryProto::key() const
9376     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9377   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
9378   return _internal_key();
9379 }
9380 template <typename Arg_, typename... Args_>
9381 inline PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_key(Arg_&& arg,
9382                                                      Args_... args) {
9383   ::google::protobuf::internal::TSanWrite(&_impl_);
9384   _impl_._has_bits_[0] |= 0x00000001u;
9385   _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9386   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
9387 }
9388 inline std::string* StringStringEntryProto::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9389   std::string* _s = _internal_mutable_key();
9390   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
9391   return _s;
9392 }
9393 inline const std::string& StringStringEntryProto::_internal_key() const {
9394   ::google::protobuf::internal::TSanRead(&_impl_);
9395   return _impl_.key_.Get();
9396 }
9397 inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
9398   ::google::protobuf::internal::TSanWrite(&_impl_);
9399   _impl_._has_bits_[0] |= 0x00000001u;
9400   _impl_.key_.Set(value, GetArena());
9401 }
9402 inline std::string* StringStringEntryProto::_internal_mutable_key() {
9403   ::google::protobuf::internal::TSanWrite(&_impl_);
9404   _impl_._has_bits_[0] |= 0x00000001u;
9405   return _impl_.key_.Mutable( GetArena());
9406 }
9407 inline std::string* StringStringEntryProto::release_key() {
9408   ::google::protobuf::internal::TSanWrite(&_impl_);
9409   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
9410   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
9411     return nullptr;
9412   }
9413   _impl_._has_bits_[0] &= ~0x00000001u;
9414   auto* released = _impl_.key_.Release();
9415   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9416   _impl_.key_.Set("", GetArena());
9417   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9418   return released;
9419 }
9420 inline void StringStringEntryProto::set_allocated_key(std::string* value) {
9421   ::google::protobuf::internal::TSanWrite(&_impl_);
9422   if (value != nullptr) {
9423     _impl_._has_bits_[0] |= 0x00000001u;
9424   } else {
9425     _impl_._has_bits_[0] &= ~0x00000001u;
9426   }
9427   _impl_.key_.SetAllocated(value, GetArena());
9428   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9429         if (_impl_.key_.IsDefault()) {
9430           _impl_.key_.Set("", GetArena());
9431         }
9432   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9433   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
9434 }
9435
9436 // optional string value = 2;
9437 inline bool StringStringEntryProto::has_value() const {
9438   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
9439   return value;
9440 }
9441 inline void StringStringEntryProto::clear_value() {
9442   ::google::protobuf::internal::TSanWrite(&_impl_);
9443   _impl_.value_.ClearToEmpty();
9444   _impl_._has_bits_[0] &= ~0x00000002u;
9445 }
9446 inline const std::string& StringStringEntryProto::value() const
9447     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9448   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
9449   return _internal_value();
9450 }
9451 template <typename Arg_, typename... Args_>
9452 inline PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_value(Arg_&& arg,
9453                                                      Args_... args) {
9454   ::google::protobuf::internal::TSanWrite(&_impl_);
9455   _impl_._has_bits_[0] |= 0x00000002u;
9456   _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9457   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
9458 }
9459 inline std::string* StringStringEntryProto::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9460   std::string* _s = _internal_mutable_value();
9461   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
9462   return _s;
9463 }
9464 inline const std::string& StringStringEntryProto::_internal_value() const {
9465   ::google::protobuf::internal::TSanRead(&_impl_);
9466   return _impl_.value_.Get();
9467 }
9468 inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
9469   ::google::protobuf::internal::TSanWrite(&_impl_);
9470   _impl_._has_bits_[0] |= 0x00000002u;
9471   _impl_.value_.Set(value, GetArena());
9472 }
9473 inline std::string* StringStringEntryProto::_internal_mutable_value() {
9474   ::google::protobuf::internal::TSanWrite(&_impl_);
9475   _impl_._has_bits_[0] |= 0x00000002u;
9476   return _impl_.value_.Mutable( GetArena());
9477 }
9478 inline std::string* StringStringEntryProto::release_value() {
9479   ::google::protobuf::internal::TSanWrite(&_impl_);
9480   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
9481   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
9482     return nullptr;
9483   }
9484   _impl_._has_bits_[0] &= ~0x00000002u;
9485   auto* released = _impl_.value_.Release();
9486   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9487   _impl_.value_.Set("", GetArena());
9488   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9489   return released;
9490 }
9491 inline void StringStringEntryProto::set_allocated_value(std::string* value) {
9492   ::google::protobuf::internal::TSanWrite(&_impl_);
9493   if (value != nullptr) {
9494     _impl_._has_bits_[0] |= 0x00000002u;
9495   } else {
9496     _impl_._has_bits_[0] &= ~0x00000002u;
9497   }
9498   _impl_.value_.SetAllocated(value, GetArena());
9499   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9500         if (_impl_.value_.IsDefault()) {
9501           _impl_.value_.Set("", GetArena());
9502         }
9503   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9504   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
9505 }
9506
9507 // -------------------------------------------------------------------
9508
9509 // TensorAnnotation
9510
9511 // optional string tensor_name = 1;
9512 inline bool TensorAnnotation::has_tensor_name() const {
9513   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
9514   return value;
9515 }
9516 inline void TensorAnnotation::clear_tensor_name() {
9517   ::google::protobuf::internal::TSanWrite(&_impl_);
9518   _impl_.tensor_name_.ClearToEmpty();
9519   _impl_._has_bits_[0] &= ~0x00000001u;
9520 }
9521 inline const std::string& TensorAnnotation::tensor_name() const
9522     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9523   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
9524   return _internal_tensor_name();
9525 }
9526 template <typename Arg_, typename... Args_>
9527 inline PROTOBUF_ALWAYS_INLINE void TensorAnnotation::set_tensor_name(Arg_&& arg,
9528                                                      Args_... args) {
9529   ::google::protobuf::internal::TSanWrite(&_impl_);
9530   _impl_._has_bits_[0] |= 0x00000001u;
9531   _impl_.tensor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9532   // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
9533 }
9534 inline std::string* TensorAnnotation::mutable_tensor_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9535   std::string* _s = _internal_mutable_tensor_name();
9536   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
9537   return _s;
9538 }
9539 inline const std::string& TensorAnnotation::_internal_tensor_name() const {
9540   ::google::protobuf::internal::TSanRead(&_impl_);
9541   return _impl_.tensor_name_.Get();
9542 }
9543 inline void TensorAnnotation::_internal_set_tensor_name(const std::string& value) {
9544   ::google::protobuf::internal::TSanWrite(&_impl_);
9545   _impl_._has_bits_[0] |= 0x00000001u;
9546   _impl_.tensor_name_.Set(value, GetArena());
9547 }
9548 inline std::string* TensorAnnotation::_internal_mutable_tensor_name() {
9549   ::google::protobuf::internal::TSanWrite(&_impl_);
9550   _impl_._has_bits_[0] |= 0x00000001u;
9551   return _impl_.tensor_name_.Mutable( GetArena());
9552 }
9553 inline std::string* TensorAnnotation::release_tensor_name() {
9554   ::google::protobuf::internal::TSanWrite(&_impl_);
9555   // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
9556   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
9557     return nullptr;
9558   }
9559   _impl_._has_bits_[0] &= ~0x00000001u;
9560   auto* released = _impl_.tensor_name_.Release();
9561   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9562   _impl_.tensor_name_.Set("", GetArena());
9563   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9564   return released;
9565 }
9566 inline void TensorAnnotation::set_allocated_tensor_name(std::string* value) {
9567   ::google::protobuf::internal::TSanWrite(&_impl_);
9568   if (value != nullptr) {
9569     _impl_._has_bits_[0] |= 0x00000001u;
9570   } else {
9571     _impl_._has_bits_[0] &= ~0x00000001u;
9572   }
9573   _impl_.tensor_name_.SetAllocated(value, GetArena());
9574   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9575         if (_impl_.tensor_name_.IsDefault()) {
9576           _impl_.tensor_name_.Set("", GetArena());
9577         }
9578   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9579   // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
9580 }
9581
9582 // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
9583 inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
9584   return _internal_quant_parameter_tensor_names().size();
9585 }
9586 inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
9587   return _internal_quant_parameter_tensor_names_size();
9588 }
9589 inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
9590   ::google::protobuf::internal::TSanWrite(&_impl_);
9591   _impl_.quant_parameter_tensor_names_.Clear();
9592 }
9593 inline ::onnx::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index)
9594     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9595   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
9596   return _internal_mutable_quant_parameter_tensor_names()->Mutable(index);
9597 }
9598 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TensorAnnotation::mutable_quant_parameter_tensor_names()
9599     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9600   // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
9601   ::google::protobuf::internal::TSanWrite(&_impl_);
9602   return _internal_mutable_quant_parameter_tensor_names();
9603 }
9604 inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const
9605     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9606   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
9607   return _internal_quant_parameter_tensor_names().Get(index);
9608 }
9609 inline ::onnx::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9610   ::google::protobuf::internal::TSanWrite(&_impl_);
9611   ::onnx::StringStringEntryProto* _add = _internal_mutable_quant_parameter_tensor_names()->Add();
9612   // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
9613   return _add;
9614 }
9615 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorAnnotation::quant_parameter_tensor_names() const
9616     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9617   // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
9618   return _internal_quant_parameter_tensor_names();
9619 }
9620 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
9621 TensorAnnotation::_internal_quant_parameter_tensor_names() const {
9622   ::google::protobuf::internal::TSanRead(&_impl_);
9623   return _impl_.quant_parameter_tensor_names_;
9624 }
9625 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
9626 TensorAnnotation::_internal_mutable_quant_parameter_tensor_names() {
9627   ::google::protobuf::internal::TSanRead(&_impl_);
9628   return &_impl_.quant_parameter_tensor_names_;
9629 }
9630
9631 // -------------------------------------------------------------------
9632
9633 // GraphProto
9634
9635 // repeated .onnx.NodeProto node = 1;
9636 inline int GraphProto::_internal_node_size() const {
9637   return _internal_node().size();
9638 }
9639 inline int GraphProto::node_size() const {
9640   return _internal_node_size();
9641 }
9642 inline void GraphProto::clear_node() {
9643   ::google::protobuf::internal::TSanWrite(&_impl_);
9644   _impl_.node_.Clear();
9645 }
9646 inline ::onnx::NodeProto* GraphProto::mutable_node(int index)
9647     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9648   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
9649   return _internal_mutable_node()->Mutable(index);
9650 }
9651 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* GraphProto::mutable_node()
9652     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9653   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
9654   ::google::protobuf::internal::TSanWrite(&_impl_);
9655   return _internal_mutable_node();
9656 }
9657 inline const ::onnx::NodeProto& GraphProto::node(int index) const
9658     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9659   // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
9660   return _internal_node().Get(index);
9661 }
9662 inline ::onnx::NodeProto* GraphProto::add_node() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9663   ::google::protobuf::internal::TSanWrite(&_impl_);
9664   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
9665   // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
9666   return _add;
9667 }
9668 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& GraphProto::node() const
9669     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9670   // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
9671   return _internal_node();
9672 }
9673 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
9674 GraphProto::_internal_node() const {
9675   ::google::protobuf::internal::TSanRead(&_impl_);
9676   return _impl_.node_;
9677 }
9678 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>*
9679 GraphProto::_internal_mutable_node() {
9680   ::google::protobuf::internal::TSanRead(&_impl_);
9681   return &_impl_.node_;
9682 }
9683
9684 // optional string name = 2;
9685 inline bool GraphProto::has_name() const {
9686   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
9687   return value;
9688 }
9689 inline void GraphProto::clear_name() {
9690   ::google::protobuf::internal::TSanWrite(&_impl_);
9691   _impl_.name_.ClearToEmpty();
9692   _impl_._has_bits_[0] &= ~0x00000001u;
9693 }
9694 inline const std::string& GraphProto::name() const
9695     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9696   // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
9697   return _internal_name();
9698 }
9699 template <typename Arg_, typename... Args_>
9700 inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_name(Arg_&& arg,
9701                                                      Args_... args) {
9702   ::google::protobuf::internal::TSanWrite(&_impl_);
9703   _impl_._has_bits_[0] |= 0x00000001u;
9704   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9705   // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
9706 }
9707 inline std::string* GraphProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9708   std::string* _s = _internal_mutable_name();
9709   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
9710   return _s;
9711 }
9712 inline const std::string& GraphProto::_internal_name() const {
9713   ::google::protobuf::internal::TSanRead(&_impl_);
9714   return _impl_.name_.Get();
9715 }
9716 inline void GraphProto::_internal_set_name(const std::string& value) {
9717   ::google::protobuf::internal::TSanWrite(&_impl_);
9718   _impl_._has_bits_[0] |= 0x00000001u;
9719   _impl_.name_.Set(value, GetArena());
9720 }
9721 inline std::string* GraphProto::_internal_mutable_name() {
9722   ::google::protobuf::internal::TSanWrite(&_impl_);
9723   _impl_._has_bits_[0] |= 0x00000001u;
9724   return _impl_.name_.Mutable( GetArena());
9725 }
9726 inline std::string* GraphProto::release_name() {
9727   ::google::protobuf::internal::TSanWrite(&_impl_);
9728   // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
9729   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
9730     return nullptr;
9731   }
9732   _impl_._has_bits_[0] &= ~0x00000001u;
9733   auto* released = _impl_.name_.Release();
9734   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9735   _impl_.name_.Set("", GetArena());
9736   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9737   return released;
9738 }
9739 inline void GraphProto::set_allocated_name(std::string* value) {
9740   ::google::protobuf::internal::TSanWrite(&_impl_);
9741   if (value != nullptr) {
9742     _impl_._has_bits_[0] |= 0x00000001u;
9743   } else {
9744     _impl_._has_bits_[0] &= ~0x00000001u;
9745   }
9746   _impl_.name_.SetAllocated(value, GetArena());
9747   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9748         if (_impl_.name_.IsDefault()) {
9749           _impl_.name_.Set("", GetArena());
9750         }
9751   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9752   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
9753 }
9754
9755 // repeated .onnx.TensorProto initializer = 5;
9756 inline int GraphProto::_internal_initializer_size() const {
9757   return _internal_initializer().size();
9758 }
9759 inline int GraphProto::initializer_size() const {
9760   return _internal_initializer_size();
9761 }
9762 inline void GraphProto::clear_initializer() {
9763   ::google::protobuf::internal::TSanWrite(&_impl_);
9764   _impl_.initializer_.Clear();
9765 }
9766 inline ::onnx::TensorProto* GraphProto::mutable_initializer(int index)
9767     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9768   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
9769   return _internal_mutable_initializer()->Mutable(index);
9770 }
9771 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* GraphProto::mutable_initializer()
9772     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9773   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
9774   ::google::protobuf::internal::TSanWrite(&_impl_);
9775   return _internal_mutable_initializer();
9776 }
9777 inline const ::onnx::TensorProto& GraphProto::initializer(int index) const
9778     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9779   // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
9780   return _internal_initializer().Get(index);
9781 }
9782 inline ::onnx::TensorProto* GraphProto::add_initializer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9783   ::google::protobuf::internal::TSanWrite(&_impl_);
9784   ::onnx::TensorProto* _add = _internal_mutable_initializer()->Add();
9785   // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
9786   return _add;
9787 }
9788 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& GraphProto::initializer() const
9789     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9790   // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
9791   return _internal_initializer();
9792 }
9793 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
9794 GraphProto::_internal_initializer() const {
9795   ::google::protobuf::internal::TSanRead(&_impl_);
9796   return _impl_.initializer_;
9797 }
9798 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>*
9799 GraphProto::_internal_mutable_initializer() {
9800   ::google::protobuf::internal::TSanRead(&_impl_);
9801   return &_impl_.initializer_;
9802 }
9803
9804 // repeated .onnx.SparseTensorProto sparse_initializer = 15;
9805 inline int GraphProto::_internal_sparse_initializer_size() const {
9806   return _internal_sparse_initializer().size();
9807 }
9808 inline int GraphProto::sparse_initializer_size() const {
9809   return _internal_sparse_initializer_size();
9810 }
9811 inline void GraphProto::clear_sparse_initializer() {
9812   ::google::protobuf::internal::TSanWrite(&_impl_);
9813   _impl_.sparse_initializer_.Clear();
9814 }
9815 inline ::onnx::SparseTensorProto* GraphProto::mutable_sparse_initializer(int index)
9816     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9817   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
9818   return _internal_mutable_sparse_initializer()->Mutable(index);
9819 }
9820 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* GraphProto::mutable_sparse_initializer()
9821     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9822   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
9823   ::google::protobuf::internal::TSanWrite(&_impl_);
9824   return _internal_mutable_sparse_initializer();
9825 }
9826 inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const
9827     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9828   // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
9829   return _internal_sparse_initializer().Get(index);
9830 }
9831 inline ::onnx::SparseTensorProto* GraphProto::add_sparse_initializer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9832   ::google::protobuf::internal::TSanWrite(&_impl_);
9833   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_initializer()->Add();
9834   // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
9835   return _add;
9836 }
9837 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& GraphProto::sparse_initializer() const
9838     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9839   // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
9840   return _internal_sparse_initializer();
9841 }
9842 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
9843 GraphProto::_internal_sparse_initializer() const {
9844   ::google::protobuf::internal::TSanRead(&_impl_);
9845   return _impl_.sparse_initializer_;
9846 }
9847 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>*
9848 GraphProto::_internal_mutable_sparse_initializer() {
9849   ::google::protobuf::internal::TSanRead(&_impl_);
9850   return &_impl_.sparse_initializer_;
9851 }
9852
9853 // optional string doc_string = 10;
9854 inline bool GraphProto::has_doc_string() const {
9855   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
9856   return value;
9857 }
9858 inline void GraphProto::clear_doc_string() {
9859   ::google::protobuf::internal::TSanWrite(&_impl_);
9860   _impl_.doc_string_.ClearToEmpty();
9861   _impl_._has_bits_[0] &= ~0x00000002u;
9862 }
9863 inline const std::string& GraphProto::doc_string() const
9864     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9865   // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
9866   return _internal_doc_string();
9867 }
9868 template <typename Arg_, typename... Args_>
9869 inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_doc_string(Arg_&& arg,
9870                                                      Args_... args) {
9871   ::google::protobuf::internal::TSanWrite(&_impl_);
9872   _impl_._has_bits_[0] |= 0x00000002u;
9873   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9874   // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
9875 }
9876 inline std::string* GraphProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9877   std::string* _s = _internal_mutable_doc_string();
9878   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
9879   return _s;
9880 }
9881 inline const std::string& GraphProto::_internal_doc_string() const {
9882   ::google::protobuf::internal::TSanRead(&_impl_);
9883   return _impl_.doc_string_.Get();
9884 }
9885 inline void GraphProto::_internal_set_doc_string(const std::string& value) {
9886   ::google::protobuf::internal::TSanWrite(&_impl_);
9887   _impl_._has_bits_[0] |= 0x00000002u;
9888   _impl_.doc_string_.Set(value, GetArena());
9889 }
9890 inline std::string* GraphProto::_internal_mutable_doc_string() {
9891   ::google::protobuf::internal::TSanWrite(&_impl_);
9892   _impl_._has_bits_[0] |= 0x00000002u;
9893   return _impl_.doc_string_.Mutable( GetArena());
9894 }
9895 inline std::string* GraphProto::release_doc_string() {
9896   ::google::protobuf::internal::TSanWrite(&_impl_);
9897   // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
9898   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
9899     return nullptr;
9900   }
9901   _impl_._has_bits_[0] &= ~0x00000002u;
9902   auto* released = _impl_.doc_string_.Release();
9903   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9904   _impl_.doc_string_.Set("", GetArena());
9905   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9906   return released;
9907 }
9908 inline void GraphProto::set_allocated_doc_string(std::string* value) {
9909   ::google::protobuf::internal::TSanWrite(&_impl_);
9910   if (value != nullptr) {
9911     _impl_._has_bits_[0] |= 0x00000002u;
9912   } else {
9913     _impl_._has_bits_[0] &= ~0x00000002u;
9914   }
9915   _impl_.doc_string_.SetAllocated(value, GetArena());
9916   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9917         if (_impl_.doc_string_.IsDefault()) {
9918           _impl_.doc_string_.Set("", GetArena());
9919         }
9920   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9921   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
9922 }
9923
9924 // repeated .onnx.ValueInfoProto input = 11;
9925 inline int GraphProto::_internal_input_size() const {
9926   return _internal_input().size();
9927 }
9928 inline int GraphProto::input_size() const {
9929   return _internal_input_size();
9930 }
9931 inline void GraphProto::clear_input() {
9932   ::google::protobuf::internal::TSanWrite(&_impl_);
9933   _impl_.input_.Clear();
9934 }
9935 inline ::onnx::ValueInfoProto* GraphProto::mutable_input(int index)
9936     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9937   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
9938   return _internal_mutable_input()->Mutable(index);
9939 }
9940 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_input()
9941     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9942   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
9943   ::google::protobuf::internal::TSanWrite(&_impl_);
9944   return _internal_mutable_input();
9945 }
9946 inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const
9947     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9948   // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
9949   return _internal_input().Get(index);
9950 }
9951 inline ::onnx::ValueInfoProto* GraphProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
9952   ::google::protobuf::internal::TSanWrite(&_impl_);
9953   ::onnx::ValueInfoProto* _add = _internal_mutable_input()->Add();
9954   // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
9955   return _add;
9956 }
9957 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::input() const
9958     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9959   // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
9960   return _internal_input();
9961 }
9962 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
9963 GraphProto::_internal_input() const {
9964   ::google::protobuf::internal::TSanRead(&_impl_);
9965   return _impl_.input_;
9966 }
9967 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
9968 GraphProto::_internal_mutable_input() {
9969   ::google::protobuf::internal::TSanRead(&_impl_);
9970   return &_impl_.input_;
9971 }
9972
9973 // repeated .onnx.ValueInfoProto output = 12;
9974 inline int GraphProto::_internal_output_size() const {
9975   return _internal_output().size();
9976 }
9977 inline int GraphProto::output_size() const {
9978   return _internal_output_size();
9979 }
9980 inline void GraphProto::clear_output() {
9981   ::google::protobuf::internal::TSanWrite(&_impl_);
9982   _impl_.output_.Clear();
9983 }
9984 inline ::onnx::ValueInfoProto* GraphProto::mutable_output(int index)
9985     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9986   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
9987   return _internal_mutable_output()->Mutable(index);
9988 }
9989 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_output()
9990     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9991   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
9992   ::google::protobuf::internal::TSanWrite(&_impl_);
9993   return _internal_mutable_output();
9994 }
9995 inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const
9996     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9997   // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
9998   return _internal_output().Get(index);
9999 }
10000 inline ::onnx::ValueInfoProto* GraphProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10001   ::google::protobuf::internal::TSanWrite(&_impl_);
10002   ::onnx::ValueInfoProto* _add = _internal_mutable_output()->Add();
10003   // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
10004   return _add;
10005 }
10006 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::output() const
10007     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10008   // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
10009   return _internal_output();
10010 }
10011 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
10012 GraphProto::_internal_output() const {
10013   ::google::protobuf::internal::TSanRead(&_impl_);
10014   return _impl_.output_;
10015 }
10016 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
10017 GraphProto::_internal_mutable_output() {
10018   ::google::protobuf::internal::TSanRead(&_impl_);
10019   return &_impl_.output_;
10020 }
10021
10022 // repeated .onnx.ValueInfoProto value_info = 13;
10023 inline int GraphProto::_internal_value_info_size() const {
10024   return _internal_value_info().size();
10025 }
10026 inline int GraphProto::value_info_size() const {
10027   return _internal_value_info_size();
10028 }
10029 inline void GraphProto::clear_value_info() {
10030   ::google::protobuf::internal::TSanWrite(&_impl_);
10031   _impl_.value_info_.Clear();
10032 }
10033 inline ::onnx::ValueInfoProto* GraphProto::mutable_value_info(int index)
10034     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10035   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
10036   return _internal_mutable_value_info()->Mutable(index);
10037 }
10038 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* GraphProto::mutable_value_info()
10039     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10040   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
10041   ::google::protobuf::internal::TSanWrite(&_impl_);
10042   return _internal_mutable_value_info();
10043 }
10044 inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const
10045     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10046   // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
10047   return _internal_value_info().Get(index);
10048 }
10049 inline ::onnx::ValueInfoProto* GraphProto::add_value_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10050   ::google::protobuf::internal::TSanWrite(&_impl_);
10051   ::onnx::ValueInfoProto* _add = _internal_mutable_value_info()->Add();
10052   // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
10053   return _add;
10054 }
10055 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::value_info() const
10056     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10057   // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
10058   return _internal_value_info();
10059 }
10060 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
10061 GraphProto::_internal_value_info() const {
10062   ::google::protobuf::internal::TSanRead(&_impl_);
10063   return _impl_.value_info_;
10064 }
10065 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
10066 GraphProto::_internal_mutable_value_info() {
10067   ::google::protobuf::internal::TSanRead(&_impl_);
10068   return &_impl_.value_info_;
10069 }
10070
10071 // repeated .onnx.TensorAnnotation quantization_annotation = 14;
10072 inline int GraphProto::_internal_quantization_annotation_size() const {
10073   return _internal_quantization_annotation().size();
10074 }
10075 inline int GraphProto::quantization_annotation_size() const {
10076   return _internal_quantization_annotation_size();
10077 }
10078 inline void GraphProto::clear_quantization_annotation() {
10079   ::google::protobuf::internal::TSanWrite(&_impl_);
10080   _impl_.quantization_annotation_.Clear();
10081 }
10082 inline ::onnx::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index)
10083     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10084   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
10085   return _internal_mutable_quantization_annotation()->Mutable(index);
10086 }
10087 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* GraphProto::mutable_quantization_annotation()
10088     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10089   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
10090   ::google::protobuf::internal::TSanWrite(&_impl_);
10091   return _internal_mutable_quantization_annotation();
10092 }
10093 inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const
10094     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10095   // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
10096   return _internal_quantization_annotation().Get(index);
10097 }
10098 inline ::onnx::TensorAnnotation* GraphProto::add_quantization_annotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10099   ::google::protobuf::internal::TSanWrite(&_impl_);
10100   ::onnx::TensorAnnotation* _add = _internal_mutable_quantization_annotation()->Add();
10101   // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
10102   return _add;
10103 }
10104 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& GraphProto::quantization_annotation() const
10105     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10106   // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
10107   return _internal_quantization_annotation();
10108 }
10109 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>&
10110 GraphProto::_internal_quantization_annotation() const {
10111   ::google::protobuf::internal::TSanRead(&_impl_);
10112   return _impl_.quantization_annotation_;
10113 }
10114 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>*
10115 GraphProto::_internal_mutable_quantization_annotation() {
10116   ::google::protobuf::internal::TSanRead(&_impl_);
10117   return &_impl_.quantization_annotation_;
10118 }
10119
10120 // repeated .onnx.StringStringEntryProto metadata_props = 16;
10121 inline int GraphProto::_internal_metadata_props_size() const {
10122   return _internal_metadata_props().size();
10123 }
10124 inline int GraphProto::metadata_props_size() const {
10125   return _internal_metadata_props_size();
10126 }
10127 inline void GraphProto::clear_metadata_props() {
10128   ::google::protobuf::internal::TSanWrite(&_impl_);
10129   _impl_.metadata_props_.Clear();
10130 }
10131 inline ::onnx::StringStringEntryProto* GraphProto::mutable_metadata_props(int index)
10132     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10133   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props)
10134   return _internal_mutable_metadata_props()->Mutable(index);
10135 }
10136 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* GraphProto::mutable_metadata_props()
10137     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10138   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props)
10139   ::google::protobuf::internal::TSanWrite(&_impl_);
10140   return _internal_mutable_metadata_props();
10141 }
10142 inline const ::onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const
10143     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10144   // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props)
10145   return _internal_metadata_props().Get(index);
10146 }
10147 inline ::onnx::StringStringEntryProto* GraphProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10148   ::google::protobuf::internal::TSanWrite(&_impl_);
10149   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
10150   // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props)
10151   return _add;
10152 }
10153 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& GraphProto::metadata_props() const
10154     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10155   // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props)
10156   return _internal_metadata_props();
10157 }
10158 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
10159 GraphProto::_internal_metadata_props() const {
10160   ::google::protobuf::internal::TSanRead(&_impl_);
10161   return _impl_.metadata_props_;
10162 }
10163 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
10164 GraphProto::_internal_mutable_metadata_props() {
10165   ::google::protobuf::internal::TSanRead(&_impl_);
10166   return &_impl_.metadata_props_;
10167 }
10168
10169 // -------------------------------------------------------------------
10170
10171 // TensorProto_Segment
10172
10173 // optional int64 begin = 1;
10174 inline bool TensorProto_Segment::has_begin() const {
10175   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
10176   return value;
10177 }
10178 inline void TensorProto_Segment::clear_begin() {
10179   ::google::protobuf::internal::TSanWrite(&_impl_);
10180   _impl_.begin_ = ::int64_t{0};
10181   _impl_._has_bits_[0] &= ~0x00000001u;
10182 }
10183 inline ::int64_t TensorProto_Segment::begin() const {
10184   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
10185   return _internal_begin();
10186 }
10187 inline void TensorProto_Segment::set_begin(::int64_t value) {
10188   _internal_set_begin(value);
10189   _impl_._has_bits_[0] |= 0x00000001u;
10190   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
10191 }
10192 inline ::int64_t TensorProto_Segment::_internal_begin() const {
10193   ::google::protobuf::internal::TSanRead(&_impl_);
10194   return _impl_.begin_;
10195 }
10196 inline void TensorProto_Segment::_internal_set_begin(::int64_t value) {
10197   ::google::protobuf::internal::TSanWrite(&_impl_);
10198   _impl_.begin_ = value;
10199 }
10200
10201 // optional int64 end = 2;
10202 inline bool TensorProto_Segment::has_end() const {
10203   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
10204   return value;
10205 }
10206 inline void TensorProto_Segment::clear_end() {
10207   ::google::protobuf::internal::TSanWrite(&_impl_);
10208   _impl_.end_ = ::int64_t{0};
10209   _impl_._has_bits_[0] &= ~0x00000002u;
10210 }
10211 inline ::int64_t TensorProto_Segment::end() const {
10212   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
10213   return _internal_end();
10214 }
10215 inline void TensorProto_Segment::set_end(::int64_t value) {
10216   _internal_set_end(value);
10217   _impl_._has_bits_[0] |= 0x00000002u;
10218   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
10219 }
10220 inline ::int64_t TensorProto_Segment::_internal_end() const {
10221   ::google::protobuf::internal::TSanRead(&_impl_);
10222   return _impl_.end_;
10223 }
10224 inline void TensorProto_Segment::_internal_set_end(::int64_t value) {
10225   ::google::protobuf::internal::TSanWrite(&_impl_);
10226   _impl_.end_ = value;
10227 }
10228
10229 // -------------------------------------------------------------------
10230
10231 // TensorProto
10232
10233 // repeated int64 dims = 1;
10234 inline int TensorProto::_internal_dims_size() const {
10235   return _internal_dims().size();
10236 }
10237 inline int TensorProto::dims_size() const {
10238   return _internal_dims_size();
10239 }
10240 inline void TensorProto::clear_dims() {
10241   ::google::protobuf::internal::TSanWrite(&_impl_);
10242   _impl_.dims_.Clear();
10243 }
10244 inline ::int64_t TensorProto::dims(int index) const {
10245   // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
10246   return _internal_dims().Get(index);
10247 }
10248 inline void TensorProto::set_dims(int index, ::int64_t value) {
10249   _internal_mutable_dims()->Set(index, value);
10250   // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
10251 }
10252 inline void TensorProto::add_dims(::int64_t value) {
10253   ::google::protobuf::internal::TSanWrite(&_impl_);
10254   _internal_mutable_dims()->Add(value);
10255   // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
10256 }
10257 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::dims() const
10258     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10259   // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
10260   return _internal_dims();
10261 }
10262 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::mutable_dims()
10263     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10264   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
10265   ::google::protobuf::internal::TSanWrite(&_impl_);
10266   return _internal_mutable_dims();
10267 }
10268 inline const ::google::protobuf::RepeatedField<::int64_t>&
10269 TensorProto::_internal_dims() const {
10270   ::google::protobuf::internal::TSanRead(&_impl_);
10271   return _impl_.dims_;
10272 }
10273 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::_internal_mutable_dims() {
10274   ::google::protobuf::internal::TSanRead(&_impl_);
10275   return &_impl_.dims_;
10276 }
10277
10278 // optional int32 data_type = 2;
10279 inline bool TensorProto::has_data_type() const {
10280   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
10281   return value;
10282 }
10283 inline void TensorProto::clear_data_type() {
10284   ::google::protobuf::internal::TSanWrite(&_impl_);
10285   _impl_.data_type_ = 0;
10286   _impl_._has_bits_[0] &= ~0x00000010u;
10287 }
10288 inline ::int32_t TensorProto::data_type() const {
10289   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
10290   return _internal_data_type();
10291 }
10292 inline void TensorProto::set_data_type(::int32_t value) {
10293   _internal_set_data_type(value);
10294   _impl_._has_bits_[0] |= 0x00000010u;
10295   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
10296 }
10297 inline ::int32_t TensorProto::_internal_data_type() const {
10298   ::google::protobuf::internal::TSanRead(&_impl_);
10299   return _impl_.data_type_;
10300 }
10301 inline void TensorProto::_internal_set_data_type(::int32_t value) {
10302   ::google::protobuf::internal::TSanWrite(&_impl_);
10303   _impl_.data_type_ = value;
10304 }
10305
10306 // optional .onnx.TensorProto.Segment segment = 3;
10307 inline bool TensorProto::has_segment() const {
10308   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
10309   PROTOBUF_ASSUME(!value || _impl_.segment_ != nullptr);
10310   return value;
10311 }
10312 inline void TensorProto::clear_segment() {
10313   ::google::protobuf::internal::TSanWrite(&_impl_);
10314   if (_impl_.segment_ != nullptr) _impl_.segment_->Clear();
10315   _impl_._has_bits_[0] &= ~0x00000008u;
10316 }
10317 inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
10318   ::google::protobuf::internal::TSanRead(&_impl_);
10319   const ::onnx::TensorProto_Segment* p = _impl_.segment_;
10320   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto_Segment&>(::onnx::_TensorProto_Segment_default_instance_);
10321 }
10322 inline const ::onnx::TensorProto_Segment& TensorProto::segment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
10323   // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
10324   return _internal_segment();
10325 }
10326 inline void TensorProto::unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* value) {
10327   ::google::protobuf::internal::TSanWrite(&_impl_);
10328   if (GetArena() == nullptr) {
10329     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
10330   }
10331   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
10332   if (value != nullptr) {
10333     _impl_._has_bits_[0] |= 0x00000008u;
10334   } else {
10335     _impl_._has_bits_[0] &= ~0x00000008u;
10336   }
10337   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
10338 }
10339 inline ::onnx::TensorProto_Segment* TensorProto::release_segment() {
10340   ::google::protobuf::internal::TSanWrite(&_impl_);
10341
10342   _impl_._has_bits_[0] &= ~0x00000008u;
10343   ::onnx::TensorProto_Segment* released = _impl_.segment_;
10344   _impl_.segment_ = nullptr;
10345 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
10346   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
10347   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
10348   if (GetArena() == nullptr) {
10349     delete old;
10350   }
10351 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
10352   if (GetArena() != nullptr) {
10353     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
10354   }
10355 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
10356   return released;
10357 }
10358 inline ::onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
10359   ::google::protobuf::internal::TSanWrite(&_impl_);
10360   // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)
10361
10362   _impl_._has_bits_[0] &= ~0x00000008u;
10363   ::onnx::TensorProto_Segment* temp = _impl_.segment_;
10364   _impl_.segment_ = nullptr;
10365   return temp;
10366 }
10367 inline ::onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
10368   ::google::protobuf::internal::TSanWrite(&_impl_);
10369   if (_impl_.segment_ == nullptr) {
10370     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto_Segment>(GetArena());
10371     _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(p);
10372   }
10373   return _impl_.segment_;
10374 }
10375 inline ::onnx::TensorProto_Segment* TensorProto::mutable_segment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10376   _impl_._has_bits_[0] |= 0x00000008u;
10377   ::onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
10378   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
10379   return _msg;
10380 }
10381 inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* value) {
10382   ::google::protobuf::Arena* message_arena = GetArena();
10383   ::google::protobuf::internal::TSanWrite(&_impl_);
10384   if (message_arena == nullptr) {
10385     delete (_impl_.segment_);
10386   }
10387
10388   if (value != nullptr) {
10389     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
10390     if (message_arena != submessage_arena) {
10391       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
10392     }
10393     _impl_._has_bits_[0] |= 0x00000008u;
10394   } else {
10395     _impl_._has_bits_[0] &= ~0x00000008u;
10396   }
10397
10398   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
10399   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
10400 }
10401
10402 // repeated float float_data = 4 [packed = true];
10403 inline int TensorProto::_internal_float_data_size() const {
10404   return _internal_float_data().size();
10405 }
10406 inline int TensorProto::float_data_size() const {
10407   return _internal_float_data_size();
10408 }
10409 inline void TensorProto::clear_float_data() {
10410   ::google::protobuf::internal::TSanWrite(&_impl_);
10411   _impl_.float_data_.Clear();
10412 }
10413 inline float TensorProto::float_data(int index) const {
10414   // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
10415   return _internal_float_data().Get(index);
10416 }
10417 inline void TensorProto::set_float_data(int index, float value) {
10418   _internal_mutable_float_data()->Set(index, value);
10419   // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
10420 }
10421 inline void TensorProto::add_float_data(float value) {
10422   ::google::protobuf::internal::TSanWrite(&_impl_);
10423   _internal_mutable_float_data()->Add(value);
10424   // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
10425 }
10426 inline const ::google::protobuf::RepeatedField<float>& TensorProto::float_data() const
10427     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10428   // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
10429   return _internal_float_data();
10430 }
10431 inline ::google::protobuf::RepeatedField<float>* TensorProto::mutable_float_data()
10432     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10433   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
10434   ::google::protobuf::internal::TSanWrite(&_impl_);
10435   return _internal_mutable_float_data();
10436 }
10437 inline const ::google::protobuf::RepeatedField<float>&
10438 TensorProto::_internal_float_data() const {
10439   ::google::protobuf::internal::TSanRead(&_impl_);
10440   return _impl_.float_data_;
10441 }
10442 inline ::google::protobuf::RepeatedField<float>* TensorProto::_internal_mutable_float_data() {
10443   ::google::protobuf::internal::TSanRead(&_impl_);
10444   return &_impl_.float_data_;
10445 }
10446
10447 // repeated int32 int32_data = 5 [packed = true];
10448 inline int TensorProto::_internal_int32_data_size() const {
10449   return _internal_int32_data().size();
10450 }
10451 inline int TensorProto::int32_data_size() const {
10452   return _internal_int32_data_size();
10453 }
10454 inline void TensorProto::clear_int32_data() {
10455   ::google::protobuf::internal::TSanWrite(&_impl_);
10456   _impl_.int32_data_.Clear();
10457 }
10458 inline ::int32_t TensorProto::int32_data(int index) const {
10459   // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
10460   return _internal_int32_data().Get(index);
10461 }
10462 inline void TensorProto::set_int32_data(int index, ::int32_t value) {
10463   _internal_mutable_int32_data()->Set(index, value);
10464   // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
10465 }
10466 inline void TensorProto::add_int32_data(::int32_t value) {
10467   ::google::protobuf::internal::TSanWrite(&_impl_);
10468   _internal_mutable_int32_data()->Add(value);
10469   // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
10470 }
10471 inline const ::google::protobuf::RepeatedField<::int32_t>& TensorProto::int32_data() const
10472     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10473   // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
10474   return _internal_int32_data();
10475 }
10476 inline ::google::protobuf::RepeatedField<::int32_t>* TensorProto::mutable_int32_data()
10477     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10478   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
10479   ::google::protobuf::internal::TSanWrite(&_impl_);
10480   return _internal_mutable_int32_data();
10481 }
10482 inline const ::google::protobuf::RepeatedField<::int32_t>&
10483 TensorProto::_internal_int32_data() const {
10484   ::google::protobuf::internal::TSanRead(&_impl_);
10485   return _impl_.int32_data_;
10486 }
10487 inline ::google::protobuf::RepeatedField<::int32_t>* TensorProto::_internal_mutable_int32_data() {
10488   ::google::protobuf::internal::TSanRead(&_impl_);
10489   return &_impl_.int32_data_;
10490 }
10491
10492 // repeated bytes string_data = 6;
10493 inline int TensorProto::_internal_string_data_size() const {
10494   return _internal_string_data().size();
10495 }
10496 inline int TensorProto::string_data_size() const {
10497   return _internal_string_data_size();
10498 }
10499 inline void TensorProto::clear_string_data() {
10500   ::google::protobuf::internal::TSanWrite(&_impl_);
10501   _impl_.string_data_.Clear();
10502 }
10503 inline std::string* TensorProto::add_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10504   ::google::protobuf::internal::TSanWrite(&_impl_);
10505   std::string* _s = _internal_mutable_string_data()->Add();
10506   // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
10507   return _s;
10508 }
10509 inline const std::string& TensorProto::string_data(int index) const
10510     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10511   // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
10512   return _internal_string_data().Get(index);
10513 }
10514 inline std::string* TensorProto::mutable_string_data(int index)
10515     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10516   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
10517   return _internal_mutable_string_data()->Mutable(index);
10518 }
10519 template <typename Arg_, typename... Args_>
10520 inline void TensorProto::set_string_data(int index, Arg_&& value, Args_... args) {
10521   ::google::protobuf::internal::AssignToString(
10522       *_internal_mutable_string_data()->Mutable(index),
10523       std::forward<Arg_>(value), args... , ::google::protobuf::internal::BytesTag{});
10524   // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
10525 }
10526 template <typename Arg_, typename... Args_>
10527 inline void TensorProto::add_string_data(Arg_&& value, Args_... args) {
10528   ::google::protobuf::internal::TSanWrite(&_impl_);
10529   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_string_data(),
10530                                std::forward<Arg_>(value),
10531                                args... , ::google::protobuf::internal::BytesTag{});
10532   // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
10533 }
10534 inline const ::google::protobuf::RepeatedPtrField<std::string>&
10535 TensorProto::string_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
10536   // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
10537   return _internal_string_data();
10538 }
10539 inline ::google::protobuf::RepeatedPtrField<std::string>*
10540 TensorProto::mutable_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10541   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
10542   ::google::protobuf::internal::TSanWrite(&_impl_);
10543   return _internal_mutable_string_data();
10544 }
10545 inline const ::google::protobuf::RepeatedPtrField<std::string>&
10546 TensorProto::_internal_string_data() const {
10547   ::google::protobuf::internal::TSanRead(&_impl_);
10548   return _impl_.string_data_;
10549 }
10550 inline ::google::protobuf::RepeatedPtrField<std::string>*
10551 TensorProto::_internal_mutable_string_data() {
10552   ::google::protobuf::internal::TSanRead(&_impl_);
10553   return &_impl_.string_data_;
10554 }
10555
10556 // repeated int64 int64_data = 7 [packed = true];
10557 inline int TensorProto::_internal_int64_data_size() const {
10558   return _internal_int64_data().size();
10559 }
10560 inline int TensorProto::int64_data_size() const {
10561   return _internal_int64_data_size();
10562 }
10563 inline void TensorProto::clear_int64_data() {
10564   ::google::protobuf::internal::TSanWrite(&_impl_);
10565   _impl_.int64_data_.Clear();
10566 }
10567 inline ::int64_t TensorProto::int64_data(int index) const {
10568   // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
10569   return _internal_int64_data().Get(index);
10570 }
10571 inline void TensorProto::set_int64_data(int index, ::int64_t value) {
10572   _internal_mutable_int64_data()->Set(index, value);
10573   // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
10574 }
10575 inline void TensorProto::add_int64_data(::int64_t value) {
10576   ::google::protobuf::internal::TSanWrite(&_impl_);
10577   _internal_mutable_int64_data()->Add(value);
10578   // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
10579 }
10580 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::int64_data() const
10581     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10582   // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
10583   return _internal_int64_data();
10584 }
10585 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::mutable_int64_data()
10586     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10587   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
10588   ::google::protobuf::internal::TSanWrite(&_impl_);
10589   return _internal_mutable_int64_data();
10590 }
10591 inline const ::google::protobuf::RepeatedField<::int64_t>&
10592 TensorProto::_internal_int64_data() const {
10593   ::google::protobuf::internal::TSanRead(&_impl_);
10594   return _impl_.int64_data_;
10595 }
10596 inline ::google::protobuf::RepeatedField<::int64_t>* TensorProto::_internal_mutable_int64_data() {
10597   ::google::protobuf::internal::TSanRead(&_impl_);
10598   return &_impl_.int64_data_;
10599 }
10600
10601 // optional string name = 8;
10602 inline bool TensorProto::has_name() const {
10603   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
10604   return value;
10605 }
10606 inline void TensorProto::clear_name() {
10607   ::google::protobuf::internal::TSanWrite(&_impl_);
10608   _impl_.name_.ClearToEmpty();
10609   _impl_._has_bits_[0] &= ~0x00000001u;
10610 }
10611 inline const std::string& TensorProto::name() const
10612     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10613   // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
10614   return _internal_name();
10615 }
10616 template <typename Arg_, typename... Args_>
10617 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_name(Arg_&& arg,
10618                                                      Args_... args) {
10619   ::google::protobuf::internal::TSanWrite(&_impl_);
10620   _impl_._has_bits_[0] |= 0x00000001u;
10621   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
10622   // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
10623 }
10624 inline std::string* TensorProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10625   std::string* _s = _internal_mutable_name();
10626   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
10627   return _s;
10628 }
10629 inline const std::string& TensorProto::_internal_name() const {
10630   ::google::protobuf::internal::TSanRead(&_impl_);
10631   return _impl_.name_.Get();
10632 }
10633 inline void TensorProto::_internal_set_name(const std::string& value) {
10634   ::google::protobuf::internal::TSanWrite(&_impl_);
10635   _impl_._has_bits_[0] |= 0x00000001u;
10636   _impl_.name_.Set(value, GetArena());
10637 }
10638 inline std::string* TensorProto::_internal_mutable_name() {
10639   ::google::protobuf::internal::TSanWrite(&_impl_);
10640   _impl_._has_bits_[0] |= 0x00000001u;
10641   return _impl_.name_.Mutable( GetArena());
10642 }
10643 inline std::string* TensorProto::release_name() {
10644   ::google::protobuf::internal::TSanWrite(&_impl_);
10645   // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
10646   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
10647     return nullptr;
10648   }
10649   _impl_._has_bits_[0] &= ~0x00000001u;
10650   auto* released = _impl_.name_.Release();
10651   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10652   _impl_.name_.Set("", GetArena());
10653   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10654   return released;
10655 }
10656 inline void TensorProto::set_allocated_name(std::string* value) {
10657   ::google::protobuf::internal::TSanWrite(&_impl_);
10658   if (value != nullptr) {
10659     _impl_._has_bits_[0] |= 0x00000001u;
10660   } else {
10661     _impl_._has_bits_[0] &= ~0x00000001u;
10662   }
10663   _impl_.name_.SetAllocated(value, GetArena());
10664   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10665         if (_impl_.name_.IsDefault()) {
10666           _impl_.name_.Set("", GetArena());
10667         }
10668   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10669   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
10670 }
10671
10672 // optional string doc_string = 12;
10673 inline bool TensorProto::has_doc_string() const {
10674   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
10675   return value;
10676 }
10677 inline void TensorProto::clear_doc_string() {
10678   ::google::protobuf::internal::TSanWrite(&_impl_);
10679   _impl_.doc_string_.ClearToEmpty();
10680   _impl_._has_bits_[0] &= ~0x00000004u;
10681 }
10682 inline const std::string& TensorProto::doc_string() const
10683     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10684   // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
10685   return _internal_doc_string();
10686 }
10687 template <typename Arg_, typename... Args_>
10688 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_doc_string(Arg_&& arg,
10689                                                      Args_... args) {
10690   ::google::protobuf::internal::TSanWrite(&_impl_);
10691   _impl_._has_bits_[0] |= 0x00000004u;
10692   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
10693   // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
10694 }
10695 inline std::string* TensorProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10696   std::string* _s = _internal_mutable_doc_string();
10697   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
10698   return _s;
10699 }
10700 inline const std::string& TensorProto::_internal_doc_string() const {
10701   ::google::protobuf::internal::TSanRead(&_impl_);
10702   return _impl_.doc_string_.Get();
10703 }
10704 inline void TensorProto::_internal_set_doc_string(const std::string& value) {
10705   ::google::protobuf::internal::TSanWrite(&_impl_);
10706   _impl_._has_bits_[0] |= 0x00000004u;
10707   _impl_.doc_string_.Set(value, GetArena());
10708 }
10709 inline std::string* TensorProto::_internal_mutable_doc_string() {
10710   ::google::protobuf::internal::TSanWrite(&_impl_);
10711   _impl_._has_bits_[0] |= 0x00000004u;
10712   return _impl_.doc_string_.Mutable( GetArena());
10713 }
10714 inline std::string* TensorProto::release_doc_string() {
10715   ::google::protobuf::internal::TSanWrite(&_impl_);
10716   // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
10717   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
10718     return nullptr;
10719   }
10720   _impl_._has_bits_[0] &= ~0x00000004u;
10721   auto* released = _impl_.doc_string_.Release();
10722   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10723   _impl_.doc_string_.Set("", GetArena());
10724   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10725   return released;
10726 }
10727 inline void TensorProto::set_allocated_doc_string(std::string* value) {
10728   ::google::protobuf::internal::TSanWrite(&_impl_);
10729   if (value != nullptr) {
10730     _impl_._has_bits_[0] |= 0x00000004u;
10731   } else {
10732     _impl_._has_bits_[0] &= ~0x00000004u;
10733   }
10734   _impl_.doc_string_.SetAllocated(value, GetArena());
10735   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10736         if (_impl_.doc_string_.IsDefault()) {
10737           _impl_.doc_string_.Set("", GetArena());
10738         }
10739   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10740   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
10741 }
10742
10743 // optional bytes raw_data = 9;
10744 inline bool TensorProto::has_raw_data() const {
10745   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
10746   return value;
10747 }
10748 inline void TensorProto::clear_raw_data() {
10749   ::google::protobuf::internal::TSanWrite(&_impl_);
10750   _impl_.raw_data_.ClearToEmpty();
10751   _impl_._has_bits_[0] &= ~0x00000002u;
10752 }
10753 inline const std::string& TensorProto::raw_data() const
10754     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10755   // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
10756   return _internal_raw_data();
10757 }
10758 template <typename Arg_, typename... Args_>
10759 inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_raw_data(Arg_&& arg,
10760                                                      Args_... args) {
10761   ::google::protobuf::internal::TSanWrite(&_impl_);
10762   _impl_._has_bits_[0] |= 0x00000002u;
10763   _impl_.raw_data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
10764   // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
10765 }
10766 inline std::string* TensorProto::mutable_raw_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10767   std::string* _s = _internal_mutable_raw_data();
10768   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
10769   return _s;
10770 }
10771 inline const std::string& TensorProto::_internal_raw_data() const {
10772   ::google::protobuf::internal::TSanRead(&_impl_);
10773   return _impl_.raw_data_.Get();
10774 }
10775 inline void TensorProto::_internal_set_raw_data(const std::string& value) {
10776   ::google::protobuf::internal::TSanWrite(&_impl_);
10777   _impl_._has_bits_[0] |= 0x00000002u;
10778   _impl_.raw_data_.Set(value, GetArena());
10779 }
10780 inline std::string* TensorProto::_internal_mutable_raw_data() {
10781   ::google::protobuf::internal::TSanWrite(&_impl_);
10782   _impl_._has_bits_[0] |= 0x00000002u;
10783   return _impl_.raw_data_.Mutable( GetArena());
10784 }
10785 inline std::string* TensorProto::release_raw_data() {
10786   ::google::protobuf::internal::TSanWrite(&_impl_);
10787   // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
10788   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
10789     return nullptr;
10790   }
10791   _impl_._has_bits_[0] &= ~0x00000002u;
10792   auto* released = _impl_.raw_data_.Release();
10793   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10794   _impl_.raw_data_.Set("", GetArena());
10795   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10796   return released;
10797 }
10798 inline void TensorProto::set_allocated_raw_data(std::string* value) {
10799   ::google::protobuf::internal::TSanWrite(&_impl_);
10800   if (value != nullptr) {
10801     _impl_._has_bits_[0] |= 0x00000002u;
10802   } else {
10803     _impl_._has_bits_[0] &= ~0x00000002u;
10804   }
10805   _impl_.raw_data_.SetAllocated(value, GetArena());
10806   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10807         if (_impl_.raw_data_.IsDefault()) {
10808           _impl_.raw_data_.Set("", GetArena());
10809         }
10810   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10811   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
10812 }
10813
10814 // repeated .onnx.StringStringEntryProto external_data = 13;
10815 inline int TensorProto::_internal_external_data_size() const {
10816   return _internal_external_data().size();
10817 }
10818 inline int TensorProto::external_data_size() const {
10819   return _internal_external_data_size();
10820 }
10821 inline void TensorProto::clear_external_data() {
10822   ::google::protobuf::internal::TSanWrite(&_impl_);
10823   _impl_.external_data_.Clear();
10824 }
10825 inline ::onnx::StringStringEntryProto* TensorProto::mutable_external_data(int index)
10826     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10827   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
10828   return _internal_mutable_external_data()->Mutable(index);
10829 }
10830 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TensorProto::mutable_external_data()
10831     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10832   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
10833   ::google::protobuf::internal::TSanWrite(&_impl_);
10834   return _internal_mutable_external_data();
10835 }
10836 inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const
10837     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10838   // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
10839   return _internal_external_data().Get(index);
10840 }
10841 inline ::onnx::StringStringEntryProto* TensorProto::add_external_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10842   ::google::protobuf::internal::TSanWrite(&_impl_);
10843   ::onnx::StringStringEntryProto* _add = _internal_mutable_external_data()->Add();
10844   // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
10845   return _add;
10846 }
10847 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::external_data() const
10848     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10849   // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
10850   return _internal_external_data();
10851 }
10852 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
10853 TensorProto::_internal_external_data() const {
10854   ::google::protobuf::internal::TSanRead(&_impl_);
10855   return _impl_.external_data_;
10856 }
10857 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
10858 TensorProto::_internal_mutable_external_data() {
10859   ::google::protobuf::internal::TSanRead(&_impl_);
10860   return &_impl_.external_data_;
10861 }
10862
10863 // optional .onnx.TensorProto.DataLocation data_location = 14;
10864 inline bool TensorProto::has_data_location() const {
10865   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
10866   return value;
10867 }
10868 inline void TensorProto::clear_data_location() {
10869   ::google::protobuf::internal::TSanWrite(&_impl_);
10870   _impl_.data_location_ = 0;
10871   _impl_._has_bits_[0] &= ~0x00000020u;
10872 }
10873 inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
10874   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
10875   return _internal_data_location();
10876 }
10877 inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
10878   _internal_set_data_location(value);
10879   _impl_._has_bits_[0] |= 0x00000020u;
10880   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
10881 }
10882 inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
10883   ::google::protobuf::internal::TSanRead(&_impl_);
10884   return static_cast<::onnx::TensorProto_DataLocation>(_impl_.data_location_);
10885 }
10886 inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
10887   ::google::protobuf::internal::TSanWrite(&_impl_);
10888   assert(::onnx::TensorProto_DataLocation_IsValid(value));
10889   _impl_.data_location_ = value;
10890 }
10891
10892 // repeated double double_data = 10 [packed = true];
10893 inline int TensorProto::_internal_double_data_size() const {
10894   return _internal_double_data().size();
10895 }
10896 inline int TensorProto::double_data_size() const {
10897   return _internal_double_data_size();
10898 }
10899 inline void TensorProto::clear_double_data() {
10900   ::google::protobuf::internal::TSanWrite(&_impl_);
10901   _impl_.double_data_.Clear();
10902 }
10903 inline double TensorProto::double_data(int index) const {
10904   // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
10905   return _internal_double_data().Get(index);
10906 }
10907 inline void TensorProto::set_double_data(int index, double value) {
10908   _internal_mutable_double_data()->Set(index, value);
10909   // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
10910 }
10911 inline void TensorProto::add_double_data(double value) {
10912   ::google::protobuf::internal::TSanWrite(&_impl_);
10913   _internal_mutable_double_data()->Add(value);
10914   // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
10915 }
10916 inline const ::google::protobuf::RepeatedField<double>& TensorProto::double_data() const
10917     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10918   // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
10919   return _internal_double_data();
10920 }
10921 inline ::google::protobuf::RepeatedField<double>* TensorProto::mutable_double_data()
10922     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10923   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
10924   ::google::protobuf::internal::TSanWrite(&_impl_);
10925   return _internal_mutable_double_data();
10926 }
10927 inline const ::google::protobuf::RepeatedField<double>&
10928 TensorProto::_internal_double_data() const {
10929   ::google::protobuf::internal::TSanRead(&_impl_);
10930   return _impl_.double_data_;
10931 }
10932 inline ::google::protobuf::RepeatedField<double>* TensorProto::_internal_mutable_double_data() {
10933   ::google::protobuf::internal::TSanRead(&_impl_);
10934   return &_impl_.double_data_;
10935 }
10936
10937 // repeated uint64 uint64_data = 11 [packed = true];
10938 inline int TensorProto::_internal_uint64_data_size() const {
10939   return _internal_uint64_data().size();
10940 }
10941 inline int TensorProto::uint64_data_size() const {
10942   return _internal_uint64_data_size();
10943 }
10944 inline void TensorProto::clear_uint64_data() {
10945   ::google::protobuf::internal::TSanWrite(&_impl_);
10946   _impl_.uint64_data_.Clear();
10947 }
10948 inline ::uint64_t TensorProto::uint64_data(int index) const {
10949   // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
10950   return _internal_uint64_data().Get(index);
10951 }
10952 inline void TensorProto::set_uint64_data(int index, ::uint64_t value) {
10953   _internal_mutable_uint64_data()->Set(index, value);
10954   // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
10955 }
10956 inline void TensorProto::add_uint64_data(::uint64_t value) {
10957   ::google::protobuf::internal::TSanWrite(&_impl_);
10958   _internal_mutable_uint64_data()->Add(value);
10959   // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
10960 }
10961 inline const ::google::protobuf::RepeatedField<::uint64_t>& TensorProto::uint64_data() const
10962     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10963   // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
10964   return _internal_uint64_data();
10965 }
10966 inline ::google::protobuf::RepeatedField<::uint64_t>* TensorProto::mutable_uint64_data()
10967     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10968   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
10969   ::google::protobuf::internal::TSanWrite(&_impl_);
10970   return _internal_mutable_uint64_data();
10971 }
10972 inline const ::google::protobuf::RepeatedField<::uint64_t>&
10973 TensorProto::_internal_uint64_data() const {
10974   ::google::protobuf::internal::TSanRead(&_impl_);
10975   return _impl_.uint64_data_;
10976 }
10977 inline ::google::protobuf::RepeatedField<::uint64_t>* TensorProto::_internal_mutable_uint64_data() {
10978   ::google::protobuf::internal::TSanRead(&_impl_);
10979   return &_impl_.uint64_data_;
10980 }
10981
10982 // repeated .onnx.StringStringEntryProto metadata_props = 16;
10983 inline int TensorProto::_internal_metadata_props_size() const {
10984   return _internal_metadata_props().size();
10985 }
10986 inline int TensorProto::metadata_props_size() const {
10987   return _internal_metadata_props_size();
10988 }
10989 inline void TensorProto::clear_metadata_props() {
10990   ::google::protobuf::internal::TSanWrite(&_impl_);
10991   _impl_.metadata_props_.Clear();
10992 }
10993 inline ::onnx::StringStringEntryProto* TensorProto::mutable_metadata_props(int index)
10994     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10995   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props)
10996   return _internal_mutable_metadata_props()->Mutable(index);
10997 }
10998 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* TensorProto::mutable_metadata_props()
10999     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11000   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props)
11001   ::google::protobuf::internal::TSanWrite(&_impl_);
11002   return _internal_mutable_metadata_props();
11003 }
11004 inline const ::onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const
11005     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11006   // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props)
11007   return _internal_metadata_props().Get(index);
11008 }
11009 inline ::onnx::StringStringEntryProto* TensorProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11010   ::google::protobuf::internal::TSanWrite(&_impl_);
11011   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
11012   // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props)
11013   return _add;
11014 }
11015 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::metadata_props() const
11016     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11017   // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props)
11018   return _internal_metadata_props();
11019 }
11020 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
11021 TensorProto::_internal_metadata_props() const {
11022   ::google::protobuf::internal::TSanRead(&_impl_);
11023   return _impl_.metadata_props_;
11024 }
11025 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
11026 TensorProto::_internal_mutable_metadata_props() {
11027   ::google::protobuf::internal::TSanRead(&_impl_);
11028   return &_impl_.metadata_props_;
11029 }
11030
11031 // -------------------------------------------------------------------
11032
11033 // SparseTensorProto
11034
11035 // optional .onnx.TensorProto values = 1;
11036 inline bool SparseTensorProto::has_values() const {
11037   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11038   PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
11039   return value;
11040 }
11041 inline void SparseTensorProto::clear_values() {
11042   ::google::protobuf::internal::TSanWrite(&_impl_);
11043   if (_impl_.values_ != nullptr) _impl_.values_->Clear();
11044   _impl_._has_bits_[0] &= ~0x00000001u;
11045 }
11046 inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
11047   ::google::protobuf::internal::TSanRead(&_impl_);
11048   const ::onnx::TensorProto* p = _impl_.values_;
11049   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
11050 }
11051 inline const ::onnx::TensorProto& SparseTensorProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11052   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
11053   return _internal_values();
11054 }
11055 inline void SparseTensorProto::unsafe_arena_set_allocated_values(::onnx::TensorProto* value) {
11056   ::google::protobuf::internal::TSanWrite(&_impl_);
11057   if (GetArena() == nullptr) {
11058     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
11059   }
11060   _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
11061   if (value != nullptr) {
11062     _impl_._has_bits_[0] |= 0x00000001u;
11063   } else {
11064     _impl_._has_bits_[0] &= ~0x00000001u;
11065   }
11066   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
11067 }
11068 inline ::onnx::TensorProto* SparseTensorProto::release_values() {
11069   ::google::protobuf::internal::TSanWrite(&_impl_);
11070
11071   _impl_._has_bits_[0] &= ~0x00000001u;
11072   ::onnx::TensorProto* released = _impl_.values_;
11073   _impl_.values_ = nullptr;
11074 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11075   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11076   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11077   if (GetArena() == nullptr) {
11078     delete old;
11079   }
11080 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11081   if (GetArena() != nullptr) {
11082     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11083   }
11084 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11085   return released;
11086 }
11087 inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_values() {
11088   ::google::protobuf::internal::TSanWrite(&_impl_);
11089   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)
11090
11091   _impl_._has_bits_[0] &= ~0x00000001u;
11092   ::onnx::TensorProto* temp = _impl_.values_;
11093   _impl_.values_ = nullptr;
11094   return temp;
11095 }
11096 inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_values() {
11097   ::google::protobuf::internal::TSanWrite(&_impl_);
11098   if (_impl_.values_ == nullptr) {
11099     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
11100     _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(p);
11101   }
11102   return _impl_.values_;
11103 }
11104 inline ::onnx::TensorProto* SparseTensorProto::mutable_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11105   _impl_._has_bits_[0] |= 0x00000001u;
11106   ::onnx::TensorProto* _msg = _internal_mutable_values();
11107   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
11108   return _msg;
11109 }
11110 inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* value) {
11111   ::google::protobuf::Arena* message_arena = GetArena();
11112   ::google::protobuf::internal::TSanWrite(&_impl_);
11113   if (message_arena == nullptr) {
11114     delete (_impl_.values_);
11115   }
11116
11117   if (value != nullptr) {
11118     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11119     if (message_arena != submessage_arena) {
11120       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11121     }
11122     _impl_._has_bits_[0] |= 0x00000001u;
11123   } else {
11124     _impl_._has_bits_[0] &= ~0x00000001u;
11125   }
11126
11127   _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
11128   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
11129 }
11130
11131 // optional .onnx.TensorProto indices = 2;
11132 inline bool SparseTensorProto::has_indices() const {
11133   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
11134   PROTOBUF_ASSUME(!value || _impl_.indices_ != nullptr);
11135   return value;
11136 }
11137 inline void SparseTensorProto::clear_indices() {
11138   ::google::protobuf::internal::TSanWrite(&_impl_);
11139   if (_impl_.indices_ != nullptr) _impl_.indices_->Clear();
11140   _impl_._has_bits_[0] &= ~0x00000002u;
11141 }
11142 inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
11143   ::google::protobuf::internal::TSanRead(&_impl_);
11144   const ::onnx::TensorProto* p = _impl_.indices_;
11145   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
11146 }
11147 inline const ::onnx::TensorProto& SparseTensorProto::indices() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11148   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
11149   return _internal_indices();
11150 }
11151 inline void SparseTensorProto::unsafe_arena_set_allocated_indices(::onnx::TensorProto* value) {
11152   ::google::protobuf::internal::TSanWrite(&_impl_);
11153   if (GetArena() == nullptr) {
11154     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
11155   }
11156   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
11157   if (value != nullptr) {
11158     _impl_._has_bits_[0] |= 0x00000002u;
11159   } else {
11160     _impl_._has_bits_[0] &= ~0x00000002u;
11161   }
11162   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
11163 }
11164 inline ::onnx::TensorProto* SparseTensorProto::release_indices() {
11165   ::google::protobuf::internal::TSanWrite(&_impl_);
11166
11167   _impl_._has_bits_[0] &= ~0x00000002u;
11168   ::onnx::TensorProto* released = _impl_.indices_;
11169   _impl_.indices_ = nullptr;
11170 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11171   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11172   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11173   if (GetArena() == nullptr) {
11174     delete old;
11175   }
11176 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11177   if (GetArena() != nullptr) {
11178     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11179   }
11180 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11181   return released;
11182 }
11183 inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_indices() {
11184   ::google::protobuf::internal::TSanWrite(&_impl_);
11185   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)
11186
11187   _impl_._has_bits_[0] &= ~0x00000002u;
11188   ::onnx::TensorProto* temp = _impl_.indices_;
11189   _impl_.indices_ = nullptr;
11190   return temp;
11191 }
11192 inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_indices() {
11193   ::google::protobuf::internal::TSanWrite(&_impl_);
11194   if (_impl_.indices_ == nullptr) {
11195     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
11196     _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(p);
11197   }
11198   return _impl_.indices_;
11199 }
11200 inline ::onnx::TensorProto* SparseTensorProto::mutable_indices() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11201   _impl_._has_bits_[0] |= 0x00000002u;
11202   ::onnx::TensorProto* _msg = _internal_mutable_indices();
11203   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
11204   return _msg;
11205 }
11206 inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* value) {
11207   ::google::protobuf::Arena* message_arena = GetArena();
11208   ::google::protobuf::internal::TSanWrite(&_impl_);
11209   if (message_arena == nullptr) {
11210     delete (_impl_.indices_);
11211   }
11212
11213   if (value != nullptr) {
11214     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11215     if (message_arena != submessage_arena) {
11216       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11217     }
11218     _impl_._has_bits_[0] |= 0x00000002u;
11219   } else {
11220     _impl_._has_bits_[0] &= ~0x00000002u;
11221   }
11222
11223   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
11224   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
11225 }
11226
11227 // repeated int64 dims = 3;
11228 inline int SparseTensorProto::_internal_dims_size() const {
11229   return _internal_dims().size();
11230 }
11231 inline int SparseTensorProto::dims_size() const {
11232   return _internal_dims_size();
11233 }
11234 inline void SparseTensorProto::clear_dims() {
11235   ::google::protobuf::internal::TSanWrite(&_impl_);
11236   _impl_.dims_.Clear();
11237 }
11238 inline ::int64_t SparseTensorProto::dims(int index) const {
11239   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
11240   return _internal_dims().Get(index);
11241 }
11242 inline void SparseTensorProto::set_dims(int index, ::int64_t value) {
11243   _internal_mutable_dims()->Set(index, value);
11244   // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
11245 }
11246 inline void SparseTensorProto::add_dims(::int64_t value) {
11247   ::google::protobuf::internal::TSanWrite(&_impl_);
11248   _internal_mutable_dims()->Add(value);
11249   // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
11250 }
11251 inline const ::google::protobuf::RepeatedField<::int64_t>& SparseTensorProto::dims() const
11252     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11253   // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
11254   return _internal_dims();
11255 }
11256 inline ::google::protobuf::RepeatedField<::int64_t>* SparseTensorProto::mutable_dims()
11257     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11258   // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
11259   ::google::protobuf::internal::TSanWrite(&_impl_);
11260   return _internal_mutable_dims();
11261 }
11262 inline const ::google::protobuf::RepeatedField<::int64_t>&
11263 SparseTensorProto::_internal_dims() const {
11264   ::google::protobuf::internal::TSanRead(&_impl_);
11265   return _impl_.dims_;
11266 }
11267 inline ::google::protobuf::RepeatedField<::int64_t>* SparseTensorProto::_internal_mutable_dims() {
11268   ::google::protobuf::internal::TSanRead(&_impl_);
11269   return &_impl_.dims_;
11270 }
11271
11272 // -------------------------------------------------------------------
11273
11274 // TensorShapeProto_Dimension
11275
11276 // int64 dim_value = 1;
11277 inline bool TensorShapeProto_Dimension::has_dim_value() const {
11278   return value_case() == kDimValue;
11279 }
11280 inline void TensorShapeProto_Dimension::set_has_dim_value() {
11281   _impl_._oneof_case_[0] = kDimValue;
11282 }
11283 inline void TensorShapeProto_Dimension::clear_dim_value() {
11284   ::google::protobuf::internal::TSanWrite(&_impl_);
11285   if (value_case() == kDimValue) {
11286     _impl_.value_.dim_value_ = ::int64_t{0};
11287     clear_has_value();
11288   }
11289 }
11290 inline ::int64_t TensorShapeProto_Dimension::dim_value() const {
11291   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
11292   return _internal_dim_value();
11293 }
11294 inline void TensorShapeProto_Dimension::set_dim_value(::int64_t value) {
11295   if (value_case() != kDimValue) {
11296     clear_value();
11297     set_has_dim_value();
11298   }
11299   _impl_.value_.dim_value_ = value;
11300   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
11301 }
11302 inline ::int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
11303   if (value_case() == kDimValue) {
11304     return _impl_.value_.dim_value_;
11305   }
11306   return ::int64_t{0};
11307 }
11308
11309 // string dim_param = 2;
11310 inline bool TensorShapeProto_Dimension::has_dim_param() const {
11311   return value_case() == kDimParam;
11312 }
11313 inline void TensorShapeProto_Dimension::set_has_dim_param() {
11314   _impl_._oneof_case_[0] = kDimParam;
11315 }
11316 inline void TensorShapeProto_Dimension::clear_dim_param() {
11317   ::google::protobuf::internal::TSanWrite(&_impl_);
11318   if (value_case() == kDimParam) {
11319     _impl_.value_.dim_param_.Destroy();
11320     clear_has_value();
11321   }
11322 }
11323 inline const std::string& TensorShapeProto_Dimension::dim_param() const
11324     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11325   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
11326   return _internal_dim_param();
11327 }
11328 template <typename Arg_, typename... Args_>
11329 inline PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_dim_param(Arg_&& arg,
11330                                                      Args_... args) {
11331   ::google::protobuf::internal::TSanWrite(&_impl_);
11332   if (value_case() != kDimParam) {
11333     clear_value();
11334
11335     set_has_dim_param();
11336     _impl_.value_.dim_param_.InitDefault();
11337   }
11338   _impl_.value_.dim_param_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
11339   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
11340 }
11341 inline std::string* TensorShapeProto_Dimension::mutable_dim_param() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11342   std::string* _s = _internal_mutable_dim_param();
11343   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
11344   return _s;
11345 }
11346 inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
11347   ::google::protobuf::internal::TSanRead(&_impl_);
11348   if (value_case() != kDimParam) {
11349     return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
11350   }
11351   return _impl_.value_.dim_param_.Get();
11352 }
11353 inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
11354   ::google::protobuf::internal::TSanWrite(&_impl_);
11355   if (value_case() != kDimParam) {
11356     clear_value();
11357
11358     set_has_dim_param();
11359     _impl_.value_.dim_param_.InitDefault();
11360   }
11361   _impl_.value_.dim_param_.Set(value, GetArena());
11362 }
11363 inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
11364   ::google::protobuf::internal::TSanWrite(&_impl_);
11365   if (value_case() != kDimParam) {
11366     clear_value();
11367
11368     set_has_dim_param();
11369     _impl_.value_.dim_param_.InitDefault();
11370   }
11371   return _impl_.value_.dim_param_.Mutable( GetArena());
11372 }
11373 inline std::string* TensorShapeProto_Dimension::release_dim_param() {
11374   ::google::protobuf::internal::TSanWrite(&_impl_);
11375   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
11376   if (value_case() != kDimParam) {
11377     return nullptr;
11378   }
11379   clear_has_value();
11380   return _impl_.value_.dim_param_.Release();
11381 }
11382 inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* value) {
11383   ::google::protobuf::internal::TSanWrite(&_impl_);
11384   if (has_value()) {
11385     clear_value();
11386   }
11387   if (value != nullptr) {
11388     set_has_dim_param();
11389     _impl_.value_.dim_param_.InitAllocated(value, GetArena());
11390   }
11391   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
11392 }
11393
11394 // optional string denotation = 3;
11395 inline bool TensorShapeProto_Dimension::has_denotation() const {
11396   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11397   return value;
11398 }
11399 inline void TensorShapeProto_Dimension::clear_denotation() {
11400   ::google::protobuf::internal::TSanWrite(&_impl_);
11401   _impl_.denotation_.ClearToEmpty();
11402   _impl_._has_bits_[0] &= ~0x00000001u;
11403 }
11404 inline const std::string& TensorShapeProto_Dimension::denotation() const
11405     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11406   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
11407   return _internal_denotation();
11408 }
11409 template <typename Arg_, typename... Args_>
11410 inline PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_denotation(Arg_&& arg,
11411                                                      Args_... args) {
11412   ::google::protobuf::internal::TSanWrite(&_impl_);
11413   _impl_._has_bits_[0] |= 0x00000001u;
11414   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
11415   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
11416 }
11417 inline std::string* TensorShapeProto_Dimension::mutable_denotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11418   std::string* _s = _internal_mutable_denotation();
11419   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
11420   return _s;
11421 }
11422 inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
11423   ::google::protobuf::internal::TSanRead(&_impl_);
11424   return _impl_.denotation_.Get();
11425 }
11426 inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
11427   ::google::protobuf::internal::TSanWrite(&_impl_);
11428   _impl_._has_bits_[0] |= 0x00000001u;
11429   _impl_.denotation_.Set(value, GetArena());
11430 }
11431 inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
11432   ::google::protobuf::internal::TSanWrite(&_impl_);
11433   _impl_._has_bits_[0] |= 0x00000001u;
11434   return _impl_.denotation_.Mutable( GetArena());
11435 }
11436 inline std::string* TensorShapeProto_Dimension::release_denotation() {
11437   ::google::protobuf::internal::TSanWrite(&_impl_);
11438   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
11439   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
11440     return nullptr;
11441   }
11442   _impl_._has_bits_[0] &= ~0x00000001u;
11443   auto* released = _impl_.denotation_.Release();
11444   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
11445   _impl_.denotation_.Set("", GetArena());
11446   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
11447   return released;
11448 }
11449 inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* value) {
11450   ::google::protobuf::internal::TSanWrite(&_impl_);
11451   if (value != nullptr) {
11452     _impl_._has_bits_[0] |= 0x00000001u;
11453   } else {
11454     _impl_._has_bits_[0] &= ~0x00000001u;
11455   }
11456   _impl_.denotation_.SetAllocated(value, GetArena());
11457   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
11458         if (_impl_.denotation_.IsDefault()) {
11459           _impl_.denotation_.Set("", GetArena());
11460         }
11461   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
11462   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
11463 }
11464
11465 inline bool TensorShapeProto_Dimension::has_value() const {
11466   return value_case() != VALUE_NOT_SET;
11467 }
11468 inline void TensorShapeProto_Dimension::clear_has_value() {
11469   _impl_._oneof_case_[0] = VALUE_NOT_SET;
11470 }
11471 inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
11472   return TensorShapeProto_Dimension::ValueCase(_impl_._oneof_case_[0]);
11473 }
11474 // -------------------------------------------------------------------
11475
11476 // TensorShapeProto
11477
11478 // repeated .onnx.TensorShapeProto.Dimension dim = 1;
11479 inline int TensorShapeProto::_internal_dim_size() const {
11480   return _internal_dim().size();
11481 }
11482 inline int TensorShapeProto::dim_size() const {
11483   return _internal_dim_size();
11484 }
11485 inline void TensorShapeProto::clear_dim() {
11486   ::google::protobuf::internal::TSanWrite(&_impl_);
11487   _impl_.dim_.Clear();
11488 }
11489 inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index)
11490     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11491   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
11492   return _internal_mutable_dim()->Mutable(index);
11493 }
11494 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* TensorShapeProto::mutable_dim()
11495     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11496   // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
11497   ::google::protobuf::internal::TSanWrite(&_impl_);
11498   return _internal_mutable_dim();
11499 }
11500 inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const
11501     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11502   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
11503   return _internal_dim().Get(index);
11504 }
11505 inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11506   ::google::protobuf::internal::TSanWrite(&_impl_);
11507   ::onnx::TensorShapeProto_Dimension* _add = _internal_mutable_dim()->Add();
11508   // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
11509   return _add;
11510 }
11511 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& TensorShapeProto::dim() const
11512     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11513   // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
11514   return _internal_dim();
11515 }
11516 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>&
11517 TensorShapeProto::_internal_dim() const {
11518   ::google::protobuf::internal::TSanRead(&_impl_);
11519   return _impl_.dim_;
11520 }
11521 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>*
11522 TensorShapeProto::_internal_mutable_dim() {
11523   ::google::protobuf::internal::TSanRead(&_impl_);
11524   return &_impl_.dim_;
11525 }
11526
11527 // -------------------------------------------------------------------
11528
11529 // TypeProto_Tensor
11530
11531 // optional int32 elem_type = 1;
11532 inline bool TypeProto_Tensor::has_elem_type() const {
11533   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
11534   return value;
11535 }
11536 inline void TypeProto_Tensor::clear_elem_type() {
11537   ::google::protobuf::internal::TSanWrite(&_impl_);
11538   _impl_.elem_type_ = 0;
11539   _impl_._has_bits_[0] &= ~0x00000002u;
11540 }
11541 inline ::int32_t TypeProto_Tensor::elem_type() const {
11542   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
11543   return _internal_elem_type();
11544 }
11545 inline void TypeProto_Tensor::set_elem_type(::int32_t value) {
11546   _internal_set_elem_type(value);
11547   _impl_._has_bits_[0] |= 0x00000002u;
11548   // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
11549 }
11550 inline ::int32_t TypeProto_Tensor::_internal_elem_type() const {
11551   ::google::protobuf::internal::TSanRead(&_impl_);
11552   return _impl_.elem_type_;
11553 }
11554 inline void TypeProto_Tensor::_internal_set_elem_type(::int32_t value) {
11555   ::google::protobuf::internal::TSanWrite(&_impl_);
11556   _impl_.elem_type_ = value;
11557 }
11558
11559 // optional .onnx.TensorShapeProto shape = 2;
11560 inline bool TypeProto_Tensor::has_shape() const {
11561   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11562   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
11563   return value;
11564 }
11565 inline void TypeProto_Tensor::clear_shape() {
11566   ::google::protobuf::internal::TSanWrite(&_impl_);
11567   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
11568   _impl_._has_bits_[0] &= ~0x00000001u;
11569 }
11570 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
11571   ::google::protobuf::internal::TSanRead(&_impl_);
11572   const ::onnx::TensorShapeProto* p = _impl_.shape_;
11573   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
11574 }
11575 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11576   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
11577   return _internal_shape();
11578 }
11579 inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value) {
11580   ::google::protobuf::internal::TSanWrite(&_impl_);
11581   if (GetArena() == nullptr) {
11582     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
11583   }
11584   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
11585   if (value != nullptr) {
11586     _impl_._has_bits_[0] |= 0x00000001u;
11587   } else {
11588     _impl_._has_bits_[0] &= ~0x00000001u;
11589   }
11590   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
11591 }
11592 inline ::onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
11593   ::google::protobuf::internal::TSanWrite(&_impl_);
11594
11595   _impl_._has_bits_[0] &= ~0x00000001u;
11596   ::onnx::TensorShapeProto* released = _impl_.shape_;
11597   _impl_.shape_ = nullptr;
11598 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11599   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11600   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11601   if (GetArena() == nullptr) {
11602     delete old;
11603   }
11604 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11605   if (GetArena() != nullptr) {
11606     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11607   }
11608 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11609   return released;
11610 }
11611 inline ::onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
11612   ::google::protobuf::internal::TSanWrite(&_impl_);
11613   // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)
11614
11615   _impl_._has_bits_[0] &= ~0x00000001u;
11616   ::onnx::TensorShapeProto* temp = _impl_.shape_;
11617   _impl_.shape_ = nullptr;
11618   return temp;
11619 }
11620 inline ::onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
11621   ::google::protobuf::internal::TSanWrite(&_impl_);
11622   if (_impl_.shape_ == nullptr) {
11623     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
11624     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
11625   }
11626   return _impl_.shape_;
11627 }
11628 inline ::onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11629   _impl_._has_bits_[0] |= 0x00000001u;
11630   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
11631   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
11632   return _msg;
11633 }
11634 inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* value) {
11635   ::google::protobuf::Arena* message_arena = GetArena();
11636   ::google::protobuf::internal::TSanWrite(&_impl_);
11637   if (message_arena == nullptr) {
11638     delete (_impl_.shape_);
11639   }
11640
11641   if (value != nullptr) {
11642     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11643     if (message_arena != submessage_arena) {
11644       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11645     }
11646     _impl_._has_bits_[0] |= 0x00000001u;
11647   } else {
11648     _impl_._has_bits_[0] &= ~0x00000001u;
11649   }
11650
11651   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
11652   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
11653 }
11654
11655 // -------------------------------------------------------------------
11656
11657 // TypeProto_Sequence
11658
11659 // optional .onnx.TypeProto elem_type = 1;
11660 inline bool TypeProto_Sequence::has_elem_type() const {
11661   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11662   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
11663   return value;
11664 }
11665 inline void TypeProto_Sequence::clear_elem_type() {
11666   ::google::protobuf::internal::TSanWrite(&_impl_);
11667   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
11668   _impl_._has_bits_[0] &= ~0x00000001u;
11669 }
11670 inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
11671   ::google::protobuf::internal::TSanRead(&_impl_);
11672   const ::onnx::TypeProto* p = _impl_.elem_type_;
11673   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
11674 }
11675 inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11676   // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
11677   return _internal_elem_type();
11678 }
11679 inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value) {
11680   ::google::protobuf::internal::TSanWrite(&_impl_);
11681   if (GetArena() == nullptr) {
11682     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
11683   }
11684   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11685   if (value != nullptr) {
11686     _impl_._has_bits_[0] |= 0x00000001u;
11687   } else {
11688     _impl_._has_bits_[0] &= ~0x00000001u;
11689   }
11690   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
11691 }
11692 inline ::onnx::TypeProto* TypeProto_Sequence::release_elem_type() {
11693   ::google::protobuf::internal::TSanWrite(&_impl_);
11694
11695   _impl_._has_bits_[0] &= ~0x00000001u;
11696   ::onnx::TypeProto* released = _impl_.elem_type_;
11697   _impl_.elem_type_ = nullptr;
11698 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11699   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11700   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11701   if (GetArena() == nullptr) {
11702     delete old;
11703   }
11704 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11705   if (GetArena() != nullptr) {
11706     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11707   }
11708 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11709   return released;
11710 }
11711 inline ::onnx::TypeProto* TypeProto_Sequence::unsafe_arena_release_elem_type() {
11712   ::google::protobuf::internal::TSanWrite(&_impl_);
11713   // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)
11714
11715   _impl_._has_bits_[0] &= ~0x00000001u;
11716   ::onnx::TypeProto* temp = _impl_.elem_type_;
11717   _impl_.elem_type_ = nullptr;
11718   return temp;
11719 }
11720 inline ::onnx::TypeProto* TypeProto_Sequence::_internal_mutable_elem_type() {
11721   ::google::protobuf::internal::TSanWrite(&_impl_);
11722   if (_impl_.elem_type_ == nullptr) {
11723     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
11724     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
11725   }
11726   return _impl_.elem_type_;
11727 }
11728 inline ::onnx::TypeProto* TypeProto_Sequence::mutable_elem_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11729   _impl_._has_bits_[0] |= 0x00000001u;
11730   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
11731   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
11732   return _msg;
11733 }
11734 inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* value) {
11735   ::google::protobuf::Arena* message_arena = GetArena();
11736   ::google::protobuf::internal::TSanWrite(&_impl_);
11737   if (message_arena == nullptr) {
11738     delete (_impl_.elem_type_);
11739   }
11740
11741   if (value != nullptr) {
11742     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11743     if (message_arena != submessage_arena) {
11744       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11745     }
11746     _impl_._has_bits_[0] |= 0x00000001u;
11747   } else {
11748     _impl_._has_bits_[0] &= ~0x00000001u;
11749   }
11750
11751   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11752   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
11753 }
11754
11755 // -------------------------------------------------------------------
11756
11757 // TypeProto_Map
11758
11759 // optional int32 key_type = 1;
11760 inline bool TypeProto_Map::has_key_type() const {
11761   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
11762   return value;
11763 }
11764 inline void TypeProto_Map::clear_key_type() {
11765   ::google::protobuf::internal::TSanWrite(&_impl_);
11766   _impl_.key_type_ = 0;
11767   _impl_._has_bits_[0] &= ~0x00000002u;
11768 }
11769 inline ::int32_t TypeProto_Map::key_type() const {
11770   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
11771   return _internal_key_type();
11772 }
11773 inline void TypeProto_Map::set_key_type(::int32_t value) {
11774   _internal_set_key_type(value);
11775   _impl_._has_bits_[0] |= 0x00000002u;
11776   // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
11777 }
11778 inline ::int32_t TypeProto_Map::_internal_key_type() const {
11779   ::google::protobuf::internal::TSanRead(&_impl_);
11780   return _impl_.key_type_;
11781 }
11782 inline void TypeProto_Map::_internal_set_key_type(::int32_t value) {
11783   ::google::protobuf::internal::TSanWrite(&_impl_);
11784   _impl_.key_type_ = value;
11785 }
11786
11787 // optional .onnx.TypeProto value_type = 2;
11788 inline bool TypeProto_Map::has_value_type() const {
11789   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11790   PROTOBUF_ASSUME(!value || _impl_.value_type_ != nullptr);
11791   return value;
11792 }
11793 inline void TypeProto_Map::clear_value_type() {
11794   ::google::protobuf::internal::TSanWrite(&_impl_);
11795   if (_impl_.value_type_ != nullptr) _impl_.value_type_->Clear();
11796   _impl_._has_bits_[0] &= ~0x00000001u;
11797 }
11798 inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
11799   ::google::protobuf::internal::TSanRead(&_impl_);
11800   const ::onnx::TypeProto* p = _impl_.value_type_;
11801   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
11802 }
11803 inline const ::onnx::TypeProto& TypeProto_Map::value_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11804   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
11805   return _internal_value_type();
11806 }
11807 inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(::onnx::TypeProto* value) {
11808   ::google::protobuf::internal::TSanWrite(&_impl_);
11809   if (GetArena() == nullptr) {
11810     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
11811   }
11812   _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11813   if (value != nullptr) {
11814     _impl_._has_bits_[0] |= 0x00000001u;
11815   } else {
11816     _impl_._has_bits_[0] &= ~0x00000001u;
11817   }
11818   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
11819 }
11820 inline ::onnx::TypeProto* TypeProto_Map::release_value_type() {
11821   ::google::protobuf::internal::TSanWrite(&_impl_);
11822
11823   _impl_._has_bits_[0] &= ~0x00000001u;
11824   ::onnx::TypeProto* released = _impl_.value_type_;
11825   _impl_.value_type_ = nullptr;
11826 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11827   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11828   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11829   if (GetArena() == nullptr) {
11830     delete old;
11831   }
11832 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11833   if (GetArena() != nullptr) {
11834     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11835   }
11836 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11837   return released;
11838 }
11839 inline ::onnx::TypeProto* TypeProto_Map::unsafe_arena_release_value_type() {
11840   ::google::protobuf::internal::TSanWrite(&_impl_);
11841   // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)
11842
11843   _impl_._has_bits_[0] &= ~0x00000001u;
11844   ::onnx::TypeProto* temp = _impl_.value_type_;
11845   _impl_.value_type_ = nullptr;
11846   return temp;
11847 }
11848 inline ::onnx::TypeProto* TypeProto_Map::_internal_mutable_value_type() {
11849   ::google::protobuf::internal::TSanWrite(&_impl_);
11850   if (_impl_.value_type_ == nullptr) {
11851     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
11852     _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
11853   }
11854   return _impl_.value_type_;
11855 }
11856 inline ::onnx::TypeProto* TypeProto_Map::mutable_value_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11857   _impl_._has_bits_[0] |= 0x00000001u;
11858   ::onnx::TypeProto* _msg = _internal_mutable_value_type();
11859   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
11860   return _msg;
11861 }
11862 inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* value) {
11863   ::google::protobuf::Arena* message_arena = GetArena();
11864   ::google::protobuf::internal::TSanWrite(&_impl_);
11865   if (message_arena == nullptr) {
11866     delete (_impl_.value_type_);
11867   }
11868
11869   if (value != nullptr) {
11870     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11871     if (message_arena != submessage_arena) {
11872       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11873     }
11874     _impl_._has_bits_[0] |= 0x00000001u;
11875   } else {
11876     _impl_._has_bits_[0] &= ~0x00000001u;
11877   }
11878
11879   _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11880   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
11881 }
11882
11883 // -------------------------------------------------------------------
11884
11885 // TypeProto_Optional
11886
11887 // optional .onnx.TypeProto elem_type = 1;
11888 inline bool TypeProto_Optional::has_elem_type() const {
11889   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
11890   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
11891   return value;
11892 }
11893 inline void TypeProto_Optional::clear_elem_type() {
11894   ::google::protobuf::internal::TSanWrite(&_impl_);
11895   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
11896   _impl_._has_bits_[0] &= ~0x00000001u;
11897 }
11898 inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
11899   ::google::protobuf::internal::TSanRead(&_impl_);
11900   const ::onnx::TypeProto* p = _impl_.elem_type_;
11901   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
11902 }
11903 inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11904   // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
11905   return _internal_elem_type();
11906 }
11907 inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* value) {
11908   ::google::protobuf::internal::TSanWrite(&_impl_);
11909   if (GetArena() == nullptr) {
11910     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
11911   }
11912   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11913   if (value != nullptr) {
11914     _impl_._has_bits_[0] |= 0x00000001u;
11915   } else {
11916     _impl_._has_bits_[0] &= ~0x00000001u;
11917   }
11918   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
11919 }
11920 inline ::onnx::TypeProto* TypeProto_Optional::release_elem_type() {
11921   ::google::protobuf::internal::TSanWrite(&_impl_);
11922
11923   _impl_._has_bits_[0] &= ~0x00000001u;
11924   ::onnx::TypeProto* released = _impl_.elem_type_;
11925   _impl_.elem_type_ = nullptr;
11926 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
11927   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11928   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11929   if (GetArena() == nullptr) {
11930     delete old;
11931   }
11932 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
11933   if (GetArena() != nullptr) {
11934     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11935   }
11936 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
11937   return released;
11938 }
11939 inline ::onnx::TypeProto* TypeProto_Optional::unsafe_arena_release_elem_type() {
11940   ::google::protobuf::internal::TSanWrite(&_impl_);
11941   // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)
11942
11943   _impl_._has_bits_[0] &= ~0x00000001u;
11944   ::onnx::TypeProto* temp = _impl_.elem_type_;
11945   _impl_.elem_type_ = nullptr;
11946   return temp;
11947 }
11948 inline ::onnx::TypeProto* TypeProto_Optional::_internal_mutable_elem_type() {
11949   ::google::protobuf::internal::TSanWrite(&_impl_);
11950   if (_impl_.elem_type_ == nullptr) {
11951     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
11952     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
11953   }
11954   return _impl_.elem_type_;
11955 }
11956 inline ::onnx::TypeProto* TypeProto_Optional::mutable_elem_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
11957   _impl_._has_bits_[0] |= 0x00000001u;
11958   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
11959   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
11960   return _msg;
11961 }
11962 inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* value) {
11963   ::google::protobuf::Arena* message_arena = GetArena();
11964   ::google::protobuf::internal::TSanWrite(&_impl_);
11965   if (message_arena == nullptr) {
11966     delete (_impl_.elem_type_);
11967   }
11968
11969   if (value != nullptr) {
11970     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
11971     if (message_arena != submessage_arena) {
11972       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11973     }
11974     _impl_._has_bits_[0] |= 0x00000001u;
11975   } else {
11976     _impl_._has_bits_[0] &= ~0x00000001u;
11977   }
11978
11979   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11980   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
11981 }
11982
11983 // -------------------------------------------------------------------
11984
11985 // TypeProto_SparseTensor
11986
11987 // optional int32 elem_type = 1;
11988 inline bool TypeProto_SparseTensor::has_elem_type() const {
11989   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
11990   return value;
11991 }
11992 inline void TypeProto_SparseTensor::clear_elem_type() {
11993   ::google::protobuf::internal::TSanWrite(&_impl_);
11994   _impl_.elem_type_ = 0;
11995   _impl_._has_bits_[0] &= ~0x00000002u;
11996 }
11997 inline ::int32_t TypeProto_SparseTensor::elem_type() const {
11998   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
11999   return _internal_elem_type();
12000 }
12001 inline void TypeProto_SparseTensor::set_elem_type(::int32_t value) {
12002   _internal_set_elem_type(value);
12003   _impl_._has_bits_[0] |= 0x00000002u;
12004   // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
12005 }
12006 inline ::int32_t TypeProto_SparseTensor::_internal_elem_type() const {
12007   ::google::protobuf::internal::TSanRead(&_impl_);
12008   return _impl_.elem_type_;
12009 }
12010 inline void TypeProto_SparseTensor::_internal_set_elem_type(::int32_t value) {
12011   ::google::protobuf::internal::TSanWrite(&_impl_);
12012   _impl_.elem_type_ = value;
12013 }
12014
12015 // optional .onnx.TensorShapeProto shape = 2;
12016 inline bool TypeProto_SparseTensor::has_shape() const {
12017   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
12018   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
12019   return value;
12020 }
12021 inline void TypeProto_SparseTensor::clear_shape() {
12022   ::google::protobuf::internal::TSanWrite(&_impl_);
12023   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
12024   _impl_._has_bits_[0] &= ~0x00000001u;
12025 }
12026 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
12027   ::google::protobuf::internal::TSanRead(&_impl_);
12028   const ::onnx::TensorShapeProto* p = _impl_.shape_;
12029   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
12030 }
12031 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12032   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
12033   return _internal_shape();
12034 }
12035 inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* value) {
12036   ::google::protobuf::internal::TSanWrite(&_impl_);
12037   if (GetArena() == nullptr) {
12038     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
12039   }
12040   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
12041   if (value != nullptr) {
12042     _impl_._has_bits_[0] |= 0x00000001u;
12043   } else {
12044     _impl_._has_bits_[0] &= ~0x00000001u;
12045   }
12046   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
12047 }
12048 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
12049   ::google::protobuf::internal::TSanWrite(&_impl_);
12050
12051   _impl_._has_bits_[0] &= ~0x00000001u;
12052   ::onnx::TensorShapeProto* released = _impl_.shape_;
12053   _impl_.shape_ = nullptr;
12054 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
12055   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
12056   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12057   if (GetArena() == nullptr) {
12058     delete old;
12059   }
12060 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
12061   if (GetArena() != nullptr) {
12062     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12063   }
12064 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
12065   return released;
12066 }
12067 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::unsafe_arena_release_shape() {
12068   ::google::protobuf::internal::TSanWrite(&_impl_);
12069   // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)
12070
12071   _impl_._has_bits_[0] &= ~0x00000001u;
12072   ::onnx::TensorShapeProto* temp = _impl_.shape_;
12073   _impl_.shape_ = nullptr;
12074   return temp;
12075 }
12076 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::_internal_mutable_shape() {
12077   ::google::protobuf::internal::TSanWrite(&_impl_);
12078   if (_impl_.shape_ == nullptr) {
12079     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
12080     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
12081   }
12082   return _impl_.shape_;
12083 }
12084 inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12085   _impl_._has_bits_[0] |= 0x00000001u;
12086   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
12087   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
12088   return _msg;
12089 }
12090 inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* value) {
12091   ::google::protobuf::Arena* message_arena = GetArena();
12092   ::google::protobuf::internal::TSanWrite(&_impl_);
12093   if (message_arena == nullptr) {
12094     delete (_impl_.shape_);
12095   }
12096
12097   if (value != nullptr) {
12098     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
12099     if (message_arena != submessage_arena) {
12100       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
12101     }
12102     _impl_._has_bits_[0] |= 0x00000001u;
12103   } else {
12104     _impl_._has_bits_[0] &= ~0x00000001u;
12105   }
12106
12107   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
12108   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
12109 }
12110
12111 // -------------------------------------------------------------------
12112
12113 // TypeProto_Opaque
12114
12115 // optional string domain = 1;
12116 inline bool TypeProto_Opaque::has_domain() const {
12117   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
12118   return value;
12119 }
12120 inline void TypeProto_Opaque::clear_domain() {
12121   ::google::protobuf::internal::TSanWrite(&_impl_);
12122   _impl_.domain_.ClearToEmpty();
12123   _impl_._has_bits_[0] &= ~0x00000001u;
12124 }
12125 inline const std::string& TypeProto_Opaque::domain() const
12126     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12127   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.domain)
12128   return _internal_domain();
12129 }
12130 template <typename Arg_, typename... Args_>
12131 inline PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_domain(Arg_&& arg,
12132                                                      Args_... args) {
12133   ::google::protobuf::internal::TSanWrite(&_impl_);
12134   _impl_._has_bits_[0] |= 0x00000001u;
12135   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12136   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.domain)
12137 }
12138 inline std::string* TypeProto_Opaque::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12139   std::string* _s = _internal_mutable_domain();
12140   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.domain)
12141   return _s;
12142 }
12143 inline const std::string& TypeProto_Opaque::_internal_domain() const {
12144   ::google::protobuf::internal::TSanRead(&_impl_);
12145   return _impl_.domain_.Get();
12146 }
12147 inline void TypeProto_Opaque::_internal_set_domain(const std::string& value) {
12148   ::google::protobuf::internal::TSanWrite(&_impl_);
12149   _impl_._has_bits_[0] |= 0x00000001u;
12150   _impl_.domain_.Set(value, GetArena());
12151 }
12152 inline std::string* TypeProto_Opaque::_internal_mutable_domain() {
12153   ::google::protobuf::internal::TSanWrite(&_impl_);
12154   _impl_._has_bits_[0] |= 0x00000001u;
12155   return _impl_.domain_.Mutable( GetArena());
12156 }
12157 inline std::string* TypeProto_Opaque::release_domain() {
12158   ::google::protobuf::internal::TSanWrite(&_impl_);
12159   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.domain)
12160   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
12161     return nullptr;
12162   }
12163   _impl_._has_bits_[0] &= ~0x00000001u;
12164   auto* released = _impl_.domain_.Release();
12165   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12166   _impl_.domain_.Set("", GetArena());
12167   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12168   return released;
12169 }
12170 inline void TypeProto_Opaque::set_allocated_domain(std::string* value) {
12171   ::google::protobuf::internal::TSanWrite(&_impl_);
12172   if (value != nullptr) {
12173     _impl_._has_bits_[0] |= 0x00000001u;
12174   } else {
12175     _impl_._has_bits_[0] &= ~0x00000001u;
12176   }
12177   _impl_.domain_.SetAllocated(value, GetArena());
12178   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12179         if (_impl_.domain_.IsDefault()) {
12180           _impl_.domain_.Set("", GetArena());
12181         }
12182   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12183   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.domain)
12184 }
12185
12186 // optional string name = 2;
12187 inline bool TypeProto_Opaque::has_name() const {
12188   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
12189   return value;
12190 }
12191 inline void TypeProto_Opaque::clear_name() {
12192   ::google::protobuf::internal::TSanWrite(&_impl_);
12193   _impl_.name_.ClearToEmpty();
12194   _impl_._has_bits_[0] &= ~0x00000002u;
12195 }
12196 inline const std::string& TypeProto_Opaque::name() const
12197     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12198   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.name)
12199   return _internal_name();
12200 }
12201 template <typename Arg_, typename... Args_>
12202 inline PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_name(Arg_&& arg,
12203                                                      Args_... args) {
12204   ::google::protobuf::internal::TSanWrite(&_impl_);
12205   _impl_._has_bits_[0] |= 0x00000002u;
12206   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12207   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.name)
12208 }
12209 inline std::string* TypeProto_Opaque::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12210   std::string* _s = _internal_mutable_name();
12211   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.name)
12212   return _s;
12213 }
12214 inline const std::string& TypeProto_Opaque::_internal_name() const {
12215   ::google::protobuf::internal::TSanRead(&_impl_);
12216   return _impl_.name_.Get();
12217 }
12218 inline void TypeProto_Opaque::_internal_set_name(const std::string& value) {
12219   ::google::protobuf::internal::TSanWrite(&_impl_);
12220   _impl_._has_bits_[0] |= 0x00000002u;
12221   _impl_.name_.Set(value, GetArena());
12222 }
12223 inline std::string* TypeProto_Opaque::_internal_mutable_name() {
12224   ::google::protobuf::internal::TSanWrite(&_impl_);
12225   _impl_._has_bits_[0] |= 0x00000002u;
12226   return _impl_.name_.Mutable( GetArena());
12227 }
12228 inline std::string* TypeProto_Opaque::release_name() {
12229   ::google::protobuf::internal::TSanWrite(&_impl_);
12230   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.name)
12231   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
12232     return nullptr;
12233   }
12234   _impl_._has_bits_[0] &= ~0x00000002u;
12235   auto* released = _impl_.name_.Release();
12236   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12237   _impl_.name_.Set("", GetArena());
12238   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12239   return released;
12240 }
12241 inline void TypeProto_Opaque::set_allocated_name(std::string* value) {
12242   ::google::protobuf::internal::TSanWrite(&_impl_);
12243   if (value != nullptr) {
12244     _impl_._has_bits_[0] |= 0x00000002u;
12245   } else {
12246     _impl_._has_bits_[0] &= ~0x00000002u;
12247   }
12248   _impl_.name_.SetAllocated(value, GetArena());
12249   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12250         if (_impl_.name_.IsDefault()) {
12251           _impl_.name_.Set("", GetArena());
12252         }
12253   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12254   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.name)
12255 }
12256
12257 // -------------------------------------------------------------------
12258
12259 // TypeProto
12260
12261 // .onnx.TypeProto.Tensor tensor_type = 1;
12262 inline bool TypeProto::has_tensor_type() const {
12263   return value_case() == kTensorType;
12264 }
12265 inline bool TypeProto::_internal_has_tensor_type() const {
12266   return value_case() == kTensorType;
12267 }
12268 inline void TypeProto::set_has_tensor_type() {
12269   _impl_._oneof_case_[0] = kTensorType;
12270 }
12271 inline void TypeProto::clear_tensor_type() {
12272   ::google::protobuf::internal::TSanWrite(&_impl_);
12273   if (value_case() == kTensorType) {
12274     if (GetArena() == nullptr) {
12275       delete _impl_.value_.tensor_type_;
12276     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12277       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.tensor_type_);
12278     }
12279     clear_has_value();
12280   }
12281 }
12282 inline ::onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
12283   // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
12284   if (value_case() == kTensorType) {
12285     clear_has_value();
12286     auto* temp = _impl_.value_.tensor_type_;
12287     if (GetArena() != nullptr) {
12288       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12289     }
12290     _impl_.value_.tensor_type_ = nullptr;
12291     return temp;
12292   } else {
12293     return nullptr;
12294   }
12295 }
12296 inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
12297   return value_case() == kTensorType ? *_impl_.value_.tensor_type_ : reinterpret_cast<::onnx::TypeProto_Tensor&>(::onnx::_TypeProto_Tensor_default_instance_);
12298 }
12299 inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12300   // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
12301   return _internal_tensor_type();
12302 }
12303 inline ::onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
12304   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
12305   if (value_case() == kTensorType) {
12306     clear_has_value();
12307     auto* temp = _impl_.value_.tensor_type_;
12308     _impl_.value_.tensor_type_ = nullptr;
12309     return temp;
12310   } else {
12311     return nullptr;
12312   }
12313 }
12314 inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* value) {
12315   // We rely on the oneof clear method to free the earlier contents
12316   // of this oneof. We can directly use the pointer we're given to
12317   // set the new value.
12318   clear_value();
12319   if (value) {
12320     set_has_tensor_type();
12321     _impl_.value_.tensor_type_ = value;
12322   }
12323   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
12324 }
12325 inline ::onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
12326   if (value_case() != kTensorType) {
12327     clear_value();
12328     set_has_tensor_type();
12329     _impl_.value_.tensor_type_ =
12330         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Tensor>(GetArena());
12331   }
12332   return _impl_.value_.tensor_type_;
12333 }
12334 inline ::onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12335   ::onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
12336   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
12337   return _msg;
12338 }
12339
12340 // .onnx.TypeProto.Sequence sequence_type = 4;
12341 inline bool TypeProto::has_sequence_type() const {
12342   return value_case() == kSequenceType;
12343 }
12344 inline bool TypeProto::_internal_has_sequence_type() const {
12345   return value_case() == kSequenceType;
12346 }
12347 inline void TypeProto::set_has_sequence_type() {
12348   _impl_._oneof_case_[0] = kSequenceType;
12349 }
12350 inline void TypeProto::clear_sequence_type() {
12351   ::google::protobuf::internal::TSanWrite(&_impl_);
12352   if (value_case() == kSequenceType) {
12353     if (GetArena() == nullptr) {
12354       delete _impl_.value_.sequence_type_;
12355     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12356       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sequence_type_);
12357     }
12358     clear_has_value();
12359   }
12360 }
12361 inline ::onnx::TypeProto_Sequence* TypeProto::release_sequence_type() {
12362   // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
12363   if (value_case() == kSequenceType) {
12364     clear_has_value();
12365     auto* temp = _impl_.value_.sequence_type_;
12366     if (GetArena() != nullptr) {
12367       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12368     }
12369     _impl_.value_.sequence_type_ = nullptr;
12370     return temp;
12371   } else {
12372     return nullptr;
12373   }
12374 }
12375 inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
12376   return value_case() == kSequenceType ? *_impl_.value_.sequence_type_ : reinterpret_cast<::onnx::TypeProto_Sequence&>(::onnx::_TypeProto_Sequence_default_instance_);
12377 }
12378 inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12379   // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
12380   return _internal_sequence_type();
12381 }
12382 inline ::onnx::TypeProto_Sequence* TypeProto::unsafe_arena_release_sequence_type() {
12383   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
12384   if (value_case() == kSequenceType) {
12385     clear_has_value();
12386     auto* temp = _impl_.value_.sequence_type_;
12387     _impl_.value_.sequence_type_ = nullptr;
12388     return temp;
12389   } else {
12390     return nullptr;
12391   }
12392 }
12393 inline void TypeProto::unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* value) {
12394   // We rely on the oneof clear method to free the earlier contents
12395   // of this oneof. We can directly use the pointer we're given to
12396   // set the new value.
12397   clear_value();
12398   if (value) {
12399     set_has_sequence_type();
12400     _impl_.value_.sequence_type_ = value;
12401   }
12402   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
12403 }
12404 inline ::onnx::TypeProto_Sequence* TypeProto::_internal_mutable_sequence_type() {
12405   if (value_case() != kSequenceType) {
12406     clear_value();
12407     set_has_sequence_type();
12408     _impl_.value_.sequence_type_ =
12409         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Sequence>(GetArena());
12410   }
12411   return _impl_.value_.sequence_type_;
12412 }
12413 inline ::onnx::TypeProto_Sequence* TypeProto::mutable_sequence_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12414   ::onnx::TypeProto_Sequence* _msg = _internal_mutable_sequence_type();
12415   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
12416   return _msg;
12417 }
12418
12419 // .onnx.TypeProto.Map map_type = 5;
12420 inline bool TypeProto::has_map_type() const {
12421   return value_case() == kMapType;
12422 }
12423 inline bool TypeProto::_internal_has_map_type() const {
12424   return value_case() == kMapType;
12425 }
12426 inline void TypeProto::set_has_map_type() {
12427   _impl_._oneof_case_[0] = kMapType;
12428 }
12429 inline void TypeProto::clear_map_type() {
12430   ::google::protobuf::internal::TSanWrite(&_impl_);
12431   if (value_case() == kMapType) {
12432     if (GetArena() == nullptr) {
12433       delete _impl_.value_.map_type_;
12434     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12435       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.map_type_);
12436     }
12437     clear_has_value();
12438   }
12439 }
12440 inline ::onnx::TypeProto_Map* TypeProto::release_map_type() {
12441   // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
12442   if (value_case() == kMapType) {
12443     clear_has_value();
12444     auto* temp = _impl_.value_.map_type_;
12445     if (GetArena() != nullptr) {
12446       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12447     }
12448     _impl_.value_.map_type_ = nullptr;
12449     return temp;
12450   } else {
12451     return nullptr;
12452   }
12453 }
12454 inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
12455   return value_case() == kMapType ? *_impl_.value_.map_type_ : reinterpret_cast<::onnx::TypeProto_Map&>(::onnx::_TypeProto_Map_default_instance_);
12456 }
12457 inline const ::onnx::TypeProto_Map& TypeProto::map_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12458   // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
12459   return _internal_map_type();
12460 }
12461 inline ::onnx::TypeProto_Map* TypeProto::unsafe_arena_release_map_type() {
12462   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
12463   if (value_case() == kMapType) {
12464     clear_has_value();
12465     auto* temp = _impl_.value_.map_type_;
12466     _impl_.value_.map_type_ = nullptr;
12467     return temp;
12468   } else {
12469     return nullptr;
12470   }
12471 }
12472 inline void TypeProto::unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* value) {
12473   // We rely on the oneof clear method to free the earlier contents
12474   // of this oneof. We can directly use the pointer we're given to
12475   // set the new value.
12476   clear_value();
12477   if (value) {
12478     set_has_map_type();
12479     _impl_.value_.map_type_ = value;
12480   }
12481   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
12482 }
12483 inline ::onnx::TypeProto_Map* TypeProto::_internal_mutable_map_type() {
12484   if (value_case() != kMapType) {
12485     clear_value();
12486     set_has_map_type();
12487     _impl_.value_.map_type_ =
12488         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Map>(GetArena());
12489   }
12490   return _impl_.value_.map_type_;
12491 }
12492 inline ::onnx::TypeProto_Map* TypeProto::mutable_map_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12493   ::onnx::TypeProto_Map* _msg = _internal_mutable_map_type();
12494   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
12495   return _msg;
12496 }
12497
12498 // .onnx.TypeProto.Optional optional_type = 9;
12499 inline bool TypeProto::has_optional_type() const {
12500   return value_case() == kOptionalType;
12501 }
12502 inline bool TypeProto::_internal_has_optional_type() const {
12503   return value_case() == kOptionalType;
12504 }
12505 inline void TypeProto::set_has_optional_type() {
12506   _impl_._oneof_case_[0] = kOptionalType;
12507 }
12508 inline void TypeProto::clear_optional_type() {
12509   ::google::protobuf::internal::TSanWrite(&_impl_);
12510   if (value_case() == kOptionalType) {
12511     if (GetArena() == nullptr) {
12512       delete _impl_.value_.optional_type_;
12513     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12514       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.optional_type_);
12515     }
12516     clear_has_value();
12517   }
12518 }
12519 inline ::onnx::TypeProto_Optional* TypeProto::release_optional_type() {
12520   // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
12521   if (value_case() == kOptionalType) {
12522     clear_has_value();
12523     auto* temp = _impl_.value_.optional_type_;
12524     if (GetArena() != nullptr) {
12525       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12526     }
12527     _impl_.value_.optional_type_ = nullptr;
12528     return temp;
12529   } else {
12530     return nullptr;
12531   }
12532 }
12533 inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
12534   return value_case() == kOptionalType ? *_impl_.value_.optional_type_ : reinterpret_cast<::onnx::TypeProto_Optional&>(::onnx::_TypeProto_Optional_default_instance_);
12535 }
12536 inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12537   // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
12538   return _internal_optional_type();
12539 }
12540 inline ::onnx::TypeProto_Optional* TypeProto::unsafe_arena_release_optional_type() {
12541   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
12542   if (value_case() == kOptionalType) {
12543     clear_has_value();
12544     auto* temp = _impl_.value_.optional_type_;
12545     _impl_.value_.optional_type_ = nullptr;
12546     return temp;
12547   } else {
12548     return nullptr;
12549   }
12550 }
12551 inline void TypeProto::unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* value) {
12552   // We rely on the oneof clear method to free the earlier contents
12553   // of this oneof. We can directly use the pointer we're given to
12554   // set the new value.
12555   clear_value();
12556   if (value) {
12557     set_has_optional_type();
12558     _impl_.value_.optional_type_ = value;
12559   }
12560   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
12561 }
12562 inline ::onnx::TypeProto_Optional* TypeProto::_internal_mutable_optional_type() {
12563   if (value_case() != kOptionalType) {
12564     clear_value();
12565     set_has_optional_type();
12566     _impl_.value_.optional_type_ =
12567         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Optional>(GetArena());
12568   }
12569   return _impl_.value_.optional_type_;
12570 }
12571 inline ::onnx::TypeProto_Optional* TypeProto::mutable_optional_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12572   ::onnx::TypeProto_Optional* _msg = _internal_mutable_optional_type();
12573   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
12574   return _msg;
12575 }
12576
12577 // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
12578 inline bool TypeProto::has_sparse_tensor_type() const {
12579   return value_case() == kSparseTensorType;
12580 }
12581 inline bool TypeProto::_internal_has_sparse_tensor_type() const {
12582   return value_case() == kSparseTensorType;
12583 }
12584 inline void TypeProto::set_has_sparse_tensor_type() {
12585   _impl_._oneof_case_[0] = kSparseTensorType;
12586 }
12587 inline void TypeProto::clear_sparse_tensor_type() {
12588   ::google::protobuf::internal::TSanWrite(&_impl_);
12589   if (value_case() == kSparseTensorType) {
12590     if (GetArena() == nullptr) {
12591       delete _impl_.value_.sparse_tensor_type_;
12592     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12593       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sparse_tensor_type_);
12594     }
12595     clear_has_value();
12596   }
12597 }
12598 inline ::onnx::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
12599   // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
12600   if (value_case() == kSparseTensorType) {
12601     clear_has_value();
12602     auto* temp = _impl_.value_.sparse_tensor_type_;
12603     if (GetArena() != nullptr) {
12604       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12605     }
12606     _impl_.value_.sparse_tensor_type_ = nullptr;
12607     return temp;
12608   } else {
12609     return nullptr;
12610   }
12611 }
12612 inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
12613   return value_case() == kSparseTensorType ? *_impl_.value_.sparse_tensor_type_ : reinterpret_cast<::onnx::TypeProto_SparseTensor&>(::onnx::_TypeProto_SparseTensor_default_instance_);
12614 }
12615 inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12616   // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
12617   return _internal_sparse_tensor_type();
12618 }
12619 inline ::onnx::TypeProto_SparseTensor* TypeProto::unsafe_arena_release_sparse_tensor_type() {
12620   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
12621   if (value_case() == kSparseTensorType) {
12622     clear_has_value();
12623     auto* temp = _impl_.value_.sparse_tensor_type_;
12624     _impl_.value_.sparse_tensor_type_ = nullptr;
12625     return temp;
12626   } else {
12627     return nullptr;
12628   }
12629 }
12630 inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* value) {
12631   // We rely on the oneof clear method to free the earlier contents
12632   // of this oneof. We can directly use the pointer we're given to
12633   // set the new value.
12634   clear_value();
12635   if (value) {
12636     set_has_sparse_tensor_type();
12637     _impl_.value_.sparse_tensor_type_ = value;
12638   }
12639   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
12640 }
12641 inline ::onnx::TypeProto_SparseTensor* TypeProto::_internal_mutable_sparse_tensor_type() {
12642   if (value_case() != kSparseTensorType) {
12643     clear_value();
12644     set_has_sparse_tensor_type();
12645     _impl_.value_.sparse_tensor_type_ =
12646         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_SparseTensor>(GetArena());
12647   }
12648   return _impl_.value_.sparse_tensor_type_;
12649 }
12650 inline ::onnx::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12651   ::onnx::TypeProto_SparseTensor* _msg = _internal_mutable_sparse_tensor_type();
12652   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
12653   return _msg;
12654 }
12655
12656 // .onnx.TypeProto.Opaque opaque_type = 7;
12657 inline bool TypeProto::has_opaque_type() const {
12658   return value_case() == kOpaqueType;
12659 }
12660 inline bool TypeProto::_internal_has_opaque_type() const {
12661   return value_case() == kOpaqueType;
12662 }
12663 inline void TypeProto::set_has_opaque_type() {
12664   _impl_._oneof_case_[0] = kOpaqueType;
12665 }
12666 inline void TypeProto::clear_opaque_type() {
12667   ::google::protobuf::internal::TSanWrite(&_impl_);
12668   if (value_case() == kOpaqueType) {
12669     if (GetArena() == nullptr) {
12670       delete _impl_.value_.opaque_type_;
12671     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12672       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.opaque_type_);
12673     }
12674     clear_has_value();
12675   }
12676 }
12677 inline ::onnx::TypeProto_Opaque* TypeProto::release_opaque_type() {
12678   // @@protoc_insertion_point(field_release:onnx.TypeProto.opaque_type)
12679   if (value_case() == kOpaqueType) {
12680     clear_has_value();
12681     auto* temp = _impl_.value_.opaque_type_;
12682     if (GetArena() != nullptr) {
12683       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12684     }
12685     _impl_.value_.opaque_type_ = nullptr;
12686     return temp;
12687   } else {
12688     return nullptr;
12689   }
12690 }
12691 inline const ::onnx::TypeProto_Opaque& TypeProto::_internal_opaque_type() const {
12692   return value_case() == kOpaqueType ? *_impl_.value_.opaque_type_ : reinterpret_cast<::onnx::TypeProto_Opaque&>(::onnx::_TypeProto_Opaque_default_instance_);
12693 }
12694 inline const ::onnx::TypeProto_Opaque& TypeProto::opaque_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12695   // @@protoc_insertion_point(field_get:onnx.TypeProto.opaque_type)
12696   return _internal_opaque_type();
12697 }
12698 inline ::onnx::TypeProto_Opaque* TypeProto::unsafe_arena_release_opaque_type() {
12699   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.opaque_type)
12700   if (value_case() == kOpaqueType) {
12701     clear_has_value();
12702     auto* temp = _impl_.value_.opaque_type_;
12703     _impl_.value_.opaque_type_ = nullptr;
12704     return temp;
12705   } else {
12706     return nullptr;
12707   }
12708 }
12709 inline void TypeProto::unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* value) {
12710   // We rely on the oneof clear method to free the earlier contents
12711   // of this oneof. We can directly use the pointer we're given to
12712   // set the new value.
12713   clear_value();
12714   if (value) {
12715     set_has_opaque_type();
12716     _impl_.value_.opaque_type_ = value;
12717   }
12718   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.opaque_type)
12719 }
12720 inline ::onnx::TypeProto_Opaque* TypeProto::_internal_mutable_opaque_type() {
12721   if (value_case() != kOpaqueType) {
12722     clear_value();
12723     set_has_opaque_type();
12724     _impl_.value_.opaque_type_ =
12725         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Opaque>(GetArena());
12726   }
12727   return _impl_.value_.opaque_type_;
12728 }
12729 inline ::onnx::TypeProto_Opaque* TypeProto::mutable_opaque_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12730   ::onnx::TypeProto_Opaque* _msg = _internal_mutable_opaque_type();
12731   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.opaque_type)
12732   return _msg;
12733 }
12734
12735 // optional string denotation = 6;
12736 inline bool TypeProto::has_denotation() const {
12737   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
12738   return value;
12739 }
12740 inline void TypeProto::clear_denotation() {
12741   ::google::protobuf::internal::TSanWrite(&_impl_);
12742   _impl_.denotation_.ClearToEmpty();
12743   _impl_._has_bits_[0] &= ~0x00000001u;
12744 }
12745 inline const std::string& TypeProto::denotation() const
12746     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12747   // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
12748   return _internal_denotation();
12749 }
12750 template <typename Arg_, typename... Args_>
12751 inline PROTOBUF_ALWAYS_INLINE void TypeProto::set_denotation(Arg_&& arg,
12752                                                      Args_... args) {
12753   ::google::protobuf::internal::TSanWrite(&_impl_);
12754   _impl_._has_bits_[0] |= 0x00000001u;
12755   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12756   // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
12757 }
12758 inline std::string* TypeProto::mutable_denotation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12759   std::string* _s = _internal_mutable_denotation();
12760   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
12761   return _s;
12762 }
12763 inline const std::string& TypeProto::_internal_denotation() const {
12764   ::google::protobuf::internal::TSanRead(&_impl_);
12765   return _impl_.denotation_.Get();
12766 }
12767 inline void TypeProto::_internal_set_denotation(const std::string& value) {
12768   ::google::protobuf::internal::TSanWrite(&_impl_);
12769   _impl_._has_bits_[0] |= 0x00000001u;
12770   _impl_.denotation_.Set(value, GetArena());
12771 }
12772 inline std::string* TypeProto::_internal_mutable_denotation() {
12773   ::google::protobuf::internal::TSanWrite(&_impl_);
12774   _impl_._has_bits_[0] |= 0x00000001u;
12775   return _impl_.denotation_.Mutable( GetArena());
12776 }
12777 inline std::string* TypeProto::release_denotation() {
12778   ::google::protobuf::internal::TSanWrite(&_impl_);
12779   // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
12780   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
12781     return nullptr;
12782   }
12783   _impl_._has_bits_[0] &= ~0x00000001u;
12784   auto* released = _impl_.denotation_.Release();
12785   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12786   _impl_.denotation_.Set("", GetArena());
12787   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12788   return released;
12789 }
12790 inline void TypeProto::set_allocated_denotation(std::string* value) {
12791   ::google::protobuf::internal::TSanWrite(&_impl_);
12792   if (value != nullptr) {
12793     _impl_._has_bits_[0] |= 0x00000001u;
12794   } else {
12795     _impl_._has_bits_[0] &= ~0x00000001u;
12796   }
12797   _impl_.denotation_.SetAllocated(value, GetArena());
12798   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12799         if (_impl_.denotation_.IsDefault()) {
12800           _impl_.denotation_.Set("", GetArena());
12801         }
12802   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12803   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
12804 }
12805
12806 inline bool TypeProto::has_value() const {
12807   return value_case() != VALUE_NOT_SET;
12808 }
12809 inline void TypeProto::clear_has_value() {
12810   _impl_._oneof_case_[0] = VALUE_NOT_SET;
12811 }
12812 inline TypeProto::ValueCase TypeProto::value_case() const {
12813   return TypeProto::ValueCase(_impl_._oneof_case_[0]);
12814 }
12815 // -------------------------------------------------------------------
12816
12817 // OperatorSetIdProto
12818
12819 // optional string domain = 1;
12820 inline bool OperatorSetIdProto::has_domain() const {
12821   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
12822   return value;
12823 }
12824 inline void OperatorSetIdProto::clear_domain() {
12825   ::google::protobuf::internal::TSanWrite(&_impl_);
12826   _impl_.domain_.ClearToEmpty();
12827   _impl_._has_bits_[0] &= ~0x00000001u;
12828 }
12829 inline const std::string& OperatorSetIdProto::domain() const
12830     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12831   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
12832   return _internal_domain();
12833 }
12834 template <typename Arg_, typename... Args_>
12835 inline PROTOBUF_ALWAYS_INLINE void OperatorSetIdProto::set_domain(Arg_&& arg,
12836                                                      Args_... args) {
12837   ::google::protobuf::internal::TSanWrite(&_impl_);
12838   _impl_._has_bits_[0] |= 0x00000001u;
12839   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12840   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
12841 }
12842 inline std::string* OperatorSetIdProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12843   std::string* _s = _internal_mutable_domain();
12844   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
12845   return _s;
12846 }
12847 inline const std::string& OperatorSetIdProto::_internal_domain() const {
12848   ::google::protobuf::internal::TSanRead(&_impl_);
12849   return _impl_.domain_.Get();
12850 }
12851 inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
12852   ::google::protobuf::internal::TSanWrite(&_impl_);
12853   _impl_._has_bits_[0] |= 0x00000001u;
12854   _impl_.domain_.Set(value, GetArena());
12855 }
12856 inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
12857   ::google::protobuf::internal::TSanWrite(&_impl_);
12858   _impl_._has_bits_[0] |= 0x00000001u;
12859   return _impl_.domain_.Mutable( GetArena());
12860 }
12861 inline std::string* OperatorSetIdProto::release_domain() {
12862   ::google::protobuf::internal::TSanWrite(&_impl_);
12863   // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
12864   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
12865     return nullptr;
12866   }
12867   _impl_._has_bits_[0] &= ~0x00000001u;
12868   auto* released = _impl_.domain_.Release();
12869   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12870   _impl_.domain_.Set("", GetArena());
12871   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12872   return released;
12873 }
12874 inline void OperatorSetIdProto::set_allocated_domain(std::string* value) {
12875   ::google::protobuf::internal::TSanWrite(&_impl_);
12876   if (value != nullptr) {
12877     _impl_._has_bits_[0] |= 0x00000001u;
12878   } else {
12879     _impl_._has_bits_[0] &= ~0x00000001u;
12880   }
12881   _impl_.domain_.SetAllocated(value, GetArena());
12882   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12883         if (_impl_.domain_.IsDefault()) {
12884           _impl_.domain_.Set("", GetArena());
12885         }
12886   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12887   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
12888 }
12889
12890 // optional int64 version = 2;
12891 inline bool OperatorSetIdProto::has_version() const {
12892   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
12893   return value;
12894 }
12895 inline void OperatorSetIdProto::clear_version() {
12896   ::google::protobuf::internal::TSanWrite(&_impl_);
12897   _impl_.version_ = ::int64_t{0};
12898   _impl_._has_bits_[0] &= ~0x00000002u;
12899 }
12900 inline ::int64_t OperatorSetIdProto::version() const {
12901   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
12902   return _internal_version();
12903 }
12904 inline void OperatorSetIdProto::set_version(::int64_t value) {
12905   _internal_set_version(value);
12906   _impl_._has_bits_[0] |= 0x00000002u;
12907   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
12908 }
12909 inline ::int64_t OperatorSetIdProto::_internal_version() const {
12910   ::google::protobuf::internal::TSanRead(&_impl_);
12911   return _impl_.version_;
12912 }
12913 inline void OperatorSetIdProto::_internal_set_version(::int64_t value) {
12914   ::google::protobuf::internal::TSanWrite(&_impl_);
12915   _impl_.version_ = value;
12916 }
12917
12918 // -------------------------------------------------------------------
12919
12920 // FunctionProto
12921
12922 // optional string name = 1;
12923 inline bool FunctionProto::has_name() const {
12924   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
12925   return value;
12926 }
12927 inline void FunctionProto::clear_name() {
12928   ::google::protobuf::internal::TSanWrite(&_impl_);
12929   _impl_.name_.ClearToEmpty();
12930   _impl_._has_bits_[0] &= ~0x00000001u;
12931 }
12932 inline const std::string& FunctionProto::name() const
12933     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12934   // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
12935   return _internal_name();
12936 }
12937 template <typename Arg_, typename... Args_>
12938 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_name(Arg_&& arg,
12939                                                      Args_... args) {
12940   ::google::protobuf::internal::TSanWrite(&_impl_);
12941   _impl_._has_bits_[0] |= 0x00000001u;
12942   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12943   // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
12944 }
12945 inline std::string* FunctionProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
12946   std::string* _s = _internal_mutable_name();
12947   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
12948   return _s;
12949 }
12950 inline const std::string& FunctionProto::_internal_name() const {
12951   ::google::protobuf::internal::TSanRead(&_impl_);
12952   return _impl_.name_.Get();
12953 }
12954 inline void FunctionProto::_internal_set_name(const std::string& value) {
12955   ::google::protobuf::internal::TSanWrite(&_impl_);
12956   _impl_._has_bits_[0] |= 0x00000001u;
12957   _impl_.name_.Set(value, GetArena());
12958 }
12959 inline std::string* FunctionProto::_internal_mutable_name() {
12960   ::google::protobuf::internal::TSanWrite(&_impl_);
12961   _impl_._has_bits_[0] |= 0x00000001u;
12962   return _impl_.name_.Mutable( GetArena());
12963 }
12964 inline std::string* FunctionProto::release_name() {
12965   ::google::protobuf::internal::TSanWrite(&_impl_);
12966   // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
12967   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
12968     return nullptr;
12969   }
12970   _impl_._has_bits_[0] &= ~0x00000001u;
12971   auto* released = _impl_.name_.Release();
12972   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12973   _impl_.name_.Set("", GetArena());
12974   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12975   return released;
12976 }
12977 inline void FunctionProto::set_allocated_name(std::string* value) {
12978   ::google::protobuf::internal::TSanWrite(&_impl_);
12979   if (value != nullptr) {
12980     _impl_._has_bits_[0] |= 0x00000001u;
12981   } else {
12982     _impl_._has_bits_[0] &= ~0x00000001u;
12983   }
12984   _impl_.name_.SetAllocated(value, GetArena());
12985   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
12986         if (_impl_.name_.IsDefault()) {
12987           _impl_.name_.Set("", GetArena());
12988         }
12989   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
12990   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
12991 }
12992
12993 // repeated string input = 4;
12994 inline int FunctionProto::_internal_input_size() const {
12995   return _internal_input().size();
12996 }
12997 inline int FunctionProto::input_size() const {
12998   return _internal_input_size();
12999 }
13000 inline void FunctionProto::clear_input() {
13001   ::google::protobuf::internal::TSanWrite(&_impl_);
13002   _impl_.input_.Clear();
13003 }
13004 inline std::string* FunctionProto::add_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13005   ::google::protobuf::internal::TSanWrite(&_impl_);
13006   std::string* _s = _internal_mutable_input()->Add();
13007   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
13008   return _s;
13009 }
13010 inline const std::string& FunctionProto::input(int index) const
13011     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13012   // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
13013   return _internal_input().Get(index);
13014 }
13015 inline std::string* FunctionProto::mutable_input(int index)
13016     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13017   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
13018   return _internal_mutable_input()->Mutable(index);
13019 }
13020 template <typename Arg_, typename... Args_>
13021 inline void FunctionProto::set_input(int index, Arg_&& value, Args_... args) {
13022   ::google::protobuf::internal::AssignToString(
13023       *_internal_mutable_input()->Mutable(index),
13024       std::forward<Arg_>(value), args... );
13025   // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
13026 }
13027 template <typename Arg_, typename... Args_>
13028 inline void FunctionProto::add_input(Arg_&& value, Args_... args) {
13029   ::google::protobuf::internal::TSanWrite(&_impl_);
13030   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
13031                                std::forward<Arg_>(value),
13032                                args... );
13033   // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
13034 }
13035 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13036 FunctionProto::input() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13037   // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
13038   return _internal_input();
13039 }
13040 inline ::google::protobuf::RepeatedPtrField<std::string>*
13041 FunctionProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13042   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
13043   ::google::protobuf::internal::TSanWrite(&_impl_);
13044   return _internal_mutable_input();
13045 }
13046 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13047 FunctionProto::_internal_input() const {
13048   ::google::protobuf::internal::TSanRead(&_impl_);
13049   return _impl_.input_;
13050 }
13051 inline ::google::protobuf::RepeatedPtrField<std::string>*
13052 FunctionProto::_internal_mutable_input() {
13053   ::google::protobuf::internal::TSanRead(&_impl_);
13054   return &_impl_.input_;
13055 }
13056
13057 // repeated string output = 5;
13058 inline int FunctionProto::_internal_output_size() const {
13059   return _internal_output().size();
13060 }
13061 inline int FunctionProto::output_size() const {
13062   return _internal_output_size();
13063 }
13064 inline void FunctionProto::clear_output() {
13065   ::google::protobuf::internal::TSanWrite(&_impl_);
13066   _impl_.output_.Clear();
13067 }
13068 inline std::string* FunctionProto::add_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13069   ::google::protobuf::internal::TSanWrite(&_impl_);
13070   std::string* _s = _internal_mutable_output()->Add();
13071   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
13072   return _s;
13073 }
13074 inline const std::string& FunctionProto::output(int index) const
13075     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13076   // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
13077   return _internal_output().Get(index);
13078 }
13079 inline std::string* FunctionProto::mutable_output(int index)
13080     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13081   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
13082   return _internal_mutable_output()->Mutable(index);
13083 }
13084 template <typename Arg_, typename... Args_>
13085 inline void FunctionProto::set_output(int index, Arg_&& value, Args_... args) {
13086   ::google::protobuf::internal::AssignToString(
13087       *_internal_mutable_output()->Mutable(index),
13088       std::forward<Arg_>(value), args... );
13089   // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
13090 }
13091 template <typename Arg_, typename... Args_>
13092 inline void FunctionProto::add_output(Arg_&& value, Args_... args) {
13093   ::google::protobuf::internal::TSanWrite(&_impl_);
13094   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
13095                                std::forward<Arg_>(value),
13096                                args... );
13097   // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
13098 }
13099 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13100 FunctionProto::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13101   // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
13102   return _internal_output();
13103 }
13104 inline ::google::protobuf::RepeatedPtrField<std::string>*
13105 FunctionProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13106   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
13107   ::google::protobuf::internal::TSanWrite(&_impl_);
13108   return _internal_mutable_output();
13109 }
13110 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13111 FunctionProto::_internal_output() const {
13112   ::google::protobuf::internal::TSanRead(&_impl_);
13113   return _impl_.output_;
13114 }
13115 inline ::google::protobuf::RepeatedPtrField<std::string>*
13116 FunctionProto::_internal_mutable_output() {
13117   ::google::protobuf::internal::TSanRead(&_impl_);
13118   return &_impl_.output_;
13119 }
13120
13121 // repeated string attribute = 6;
13122 inline int FunctionProto::_internal_attribute_size() const {
13123   return _internal_attribute().size();
13124 }
13125 inline int FunctionProto::attribute_size() const {
13126   return _internal_attribute_size();
13127 }
13128 inline void FunctionProto::clear_attribute() {
13129   ::google::protobuf::internal::TSanWrite(&_impl_);
13130   _impl_.attribute_.Clear();
13131 }
13132 inline std::string* FunctionProto::add_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13133   ::google::protobuf::internal::TSanWrite(&_impl_);
13134   std::string* _s = _internal_mutable_attribute()->Add();
13135   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
13136   return _s;
13137 }
13138 inline const std::string& FunctionProto::attribute(int index) const
13139     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13140   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
13141   return _internal_attribute().Get(index);
13142 }
13143 inline std::string* FunctionProto::mutable_attribute(int index)
13144     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13145   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
13146   return _internal_mutable_attribute()->Mutable(index);
13147 }
13148 template <typename Arg_, typename... Args_>
13149 inline void FunctionProto::set_attribute(int index, Arg_&& value, Args_... args) {
13150   ::google::protobuf::internal::AssignToString(
13151       *_internal_mutable_attribute()->Mutable(index),
13152       std::forward<Arg_>(value), args... );
13153   // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
13154 }
13155 template <typename Arg_, typename... Args_>
13156 inline void FunctionProto::add_attribute(Arg_&& value, Args_... args) {
13157   ::google::protobuf::internal::TSanWrite(&_impl_);
13158   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_attribute(),
13159                                std::forward<Arg_>(value),
13160                                args... );
13161   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
13162 }
13163 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13164 FunctionProto::attribute() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13165   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
13166   return _internal_attribute();
13167 }
13168 inline ::google::protobuf::RepeatedPtrField<std::string>*
13169 FunctionProto::mutable_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13170   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
13171   ::google::protobuf::internal::TSanWrite(&_impl_);
13172   return _internal_mutable_attribute();
13173 }
13174 inline const ::google::protobuf::RepeatedPtrField<std::string>&
13175 FunctionProto::_internal_attribute() const {
13176   ::google::protobuf::internal::TSanRead(&_impl_);
13177   return _impl_.attribute_;
13178 }
13179 inline ::google::protobuf::RepeatedPtrField<std::string>*
13180 FunctionProto::_internal_mutable_attribute() {
13181   ::google::protobuf::internal::TSanRead(&_impl_);
13182   return &_impl_.attribute_;
13183 }
13184
13185 // repeated .onnx.AttributeProto attribute_proto = 11;
13186 inline int FunctionProto::_internal_attribute_proto_size() const {
13187   return _internal_attribute_proto().size();
13188 }
13189 inline int FunctionProto::attribute_proto_size() const {
13190   return _internal_attribute_proto_size();
13191 }
13192 inline void FunctionProto::clear_attribute_proto() {
13193   ::google::protobuf::internal::TSanWrite(&_impl_);
13194   _impl_.attribute_proto_.Clear();
13195 }
13196 inline ::onnx::AttributeProto* FunctionProto::mutable_attribute_proto(int index)
13197     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13198   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
13199   return _internal_mutable_attribute_proto()->Mutable(index);
13200 }
13201 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* FunctionProto::mutable_attribute_proto()
13202     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13203   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
13204   ::google::protobuf::internal::TSanWrite(&_impl_);
13205   return _internal_mutable_attribute_proto();
13206 }
13207 inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const
13208     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13209   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
13210   return _internal_attribute_proto().Get(index);
13211 }
13212 inline ::onnx::AttributeProto* FunctionProto::add_attribute_proto() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13213   ::google::protobuf::internal::TSanWrite(&_impl_);
13214   ::onnx::AttributeProto* _add = _internal_mutable_attribute_proto()->Add();
13215   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
13216   return _add;
13217 }
13218 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& FunctionProto::attribute_proto() const
13219     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13220   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
13221   return _internal_attribute_proto();
13222 }
13223 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
13224 FunctionProto::_internal_attribute_proto() const {
13225   ::google::protobuf::internal::TSanRead(&_impl_);
13226   return _impl_.attribute_proto_;
13227 }
13228 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>*
13229 FunctionProto::_internal_mutable_attribute_proto() {
13230   ::google::protobuf::internal::TSanRead(&_impl_);
13231   return &_impl_.attribute_proto_;
13232 }
13233
13234 // repeated .onnx.NodeProto node = 7;
13235 inline int FunctionProto::_internal_node_size() const {
13236   return _internal_node().size();
13237 }
13238 inline int FunctionProto::node_size() const {
13239   return _internal_node_size();
13240 }
13241 inline void FunctionProto::clear_node() {
13242   ::google::protobuf::internal::TSanWrite(&_impl_);
13243   _impl_.node_.Clear();
13244 }
13245 inline ::onnx::NodeProto* FunctionProto::mutable_node(int index)
13246     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13247   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
13248   return _internal_mutable_node()->Mutable(index);
13249 }
13250 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* FunctionProto::mutable_node()
13251     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13252   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
13253   ::google::protobuf::internal::TSanWrite(&_impl_);
13254   return _internal_mutable_node();
13255 }
13256 inline const ::onnx::NodeProto& FunctionProto::node(int index) const
13257     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13258   // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
13259   return _internal_node().Get(index);
13260 }
13261 inline ::onnx::NodeProto* FunctionProto::add_node() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13262   ::google::protobuf::internal::TSanWrite(&_impl_);
13263   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
13264   // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
13265   return _add;
13266 }
13267 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& FunctionProto::node() const
13268     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13269   // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
13270   return _internal_node();
13271 }
13272 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
13273 FunctionProto::_internal_node() const {
13274   ::google::protobuf::internal::TSanRead(&_impl_);
13275   return _impl_.node_;
13276 }
13277 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>*
13278 FunctionProto::_internal_mutable_node() {
13279   ::google::protobuf::internal::TSanRead(&_impl_);
13280   return &_impl_.node_;
13281 }
13282
13283 // optional string doc_string = 8;
13284 inline bool FunctionProto::has_doc_string() const {
13285   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
13286   return value;
13287 }
13288 inline void FunctionProto::clear_doc_string() {
13289   ::google::protobuf::internal::TSanWrite(&_impl_);
13290   _impl_.doc_string_.ClearToEmpty();
13291   _impl_._has_bits_[0] &= ~0x00000002u;
13292 }
13293 inline const std::string& FunctionProto::doc_string() const
13294     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13295   // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
13296   return _internal_doc_string();
13297 }
13298 template <typename Arg_, typename... Args_>
13299 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_doc_string(Arg_&& arg,
13300                                                      Args_... args) {
13301   ::google::protobuf::internal::TSanWrite(&_impl_);
13302   _impl_._has_bits_[0] |= 0x00000002u;
13303   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13304   // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
13305 }
13306 inline std::string* FunctionProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13307   std::string* _s = _internal_mutable_doc_string();
13308   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
13309   return _s;
13310 }
13311 inline const std::string& FunctionProto::_internal_doc_string() const {
13312   ::google::protobuf::internal::TSanRead(&_impl_);
13313   return _impl_.doc_string_.Get();
13314 }
13315 inline void FunctionProto::_internal_set_doc_string(const std::string& value) {
13316   ::google::protobuf::internal::TSanWrite(&_impl_);
13317   _impl_._has_bits_[0] |= 0x00000002u;
13318   _impl_.doc_string_.Set(value, GetArena());
13319 }
13320 inline std::string* FunctionProto::_internal_mutable_doc_string() {
13321   ::google::protobuf::internal::TSanWrite(&_impl_);
13322   _impl_._has_bits_[0] |= 0x00000002u;
13323   return _impl_.doc_string_.Mutable( GetArena());
13324 }
13325 inline std::string* FunctionProto::release_doc_string() {
13326   ::google::protobuf::internal::TSanWrite(&_impl_);
13327   // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
13328   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
13329     return nullptr;
13330   }
13331   _impl_._has_bits_[0] &= ~0x00000002u;
13332   auto* released = _impl_.doc_string_.Release();
13333   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13334   _impl_.doc_string_.Set("", GetArena());
13335   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13336   return released;
13337 }
13338 inline void FunctionProto::set_allocated_doc_string(std::string* value) {
13339   ::google::protobuf::internal::TSanWrite(&_impl_);
13340   if (value != nullptr) {
13341     _impl_._has_bits_[0] |= 0x00000002u;
13342   } else {
13343     _impl_._has_bits_[0] &= ~0x00000002u;
13344   }
13345   _impl_.doc_string_.SetAllocated(value, GetArena());
13346   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13347         if (_impl_.doc_string_.IsDefault()) {
13348           _impl_.doc_string_.Set("", GetArena());
13349         }
13350   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13351   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
13352 }
13353
13354 // repeated .onnx.OperatorSetIdProto opset_import = 9;
13355 inline int FunctionProto::_internal_opset_import_size() const {
13356   return _internal_opset_import().size();
13357 }
13358 inline int FunctionProto::opset_import_size() const {
13359   return _internal_opset_import_size();
13360 }
13361 inline void FunctionProto::clear_opset_import() {
13362   ::google::protobuf::internal::TSanWrite(&_impl_);
13363   _impl_.opset_import_.Clear();
13364 }
13365 inline ::onnx::OperatorSetIdProto* FunctionProto::mutable_opset_import(int index)
13366     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13367   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
13368   return _internal_mutable_opset_import()->Mutable(index);
13369 }
13370 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* FunctionProto::mutable_opset_import()
13371     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13372   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
13373   ::google::protobuf::internal::TSanWrite(&_impl_);
13374   return _internal_mutable_opset_import();
13375 }
13376 inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const
13377     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13378   // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
13379   return _internal_opset_import().Get(index);
13380 }
13381 inline ::onnx::OperatorSetIdProto* FunctionProto::add_opset_import() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13382   ::google::protobuf::internal::TSanWrite(&_impl_);
13383   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
13384   // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
13385   return _add;
13386 }
13387 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& FunctionProto::opset_import() const
13388     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13389   // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
13390   return _internal_opset_import();
13391 }
13392 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
13393 FunctionProto::_internal_opset_import() const {
13394   ::google::protobuf::internal::TSanRead(&_impl_);
13395   return _impl_.opset_import_;
13396 }
13397 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>*
13398 FunctionProto::_internal_mutable_opset_import() {
13399   ::google::protobuf::internal::TSanRead(&_impl_);
13400   return &_impl_.opset_import_;
13401 }
13402
13403 // optional string domain = 10;
13404 inline bool FunctionProto::has_domain() const {
13405   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
13406   return value;
13407 }
13408 inline void FunctionProto::clear_domain() {
13409   ::google::protobuf::internal::TSanWrite(&_impl_);
13410   _impl_.domain_.ClearToEmpty();
13411   _impl_._has_bits_[0] &= ~0x00000004u;
13412 }
13413 inline const std::string& FunctionProto::domain() const
13414     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13415   // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
13416   return _internal_domain();
13417 }
13418 template <typename Arg_, typename... Args_>
13419 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_domain(Arg_&& arg,
13420                                                      Args_... args) {
13421   ::google::protobuf::internal::TSanWrite(&_impl_);
13422   _impl_._has_bits_[0] |= 0x00000004u;
13423   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13424   // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
13425 }
13426 inline std::string* FunctionProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13427   std::string* _s = _internal_mutable_domain();
13428   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
13429   return _s;
13430 }
13431 inline const std::string& FunctionProto::_internal_domain() const {
13432   ::google::protobuf::internal::TSanRead(&_impl_);
13433   return _impl_.domain_.Get();
13434 }
13435 inline void FunctionProto::_internal_set_domain(const std::string& value) {
13436   ::google::protobuf::internal::TSanWrite(&_impl_);
13437   _impl_._has_bits_[0] |= 0x00000004u;
13438   _impl_.domain_.Set(value, GetArena());
13439 }
13440 inline std::string* FunctionProto::_internal_mutable_domain() {
13441   ::google::protobuf::internal::TSanWrite(&_impl_);
13442   _impl_._has_bits_[0] |= 0x00000004u;
13443   return _impl_.domain_.Mutable( GetArena());
13444 }
13445 inline std::string* FunctionProto::release_domain() {
13446   ::google::protobuf::internal::TSanWrite(&_impl_);
13447   // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
13448   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
13449     return nullptr;
13450   }
13451   _impl_._has_bits_[0] &= ~0x00000004u;
13452   auto* released = _impl_.domain_.Release();
13453   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13454   _impl_.domain_.Set("", GetArena());
13455   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13456   return released;
13457 }
13458 inline void FunctionProto::set_allocated_domain(std::string* value) {
13459   ::google::protobuf::internal::TSanWrite(&_impl_);
13460   if (value != nullptr) {
13461     _impl_._has_bits_[0] |= 0x00000004u;
13462   } else {
13463     _impl_._has_bits_[0] &= ~0x00000004u;
13464   }
13465   _impl_.domain_.SetAllocated(value, GetArena());
13466   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13467         if (_impl_.domain_.IsDefault()) {
13468           _impl_.domain_.Set("", GetArena());
13469         }
13470   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13471   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
13472 }
13473
13474 // optional string overload = 13;
13475 inline bool FunctionProto::has_overload() const {
13476   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
13477   return value;
13478 }
13479 inline void FunctionProto::clear_overload() {
13480   ::google::protobuf::internal::TSanWrite(&_impl_);
13481   _impl_.overload_.ClearToEmpty();
13482   _impl_._has_bits_[0] &= ~0x00000008u;
13483 }
13484 inline const std::string& FunctionProto::overload() const
13485     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13486   // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload)
13487   return _internal_overload();
13488 }
13489 template <typename Arg_, typename... Args_>
13490 inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_overload(Arg_&& arg,
13491                                                      Args_... args) {
13492   ::google::protobuf::internal::TSanWrite(&_impl_);
13493   _impl_._has_bits_[0] |= 0x00000008u;
13494   _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13495   // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload)
13496 }
13497 inline std::string* FunctionProto::mutable_overload() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13498   std::string* _s = _internal_mutable_overload();
13499   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload)
13500   return _s;
13501 }
13502 inline const std::string& FunctionProto::_internal_overload() const {
13503   ::google::protobuf::internal::TSanRead(&_impl_);
13504   return _impl_.overload_.Get();
13505 }
13506 inline void FunctionProto::_internal_set_overload(const std::string& value) {
13507   ::google::protobuf::internal::TSanWrite(&_impl_);
13508   _impl_._has_bits_[0] |= 0x00000008u;
13509   _impl_.overload_.Set(value, GetArena());
13510 }
13511 inline std::string* FunctionProto::_internal_mutable_overload() {
13512   ::google::protobuf::internal::TSanWrite(&_impl_);
13513   _impl_._has_bits_[0] |= 0x00000008u;
13514   return _impl_.overload_.Mutable( GetArena());
13515 }
13516 inline std::string* FunctionProto::release_overload() {
13517   ::google::protobuf::internal::TSanWrite(&_impl_);
13518   // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload)
13519   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
13520     return nullptr;
13521   }
13522   _impl_._has_bits_[0] &= ~0x00000008u;
13523   auto* released = _impl_.overload_.Release();
13524   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13525   _impl_.overload_.Set("", GetArena());
13526   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13527   return released;
13528 }
13529 inline void FunctionProto::set_allocated_overload(std::string* value) {
13530   ::google::protobuf::internal::TSanWrite(&_impl_);
13531   if (value != nullptr) {
13532     _impl_._has_bits_[0] |= 0x00000008u;
13533   } else {
13534     _impl_._has_bits_[0] &= ~0x00000008u;
13535   }
13536   _impl_.overload_.SetAllocated(value, GetArena());
13537   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
13538         if (_impl_.overload_.IsDefault()) {
13539           _impl_.overload_.Set("", GetArena());
13540         }
13541   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
13542   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload)
13543 }
13544
13545 // repeated .onnx.ValueInfoProto value_info = 12;
13546 inline int FunctionProto::_internal_value_info_size() const {
13547   return _internal_value_info().size();
13548 }
13549 inline int FunctionProto::value_info_size() const {
13550   return _internal_value_info_size();
13551 }
13552 inline void FunctionProto::clear_value_info() {
13553   ::google::protobuf::internal::TSanWrite(&_impl_);
13554   _impl_.value_info_.Clear();
13555 }
13556 inline ::onnx::ValueInfoProto* FunctionProto::mutable_value_info(int index)
13557     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13558   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info)
13559   return _internal_mutable_value_info()->Mutable(index);
13560 }
13561 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* FunctionProto::mutable_value_info()
13562     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13563   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info)
13564   ::google::protobuf::internal::TSanWrite(&_impl_);
13565   return _internal_mutable_value_info();
13566 }
13567 inline const ::onnx::ValueInfoProto& FunctionProto::value_info(int index) const
13568     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13569   // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info)
13570   return _internal_value_info().Get(index);
13571 }
13572 inline ::onnx::ValueInfoProto* FunctionProto::add_value_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13573   ::google::protobuf::internal::TSanWrite(&_impl_);
13574   ::onnx::ValueInfoProto* _add = _internal_mutable_value_info()->Add();
13575   // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info)
13576   return _add;
13577 }
13578 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& FunctionProto::value_info() const
13579     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13580   // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info)
13581   return _internal_value_info();
13582 }
13583 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
13584 FunctionProto::_internal_value_info() const {
13585   ::google::protobuf::internal::TSanRead(&_impl_);
13586   return _impl_.value_info_;
13587 }
13588 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>*
13589 FunctionProto::_internal_mutable_value_info() {
13590   ::google::protobuf::internal::TSanRead(&_impl_);
13591   return &_impl_.value_info_;
13592 }
13593
13594 // repeated .onnx.StringStringEntryProto metadata_props = 14;
13595 inline int FunctionProto::_internal_metadata_props_size() const {
13596   return _internal_metadata_props().size();
13597 }
13598 inline int FunctionProto::metadata_props_size() const {
13599   return _internal_metadata_props_size();
13600 }
13601 inline void FunctionProto::clear_metadata_props() {
13602   ::google::protobuf::internal::TSanWrite(&_impl_);
13603   _impl_.metadata_props_.Clear();
13604 }
13605 inline ::onnx::StringStringEntryProto* FunctionProto::mutable_metadata_props(int index)
13606     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13607   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props)
13608   return _internal_mutable_metadata_props()->Mutable(index);
13609 }
13610 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* FunctionProto::mutable_metadata_props()
13611     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13612   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props)
13613   ::google::protobuf::internal::TSanWrite(&_impl_);
13614   return _internal_mutable_metadata_props();
13615 }
13616 inline const ::onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const
13617     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13618   // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props)
13619   return _internal_metadata_props().Get(index);
13620 }
13621 inline ::onnx::StringStringEntryProto* FunctionProto::add_metadata_props() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13622   ::google::protobuf::internal::TSanWrite(&_impl_);
13623   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
13624   // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props)
13625   return _add;
13626 }
13627 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& FunctionProto::metadata_props() const
13628     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13629   // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props)
13630   return _internal_metadata_props();
13631 }
13632 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
13633 FunctionProto::_internal_metadata_props() const {
13634   ::google::protobuf::internal::TSanRead(&_impl_);
13635   return _impl_.metadata_props_;
13636 }
13637 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>*
13638 FunctionProto::_internal_mutable_metadata_props() {
13639   ::google::protobuf::internal::TSanRead(&_impl_);
13640   return &_impl_.metadata_props_;
13641 }
13642
13643 #ifdef __GNUC__
13644 #pragma GCC diagnostic pop
13645 #endif  // __GNUC__
13646
13647 // @@protoc_insertion_point(namespace_scope)
13648 }  // namespace onnx
13649
13650
13651 namespace google {
13652 namespace protobuf {
13653
13654 template <>
13655 struct is_proto_enum<::onnx::AttributeProto_AttributeType> : std::true_type {};
13656 template <>
13657 inline const EnumDescriptor* GetEnumDescriptor<::onnx::AttributeProto_AttributeType>() {
13658   return ::onnx::AttributeProto_AttributeType_descriptor();
13659 }
13660 template <>
13661 struct is_proto_enum<::onnx::TensorProto_DataType> : std::true_type {};
13662 template <>
13663 inline const EnumDescriptor* GetEnumDescriptor<::onnx::TensorProto_DataType>() {
13664   return ::onnx::TensorProto_DataType_descriptor();
13665 }
13666 template <>
13667 struct is_proto_enum<::onnx::TensorProto_DataLocation> : std::true_type {};
13668 template <>
13669 inline const EnumDescriptor* GetEnumDescriptor<::onnx::TensorProto_DataLocation>() {
13670   return ::onnx::TensorProto_DataLocation_descriptor();
13671 }
13672 template <>
13673 struct is_proto_enum<::onnx::Version> : std::true_type {};
13674 template <>
13675 inline const EnumDescriptor* GetEnumDescriptor<::onnx::Version>() {
13676   return ::onnx::Version_descriptor();
13677 }
13678 template <>
13679 struct is_proto_enum<::onnx::OperatorStatus> : std::true_type {};
13680 template <>
13681 inline const EnumDescriptor* GetEnumDescriptor<::onnx::OperatorStatus>() {
13682   return ::onnx::OperatorStatus_descriptor();
13683 }
13684
13685 }  // namespace protobuf
13686 }  // namespace google
13687
13688 // @@protoc_insertion_point(global_scope)
13689
13690 #include "google/protobuf/port_undef.inc"
13691
13692 #endif  // GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2dml_2eproto_2epb_2eh