include/onnx/onnx-data.pb.h

0001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
0002 // NO CHECKED-IN PROTOBUF GENCODE
0003 // source: onnx/onnx-data.proto
0004 // Protobuf C++ Version: 6.32.1
0005
0006 #ifndef onnx_2fonnx_2ddata_2eproto_2epb_2eh
0007 #define onnx_2fonnx_2ddata_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 != 6032001
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/message_lite.h"
0029 #include "google/protobuf/repeated_field.h"  // IWYU pragma: export
0030 #include "google/protobuf/extension_set.h"  // IWYU pragma: export
0031 #include "google/protobuf/generated_enum_reflection.h"
0032 #include "google/protobuf/unknown_field_set.h"
0033 #include "onnx/onnx-ml.pb.h"
0034 // @@protoc_insertion_point(includes)
0035
0036 // Must be included last.
0037 #include "google/protobuf/port_def.inc"
0038
0039 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2ddata_2eproto ONNX_API
0040
0041 namespace google {
0042 namespace protobuf {
0043 namespace internal {
0044 template <typename T>
0045 ::absl::string_view GetAnyMessageName();
0046 }  // namespace internal
0047 }  // namespace protobuf
0048 }  // namespace google
0049
0050 // Internal implementation detail -- do not use these members.
0051 struct ONNX_API TableStruct_onnx_2fonnx_2ddata_2eproto {
0052   static const ::uint32_t offsets[];
0053 };
0054 extern "C" {
0055 ONNX_API extern const ::google::protobuf::internal::DescriptorTable descriptor_table_onnx_2fonnx_2ddata_2eproto;
0056 }  // extern "C"
0057 namespace onnx {
0058 enum OptionalProto_DataType : int;
0059 ONNX_API extern const uint32_t OptionalProto_DataType_internal_data_[];
0060 enum SequenceProto_DataType : int;
0061 ONNX_API extern const uint32_t SequenceProto_DataType_internal_data_[];
0062 class MapProto;
0063 struct MapProtoDefaultTypeInternal;
0064 ONNX_API extern MapProtoDefaultTypeInternal _MapProto_default_instance_;
0065 ONNX_API extern const ::google::protobuf::internal::ClassDataFull MapProto_class_data_;
0066 class OptionalProto;
0067 struct OptionalProtoDefaultTypeInternal;
0068 ONNX_API extern OptionalProtoDefaultTypeInternal _OptionalProto_default_instance_;
0069 ONNX_API extern const ::google::protobuf::internal::ClassDataFull OptionalProto_class_data_;
0070 class SequenceProto;
0071 struct SequenceProtoDefaultTypeInternal;
0072 ONNX_API extern SequenceProtoDefaultTypeInternal _SequenceProto_default_instance_;
0073 ONNX_API extern const ::google::protobuf::internal::ClassDataFull SequenceProto_class_data_;
0074 }  // namespace onnx
0075 namespace google {
0076 namespace protobuf {
0077 template <>
0078 internal::EnumTraitsT<::onnx::OptionalProto_DataType_internal_data_>
0079     internal::EnumTraitsImpl::value<::onnx::OptionalProto_DataType>;
0080 template <>
0081 internal::EnumTraitsT<::onnx::SequenceProto_DataType_internal_data_>
0082     internal::EnumTraitsImpl::value<::onnx::SequenceProto_DataType>;
0083 }  // namespace protobuf
0084 }  // namespace google
0085
0086 namespace onnx {
0087 enum SequenceProto_DataType : int {
0088   SequenceProto_DataType_UNDEFINED = 0,
0089   SequenceProto_DataType_TENSOR = 1,
0090   SequenceProto_DataType_SPARSE_TENSOR = 2,
0091   SequenceProto_DataType_SEQUENCE = 3,
0092   SequenceProto_DataType_MAP = 4,
0093   SequenceProto_DataType_OPTIONAL = 5,
0094 };
0095
0096 ONNX_API extern const uint32_t SequenceProto_DataType_internal_data_[];
0097 inline constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MIN =
0098     static_cast<SequenceProto_DataType>(0);
0099 inline constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MAX =
0100     static_cast<SequenceProto_DataType>(5);
0101 inline bool SequenceProto_DataType_IsValid(int value) {
0102   return 0 <= value && value <= 5;
0103 }
0104 inline constexpr int SequenceProto_DataType_DataType_ARRAYSIZE = 5 + 1;
0105 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SequenceProto_DataType_descriptor();
0106 template <typename T>
0107 const ::std::string& SequenceProto_DataType_Name(T value) {
0108   static_assert(::std::is_same<T, SequenceProto_DataType>::value ||
0109                     ::std::is_integral<T>::value,
0110                 "Incorrect type passed to DataType_Name().");
0111   return SequenceProto_DataType_Name(static_cast<SequenceProto_DataType>(value));
0112 }
0113 template <>
0114 inline const ::std::string& SequenceProto_DataType_Name(SequenceProto_DataType value) {
0115   return ::google::protobuf::internal::NameOfDenseEnum<SequenceProto_DataType_descriptor, 0, 5>(
0116       static_cast<int>(value));
0117 }
0118 inline bool SequenceProto_DataType_Parse(
0119     ::absl::string_view name, SequenceProto_DataType* PROTOBUF_NONNULL value) {
0120   return ::google::protobuf::internal::ParseNamedEnum<SequenceProto_DataType>(SequenceProto_DataType_descriptor(), name,
0121                                            value);
0122 }
0123 enum OptionalProto_DataType : int {
0124   OptionalProto_DataType_UNDEFINED = 0,
0125   OptionalProto_DataType_TENSOR = 1,
0126   OptionalProto_DataType_SPARSE_TENSOR = 2,
0127   OptionalProto_DataType_SEQUENCE = 3,
0128   OptionalProto_DataType_MAP = 4,
0129   OptionalProto_DataType_OPTIONAL = 5,
0130 };
0131
0132 ONNX_API extern const uint32_t OptionalProto_DataType_internal_data_[];
0133 inline constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MIN =
0134     static_cast<OptionalProto_DataType>(0);
0135 inline constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MAX =
0136     static_cast<OptionalProto_DataType>(5);
0137 inline bool OptionalProto_DataType_IsValid(int value) {
0138   return 0 <= value && value <= 5;
0139 }
0140 inline constexpr int OptionalProto_DataType_DataType_ARRAYSIZE = 5 + 1;
0141 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL OptionalProto_DataType_descriptor();
0142 template <typename T>
0143 const ::std::string& OptionalProto_DataType_Name(T value) {
0144   static_assert(::std::is_same<T, OptionalProto_DataType>::value ||
0145                     ::std::is_integral<T>::value,
0146                 "Incorrect type passed to DataType_Name().");
0147   return OptionalProto_DataType_Name(static_cast<OptionalProto_DataType>(value));
0148 }
0149 template <>
0150 inline const ::std::string& OptionalProto_DataType_Name(OptionalProto_DataType value) {
0151   return ::google::protobuf::internal::NameOfDenseEnum<OptionalProto_DataType_descriptor, 0, 5>(
0152       static_cast<int>(value));
0153 }
0154 inline bool OptionalProto_DataType_Parse(
0155     ::absl::string_view name, OptionalProto_DataType* PROTOBUF_NONNULL value) {
0156   return ::google::protobuf::internal::ParseNamedEnum<OptionalProto_DataType>(OptionalProto_DataType_descriptor(), name,
0157                                            value);
0158 }
0159
0160 // ===================================================================
0161
0162
0163 // -------------------------------------------------------------------
0164
0165 class ONNX_API MapProto final : public ::google::protobuf::Message
0166 /* @@protoc_insertion_point(class_definition:onnx.MapProto) */ {
0167  public:
0168   inline MapProto() : MapProto(nullptr) {}
0169   ~MapProto() PROTOBUF_FINAL;
0170
0171 #if defined(PROTOBUF_CUSTOM_VTABLE)
0172   void operator delete(MapProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0173     SharedDtor(*msg);
0174     ::google::protobuf::internal::SizedDelete(msg, sizeof(MapProto));
0175   }
0176 #endif
0177
0178   template <typename = void>
0179   explicit PROTOBUF_CONSTEXPR MapProto(::google::protobuf::internal::ConstantInitialized);
0180
0181   inline MapProto(const MapProto& from) : MapProto(nullptr, from) {}
0182   inline MapProto(MapProto&& from) noexcept
0183       : MapProto(nullptr, ::std::move(from)) {}
0184   inline MapProto& operator=(const MapProto& from) {
0185     CopyFrom(from);
0186     return *this;
0187   }
0188   inline MapProto& operator=(MapProto&& from) noexcept {
0189     if (this == &from) return *this;
0190     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0191       InternalSwap(&from);
0192     } else {
0193       CopyFrom(from);
0194     }
0195     return *this;
0196   }
0197
0198   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0199       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0200     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0201   }
0202   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0203       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0204     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0205   }
0206
0207   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0208     return GetDescriptor();
0209   }
0210   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0211     return default_instance().GetMetadata().descriptor;
0212   }
0213   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0214     return default_instance().GetMetadata().reflection;
0215   }
0216   static const MapProto& default_instance() {
0217     return *reinterpret_cast<const MapProto*>(
0218         &_MapProto_default_instance_);
0219   }
0220   static constexpr int kIndexInFileMessages = 1;
0221   friend void swap(MapProto& a, MapProto& b) { a.Swap(&b); }
0222   inline void Swap(MapProto* PROTOBUF_NONNULL other) {
0223     if (other == this) return;
0224     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0225       InternalSwap(other);
0226     } else {
0227       ::google::protobuf::internal::GenericSwap(this, other);
0228     }
0229   }
0230   void UnsafeArenaSwap(MapProto* PROTOBUF_NONNULL other) {
0231     if (other == this) return;
0232     ABSL_DCHECK(GetArena() == other->GetArena());
0233     InternalSwap(other);
0234   }
0235
0236   // implements Message ----------------------------------------------
0237
0238   MapProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0239     return ::google::protobuf::Message::DefaultConstruct<MapProto>(arena);
0240   }
0241   using ::google::protobuf::Message::CopyFrom;
0242   void CopyFrom(const MapProto& from);
0243   using ::google::protobuf::Message::MergeFrom;
0244   void MergeFrom(const MapProto& from) { MapProto::MergeImpl(*this, from); }
0245
0246   private:
0247   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0248                         const ::google::protobuf::MessageLite& from_msg);
0249
0250   public:
0251   bool IsInitialized() const {
0252     return true;
0253   }
0254   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0255   #if defined(PROTOBUF_CUSTOM_VTABLE)
0256   private:
0257   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0258   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0259       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0260       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0261
0262   public:
0263   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0264   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0265       ::uint8_t* PROTOBUF_NONNULL target,
0266       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0267     return _InternalSerialize(*this, target, stream);
0268   }
0269   #else   // PROTOBUF_CUSTOM_VTABLE
0270   ::size_t ByteSizeLong() const final;
0271   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0272       ::uint8_t* PROTOBUF_NONNULL target,
0273       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0274   #endif  // PROTOBUF_CUSTOM_VTABLE
0275   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0276
0277   private:
0278   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0279   static void SharedDtor(MessageLite& self);
0280   void InternalSwap(MapProto* PROTOBUF_NONNULL other);
0281  private:
0282   template <typename T>
0283   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0284   static ::absl::string_view FullMessageName() { return "onnx.MapProto"; }
0285
0286  protected:
0287   explicit MapProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0288   MapProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MapProto& from);
0289   MapProto(
0290       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MapProto&& from) noexcept
0291       : MapProto(arena) {
0292     *this = ::std::move(from);
0293   }
0294   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0295   static void* PROTOBUF_NONNULL PlacementNew_(
0296       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0297       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0298   static constexpr auto InternalNewImpl_();
0299
0300  public:
0301   static constexpr auto InternalGenerateClassData_();
0302
0303   ::google::protobuf::Metadata GetMetadata() const;
0304   // nested types ----------------------------------------------------
0305
0306   // accessors -------------------------------------------------------
0307   enum : int {
0308     kKeysFieldNumber = 3,
0309     kStringKeysFieldNumber = 4,
0310     kNameFieldNumber = 1,
0311     kValuesFieldNumber = 5,
0312     kKeyTypeFieldNumber = 2,
0313   };
0314   // repeated int64 keys = 3;
0315   int keys_size() const;
0316   private:
0317   int _internal_keys_size() const;
0318
0319   public:
0320   void clear_keys() ;
0321   ::int64_t keys(int index) const;
0322   void set_keys(int index, ::int64_t value);
0323   void add_keys(::int64_t value);
0324   const ::google::protobuf::RepeatedField<::int64_t>& keys() const;
0325   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_keys();
0326
0327   private:
0328   const ::google::protobuf::RepeatedField<::int64_t>& _internal_keys() const;
0329   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_keys();
0330
0331   public:
0332   // repeated bytes string_keys = 4;
0333   int string_keys_size() const;
0334   private:
0335   int _internal_string_keys_size() const;
0336
0337   public:
0338   void clear_string_keys() ;
0339   const ::std::string& string_keys(int index) const;
0340   ::std::string* PROTOBUF_NONNULL mutable_string_keys(int index);
0341   template <typename Arg_ = const ::std::string&, typename... Args_>
0342   void set_string_keys(int index, Arg_&& value, Args_... args);
0343   ::std::string* PROTOBUF_NONNULL add_string_keys();
0344   template <typename Arg_ = const ::std::string&, typename... Args_>
0345   void add_string_keys(Arg_&& value, Args_... args);
0346   const ::google::protobuf::RepeatedPtrField<::std::string>& string_keys() const;
0347   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_string_keys();
0348
0349   private:
0350   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_string_keys() const;
0351   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_string_keys();
0352
0353   public:
0354   // optional string name = 1;
0355   bool has_name() const;
0356   void clear_name() ;
0357   const ::std::string& name() const;
0358   template <typename Arg_ = const ::std::string&, typename... Args_>
0359   void set_name(Arg_&& arg, Args_... args);
0360   ::std::string* PROTOBUF_NONNULL mutable_name();
0361   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
0362   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
0363
0364   private:
0365   const ::std::string& _internal_name() const;
0366   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
0367   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
0368
0369   public:
0370   // optional .onnx.SequenceProto values = 5;
0371   bool has_values() const;
0372   void clear_values() ;
0373   const ::onnx::SequenceProto& values() const;
0374   [[nodiscard]] ::onnx::SequenceProto* PROTOBUF_NULLABLE release_values();
0375   ::onnx::SequenceProto* PROTOBUF_NONNULL mutable_values();
0376   void set_allocated_values(::onnx::SequenceProto* PROTOBUF_NULLABLE value);
0377   void unsafe_arena_set_allocated_values(::onnx::SequenceProto* PROTOBUF_NULLABLE value);
0378   ::onnx::SequenceProto* PROTOBUF_NULLABLE unsafe_arena_release_values();
0379
0380   private:
0381   const ::onnx::SequenceProto& _internal_values() const;
0382   ::onnx::SequenceProto* PROTOBUF_NONNULL _internal_mutable_values();
0383
0384   public:
0385   // optional int32 key_type = 2;
0386   bool has_key_type() const;
0387   void clear_key_type() ;
0388   ::int32_t key_type() const;
0389   void set_key_type(::int32_t value);
0390
0391   private:
0392   ::int32_t _internal_key_type() const;
0393   void _internal_set_key_type(::int32_t value);
0394
0395   public:
0396   // @@protoc_insertion_point(class_scope:onnx.MapProto)
0397  private:
0398   class _Internal;
0399   friend class ::google::protobuf::internal::TcParser;
0400   static const ::google::protobuf::internal::TcParseTable<3, 5,
0401                                    1, 26,
0402                                    2>
0403       _table_;
0404
0405   friend class ::google::protobuf::MessageLite;
0406   friend class ::google::protobuf::Arena;
0407   template <typename T>
0408   friend class ::google::protobuf::Arena::InternalHelper;
0409   using InternalArenaConstructable_ = void;
0410   using DestructorSkippable_ = void;
0411   struct Impl_ {
0412     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
0413     inline explicit Impl_(
0414         ::google::protobuf::internal::InternalVisibility visibility,
0415         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0416     inline explicit Impl_(
0417         ::google::protobuf::internal::InternalVisibility visibility,
0418         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
0419         const MapProto& from_msg);
0420     ::google::protobuf::internal::HasBits<1> _has_bits_;
0421     ::google::protobuf::internal::CachedSize _cached_size_;
0422     ::google::protobuf::RepeatedField<::int64_t> keys_;
0423     ::google::protobuf::RepeatedPtrField<::std::string> string_keys_;
0424     ::google::protobuf::internal::ArenaStringPtr name_;
0425     ::onnx::SequenceProto* PROTOBUF_NULLABLE values_;
0426     ::int32_t key_type_;
0427     PROTOBUF_TSAN_DECLARE_MEMBER
0428   };
0429   union { Impl_ _impl_; };
0430   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
0431 };
0432
0433 ONNX_API extern const ::google::protobuf::internal::ClassDataFull MapProto_class_data_;
0434 // -------------------------------------------------------------------
0435
0436 class ONNX_API OptionalProto final : public ::google::protobuf::Message
0437 /* @@protoc_insertion_point(class_definition:onnx.OptionalProto) */ {
0438  public:
0439   inline OptionalProto() : OptionalProto(nullptr) {}
0440   ~OptionalProto() PROTOBUF_FINAL;
0441
0442 #if defined(PROTOBUF_CUSTOM_VTABLE)
0443   void operator delete(OptionalProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0444     SharedDtor(*msg);
0445     ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionalProto));
0446   }
0447 #endif
0448
0449   template <typename = void>
0450   explicit PROTOBUF_CONSTEXPR OptionalProto(::google::protobuf::internal::ConstantInitialized);
0451
0452   inline OptionalProto(const OptionalProto& from) : OptionalProto(nullptr, from) {}
0453   inline OptionalProto(OptionalProto&& from) noexcept
0454       : OptionalProto(nullptr, ::std::move(from)) {}
0455   inline OptionalProto& operator=(const OptionalProto& from) {
0456     CopyFrom(from);
0457     return *this;
0458   }
0459   inline OptionalProto& operator=(OptionalProto&& from) noexcept {
0460     if (this == &from) return *this;
0461     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0462       InternalSwap(&from);
0463     } else {
0464       CopyFrom(from);
0465     }
0466     return *this;
0467   }
0468
0469   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0470       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0471     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0472   }
0473   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0474       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0475     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0476   }
0477
0478   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0479     return GetDescriptor();
0480   }
0481   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0482     return default_instance().GetMetadata().descriptor;
0483   }
0484   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0485     return default_instance().GetMetadata().reflection;
0486   }
0487   static const OptionalProto& default_instance() {
0488     return *reinterpret_cast<const OptionalProto*>(
0489         &_OptionalProto_default_instance_);
0490   }
0491   static constexpr int kIndexInFileMessages = 2;
0492   friend void swap(OptionalProto& a, OptionalProto& b) { a.Swap(&b); }
0493   inline void Swap(OptionalProto* PROTOBUF_NONNULL other) {
0494     if (other == this) return;
0495     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0496       InternalSwap(other);
0497     } else {
0498       ::google::protobuf::internal::GenericSwap(this, other);
0499     }
0500   }
0501   void UnsafeArenaSwap(OptionalProto* PROTOBUF_NONNULL other) {
0502     if (other == this) return;
0503     ABSL_DCHECK(GetArena() == other->GetArena());
0504     InternalSwap(other);
0505   }
0506
0507   // implements Message ----------------------------------------------
0508
0509   OptionalProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0510     return ::google::protobuf::Message::DefaultConstruct<OptionalProto>(arena);
0511   }
0512   using ::google::protobuf::Message::CopyFrom;
0513   void CopyFrom(const OptionalProto& from);
0514   using ::google::protobuf::Message::MergeFrom;
0515   void MergeFrom(const OptionalProto& from) { OptionalProto::MergeImpl(*this, from); }
0516
0517   private:
0518   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0519                         const ::google::protobuf::MessageLite& from_msg);
0520
0521   public:
0522   bool IsInitialized() const {
0523     return true;
0524   }
0525   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0526   #if defined(PROTOBUF_CUSTOM_VTABLE)
0527   private:
0528   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0529   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0530       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0531       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0532
0533   public:
0534   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0535   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0536       ::uint8_t* PROTOBUF_NONNULL target,
0537       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0538     return _InternalSerialize(*this, target, stream);
0539   }
0540   #else   // PROTOBUF_CUSTOM_VTABLE
0541   ::size_t ByteSizeLong() const final;
0542   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0543       ::uint8_t* PROTOBUF_NONNULL target,
0544       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0545   #endif  // PROTOBUF_CUSTOM_VTABLE
0546   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0547
0548   private:
0549   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0550   static void SharedDtor(MessageLite& self);
0551   void InternalSwap(OptionalProto* PROTOBUF_NONNULL other);
0552  private:
0553   template <typename T>
0554   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0555   static ::absl::string_view FullMessageName() { return "onnx.OptionalProto"; }
0556
0557  protected:
0558   explicit OptionalProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0559   OptionalProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionalProto& from);
0560   OptionalProto(
0561       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionalProto&& from) noexcept
0562       : OptionalProto(arena) {
0563     *this = ::std::move(from);
0564   }
0565   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0566   static void* PROTOBUF_NONNULL PlacementNew_(
0567       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0568       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0569   static constexpr auto InternalNewImpl_();
0570
0571  public:
0572   static constexpr auto InternalGenerateClassData_();
0573
0574   ::google::protobuf::Metadata GetMetadata() const;
0575   // nested types ----------------------------------------------------
0576   using DataType = OptionalProto_DataType;
0577   static constexpr DataType UNDEFINED = OptionalProto_DataType_UNDEFINED;
0578   static constexpr DataType TENSOR = OptionalProto_DataType_TENSOR;
0579   static constexpr DataType SPARSE_TENSOR = OptionalProto_DataType_SPARSE_TENSOR;
0580   static constexpr DataType SEQUENCE = OptionalProto_DataType_SEQUENCE;
0581   static constexpr DataType MAP = OptionalProto_DataType_MAP;
0582   static constexpr DataType OPTIONAL = OptionalProto_DataType_OPTIONAL;
0583   static inline bool DataType_IsValid(int value) {
0584     return OptionalProto_DataType_IsValid(value);
0585   }
0586   static constexpr DataType DataType_MIN = OptionalProto_DataType_DataType_MIN;
0587   static constexpr DataType DataType_MAX = OptionalProto_DataType_DataType_MAX;
0588   static constexpr int DataType_ARRAYSIZE = OptionalProto_DataType_DataType_ARRAYSIZE;
0589   static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataType_descriptor() {
0590     return OptionalProto_DataType_descriptor();
0591   }
0592   template <typename T>
0593   static inline const ::std::string& DataType_Name(T value) {
0594     return OptionalProto_DataType_Name(value);
0595   }
0596   static inline bool DataType_Parse(
0597       ::absl::string_view name, DataType* PROTOBUF_NONNULL value) {
0598     return OptionalProto_DataType_Parse(name, value);
0599   }
0600
0601   // accessors -------------------------------------------------------
0602   enum : int {
0603     kNameFieldNumber = 1,
0604     kTensorValueFieldNumber = 3,
0605     kSparseTensorValueFieldNumber = 4,
0606     kSequenceValueFieldNumber = 5,
0607     kMapValueFieldNumber = 6,
0608     kOptionalValueFieldNumber = 7,
0609     kElemTypeFieldNumber = 2,
0610   };
0611   // optional string name = 1;
0612   bool has_name() const;
0613   void clear_name() ;
0614   const ::std::string& name() const;
0615   template <typename Arg_ = const ::std::string&, typename... Args_>
0616   void set_name(Arg_&& arg, Args_... args);
0617   ::std::string* PROTOBUF_NONNULL mutable_name();
0618   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
0619   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
0620
0621   private:
0622   const ::std::string& _internal_name() const;
0623   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
0624   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
0625
0626   public:
0627   // optional .onnx.TensorProto tensor_value = 3;
0628   bool has_tensor_value() const;
0629   void clear_tensor_value() ;
0630   const ::onnx::TensorProto& tensor_value() const;
0631   [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_tensor_value();
0632   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_tensor_value();
0633   void set_allocated_tensor_value(::onnx::TensorProto* PROTOBUF_NULLABLE value);
0634   void unsafe_arena_set_allocated_tensor_value(::onnx::TensorProto* PROTOBUF_NULLABLE value);
0635   ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_tensor_value();
0636
0637   private:
0638   const ::onnx::TensorProto& _internal_tensor_value() const;
0639   ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_tensor_value();
0640
0641   public:
0642   // optional .onnx.SparseTensorProto sparse_tensor_value = 4;
0643   bool has_sparse_tensor_value() const;
0644   void clear_sparse_tensor_value() ;
0645   const ::onnx::SparseTensorProto& sparse_tensor_value() const;
0646   [[nodiscard]] ::onnx::SparseTensorProto* PROTOBUF_NULLABLE release_sparse_tensor_value();
0647   ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensor_value();
0648   void set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
0649   void unsafe_arena_set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
0650   ::onnx::SparseTensorProto* PROTOBUF_NULLABLE unsafe_arena_release_sparse_tensor_value();
0651
0652   private:
0653   const ::onnx::SparseTensorProto& _internal_sparse_tensor_value() const;
0654   ::onnx::SparseTensorProto* PROTOBUF_NONNULL _internal_mutable_sparse_tensor_value();
0655
0656   public:
0657   // optional .onnx.SequenceProto sequence_value = 5;
0658   bool has_sequence_value() const;
0659   void clear_sequence_value() ;
0660   const ::onnx::SequenceProto& sequence_value() const;
0661   [[nodiscard]] ::onnx::SequenceProto* PROTOBUF_NULLABLE release_sequence_value();
0662   ::onnx::SequenceProto* PROTOBUF_NONNULL mutable_sequence_value();
0663   void set_allocated_sequence_value(::onnx::SequenceProto* PROTOBUF_NULLABLE value);
0664   void unsafe_arena_set_allocated_sequence_value(::onnx::SequenceProto* PROTOBUF_NULLABLE value);
0665   ::onnx::SequenceProto* PROTOBUF_NULLABLE unsafe_arena_release_sequence_value();
0666
0667   private:
0668   const ::onnx::SequenceProto& _internal_sequence_value() const;
0669   ::onnx::SequenceProto* PROTOBUF_NONNULL _internal_mutable_sequence_value();
0670
0671   public:
0672   // optional .onnx.MapProto map_value = 6;
0673   bool has_map_value() const;
0674   void clear_map_value() ;
0675   const ::onnx::MapProto& map_value() const;
0676   [[nodiscard]] ::onnx::MapProto* PROTOBUF_NULLABLE release_map_value();
0677   ::onnx::MapProto* PROTOBUF_NONNULL mutable_map_value();
0678   void set_allocated_map_value(::onnx::MapProto* PROTOBUF_NULLABLE value);
0679   void unsafe_arena_set_allocated_map_value(::onnx::MapProto* PROTOBUF_NULLABLE value);
0680   ::onnx::MapProto* PROTOBUF_NULLABLE unsafe_arena_release_map_value();
0681
0682   private:
0683   const ::onnx::MapProto& _internal_map_value() const;
0684   ::onnx::MapProto* PROTOBUF_NONNULL _internal_mutable_map_value();
0685
0686   public:
0687   // optional .onnx.OptionalProto optional_value = 7;
0688   bool has_optional_value() const;
0689   void clear_optional_value() ;
0690   const ::onnx::OptionalProto& optional_value() const;
0691   [[nodiscard]] ::onnx::OptionalProto* PROTOBUF_NULLABLE release_optional_value();
0692   ::onnx::OptionalProto* PROTOBUF_NONNULL mutable_optional_value();
0693   void set_allocated_optional_value(::onnx::OptionalProto* PROTOBUF_NULLABLE value);
0694   void unsafe_arena_set_allocated_optional_value(::onnx::OptionalProto* PROTOBUF_NULLABLE value);
0695   ::onnx::OptionalProto* PROTOBUF_NULLABLE unsafe_arena_release_optional_value();
0696
0697   private:
0698   const ::onnx::OptionalProto& _internal_optional_value() const;
0699   ::onnx::OptionalProto* PROTOBUF_NONNULL _internal_mutable_optional_value();
0700
0701   public:
0702   // optional int32 elem_type = 2;
0703   bool has_elem_type() const;
0704   void clear_elem_type() ;
0705   ::int32_t elem_type() const;
0706   void set_elem_type(::int32_t value);
0707
0708   private:
0709   ::int32_t _internal_elem_type() const;
0710   void _internal_set_elem_type(::int32_t value);
0711
0712   public:
0713   // @@protoc_insertion_point(class_scope:onnx.OptionalProto)
0714  private:
0715   class _Internal;
0716   friend class ::google::protobuf::internal::TcParser;
0717   static const ::google::protobuf::internal::TcParseTable<3, 7,
0718                                    5, 31,
0719                                    2>
0720       _table_;
0721
0722   friend class ::google::protobuf::MessageLite;
0723   friend class ::google::protobuf::Arena;
0724   template <typename T>
0725   friend class ::google::protobuf::Arena::InternalHelper;
0726   using InternalArenaConstructable_ = void;
0727   using DestructorSkippable_ = void;
0728   struct Impl_ {
0729     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
0730     inline explicit Impl_(
0731         ::google::protobuf::internal::InternalVisibility visibility,
0732         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0733     inline explicit Impl_(
0734         ::google::protobuf::internal::InternalVisibility visibility,
0735         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
0736         const OptionalProto& from_msg);
0737     ::google::protobuf::internal::HasBits<1> _has_bits_;
0738     ::google::protobuf::internal::CachedSize _cached_size_;
0739     ::google::protobuf::internal::ArenaStringPtr name_;
0740     ::onnx::TensorProto* PROTOBUF_NULLABLE tensor_value_;
0741     ::onnx::SparseTensorProto* PROTOBUF_NULLABLE sparse_tensor_value_;
0742     ::onnx::SequenceProto* PROTOBUF_NULLABLE sequence_value_;
0743     ::onnx::MapProto* PROTOBUF_NULLABLE map_value_;
0744     ::onnx::OptionalProto* PROTOBUF_NULLABLE optional_value_;
0745     ::int32_t elem_type_;
0746     PROTOBUF_TSAN_DECLARE_MEMBER
0747   };
0748   union { Impl_ _impl_; };
0749   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
0750 };
0751
0752 ONNX_API extern const ::google::protobuf::internal::ClassDataFull OptionalProto_class_data_;
0753 // -------------------------------------------------------------------
0754
0755 class ONNX_API SequenceProto final : public ::google::protobuf::Message
0756 /* @@protoc_insertion_point(class_definition:onnx.SequenceProto) */ {
0757  public:
0758   inline SequenceProto() : SequenceProto(nullptr) {}
0759   ~SequenceProto() PROTOBUF_FINAL;
0760
0761 #if defined(PROTOBUF_CUSTOM_VTABLE)
0762   void operator delete(SequenceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0763     SharedDtor(*msg);
0764     ::google::protobuf::internal::SizedDelete(msg, sizeof(SequenceProto));
0765   }
0766 #endif
0767
0768   template <typename = void>
0769   explicit PROTOBUF_CONSTEXPR SequenceProto(::google::protobuf::internal::ConstantInitialized);
0770
0771   inline SequenceProto(const SequenceProto& from) : SequenceProto(nullptr, from) {}
0772   inline SequenceProto(SequenceProto&& from) noexcept
0773       : SequenceProto(nullptr, ::std::move(from)) {}
0774   inline SequenceProto& operator=(const SequenceProto& from) {
0775     CopyFrom(from);
0776     return *this;
0777   }
0778   inline SequenceProto& operator=(SequenceProto&& from) noexcept {
0779     if (this == &from) return *this;
0780     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0781       InternalSwap(&from);
0782     } else {
0783       CopyFrom(from);
0784     }
0785     return *this;
0786   }
0787
0788   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0789       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0790     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0791   }
0792   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0793       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0794     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0795   }
0796
0797   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0798     return GetDescriptor();
0799   }
0800   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0801     return default_instance().GetMetadata().descriptor;
0802   }
0803   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0804     return default_instance().GetMetadata().reflection;
0805   }
0806   static const SequenceProto& default_instance() {
0807     return *reinterpret_cast<const SequenceProto*>(
0808         &_SequenceProto_default_instance_);
0809   }
0810   static constexpr int kIndexInFileMessages = 0;
0811   friend void swap(SequenceProto& a, SequenceProto& b) { a.Swap(&b); }
0812   inline void Swap(SequenceProto* PROTOBUF_NONNULL other) {
0813     if (other == this) return;
0814     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0815       InternalSwap(other);
0816     } else {
0817       ::google::protobuf::internal::GenericSwap(this, other);
0818     }
0819   }
0820   void UnsafeArenaSwap(SequenceProto* PROTOBUF_NONNULL other) {
0821     if (other == this) return;
0822     ABSL_DCHECK(GetArena() == other->GetArena());
0823     InternalSwap(other);
0824   }
0825
0826   // implements Message ----------------------------------------------
0827
0828   SequenceProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0829     return ::google::protobuf::Message::DefaultConstruct<SequenceProto>(arena);
0830   }
0831   using ::google::protobuf::Message::CopyFrom;
0832   void CopyFrom(const SequenceProto& from);
0833   using ::google::protobuf::Message::MergeFrom;
0834   void MergeFrom(const SequenceProto& from) { SequenceProto::MergeImpl(*this, from); }
0835
0836   private:
0837   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0838                         const ::google::protobuf::MessageLite& from_msg);
0839
0840   public:
0841   bool IsInitialized() const {
0842     return true;
0843   }
0844   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0845   #if defined(PROTOBUF_CUSTOM_VTABLE)
0846   private:
0847   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0848   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0849       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0850       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0851
0852   public:
0853   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0854   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0855       ::uint8_t* PROTOBUF_NONNULL target,
0856       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0857     return _InternalSerialize(*this, target, stream);
0858   }
0859   #else   // PROTOBUF_CUSTOM_VTABLE
0860   ::size_t ByteSizeLong() const final;
0861   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0862       ::uint8_t* PROTOBUF_NONNULL target,
0863       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0864   #endif  // PROTOBUF_CUSTOM_VTABLE
0865   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0866
0867   private:
0868   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0869   static void SharedDtor(MessageLite& self);
0870   void InternalSwap(SequenceProto* PROTOBUF_NONNULL other);
0871  private:
0872   template <typename T>
0873   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0874   static ::absl::string_view FullMessageName() { return "onnx.SequenceProto"; }
0875
0876  protected:
0877   explicit SequenceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0878   SequenceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SequenceProto& from);
0879   SequenceProto(
0880       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SequenceProto&& from) noexcept
0881       : SequenceProto(arena) {
0882     *this = ::std::move(from);
0883   }
0884   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0885   static void* PROTOBUF_NONNULL PlacementNew_(
0886       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0887       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0888   static constexpr auto InternalNewImpl_();
0889
0890  public:
0891   static constexpr auto InternalGenerateClassData_();
0892
0893   ::google::protobuf::Metadata GetMetadata() const;
0894   // nested types ----------------------------------------------------
0895   using DataType = SequenceProto_DataType;
0896   static constexpr DataType UNDEFINED = SequenceProto_DataType_UNDEFINED;
0897   static constexpr DataType TENSOR = SequenceProto_DataType_TENSOR;
0898   static constexpr DataType SPARSE_TENSOR = SequenceProto_DataType_SPARSE_TENSOR;
0899   static constexpr DataType SEQUENCE = SequenceProto_DataType_SEQUENCE;
0900   static constexpr DataType MAP = SequenceProto_DataType_MAP;
0901   static constexpr DataType OPTIONAL = SequenceProto_DataType_OPTIONAL;
0902   static inline bool DataType_IsValid(int value) {
0903     return SequenceProto_DataType_IsValid(value);
0904   }
0905   static constexpr DataType DataType_MIN = SequenceProto_DataType_DataType_MIN;
0906   static constexpr DataType DataType_MAX = SequenceProto_DataType_DataType_MAX;
0907   static constexpr int DataType_ARRAYSIZE = SequenceProto_DataType_DataType_ARRAYSIZE;
0908   static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataType_descriptor() {
0909     return SequenceProto_DataType_descriptor();
0910   }
0911   template <typename T>
0912   static inline const ::std::string& DataType_Name(T value) {
0913     return SequenceProto_DataType_Name(value);
0914   }
0915   static inline bool DataType_Parse(
0916       ::absl::string_view name, DataType* PROTOBUF_NONNULL value) {
0917     return SequenceProto_DataType_Parse(name, value);
0918   }
0919
0920   // accessors -------------------------------------------------------
0921   enum : int {
0922     kTensorValuesFieldNumber = 3,
0923     kSparseTensorValuesFieldNumber = 4,
0924     kSequenceValuesFieldNumber = 5,
0925     kMapValuesFieldNumber = 6,
0926     kOptionalValuesFieldNumber = 7,
0927     kNameFieldNumber = 1,
0928     kElemTypeFieldNumber = 2,
0929   };
0930   // repeated .onnx.TensorProto tensor_values = 3;
0931   int tensor_values_size() const;
0932   private:
0933   int _internal_tensor_values_size() const;
0934
0935   public:
0936   void clear_tensor_values() ;
0937   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_tensor_values(int index);
0938   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL mutable_tensor_values();
0939
0940   private:
0941   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensor_values() const;
0942   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL _internal_mutable_tensor_values();
0943   public:
0944   const ::onnx::TensorProto& tensor_values(int index) const;
0945   ::onnx::TensorProto* PROTOBUF_NONNULL add_tensor_values();
0946   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensor_values() const;
0947   // repeated .onnx.SparseTensorProto sparse_tensor_values = 4;
0948   int sparse_tensor_values_size() const;
0949   private:
0950   int _internal_sparse_tensor_values_size() const;
0951
0952   public:
0953   void clear_sparse_tensor_values() ;
0954   ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensor_values(int index);
0955   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL mutable_sparse_tensor_values();
0956
0957   private:
0958   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensor_values() const;
0959   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL _internal_mutable_sparse_tensor_values();
0960   public:
0961   const ::onnx::SparseTensorProto& sparse_tensor_values(int index) const;
0962   ::onnx::SparseTensorProto* PROTOBUF_NONNULL add_sparse_tensor_values();
0963   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensor_values() const;
0964   // repeated .onnx.SequenceProto sequence_values = 5;
0965   int sequence_values_size() const;
0966   private:
0967   int _internal_sequence_values_size() const;
0968
0969   public:
0970   void clear_sequence_values() ;
0971   ::onnx::SequenceProto* PROTOBUF_NONNULL mutable_sequence_values(int index);
0972   ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* PROTOBUF_NONNULL mutable_sequence_values();
0973
0974   private:
0975   const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& _internal_sequence_values() const;
0976   ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* PROTOBUF_NONNULL _internal_mutable_sequence_values();
0977   public:
0978   const ::onnx::SequenceProto& sequence_values(int index) const;
0979   ::onnx::SequenceProto* PROTOBUF_NONNULL add_sequence_values();
0980   const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& sequence_values() const;
0981   // repeated .onnx.MapProto map_values = 6;
0982   int map_values_size() const;
0983   private:
0984   int _internal_map_values_size() const;
0985
0986   public:
0987   void clear_map_values() ;
0988   ::onnx::MapProto* PROTOBUF_NONNULL mutable_map_values(int index);
0989   ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* PROTOBUF_NONNULL mutable_map_values();
0990
0991   private:
0992   const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& _internal_map_values() const;
0993   ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* PROTOBUF_NONNULL _internal_mutable_map_values();
0994   public:
0995   const ::onnx::MapProto& map_values(int index) const;
0996   ::onnx::MapProto* PROTOBUF_NONNULL add_map_values();
0997   const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& map_values() const;
0998   // repeated .onnx.OptionalProto optional_values = 7;
0999   int optional_values_size() const;
1000   private:
1001   int _internal_optional_values_size() const;
1002
1003   public:
1004   void clear_optional_values() ;
1005   ::onnx::OptionalProto* PROTOBUF_NONNULL mutable_optional_values(int index);
1006   ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* PROTOBUF_NONNULL mutable_optional_values();
1007
1008   private:
1009   const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& _internal_optional_values() const;
1010   ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* PROTOBUF_NONNULL _internal_mutable_optional_values();
1011   public:
1012   const ::onnx::OptionalProto& optional_values(int index) const;
1013   ::onnx::OptionalProto* PROTOBUF_NONNULL add_optional_values();
1014   const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& optional_values() const;
1015   // optional string name = 1;
1016   bool has_name() const;
1017   void clear_name() ;
1018   const ::std::string& name() const;
1019   template <typename Arg_ = const ::std::string&, typename... Args_>
1020   void set_name(Arg_&& arg, Args_... args);
1021   ::std::string* PROTOBUF_NONNULL mutable_name();
1022   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
1023   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
1024
1025   private:
1026   const ::std::string& _internal_name() const;
1027   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
1028   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
1029
1030   public:
1031   // optional int32 elem_type = 2;
1032   bool has_elem_type() const;
1033   void clear_elem_type() ;
1034   ::int32_t elem_type() const;
1035   void set_elem_type(::int32_t value);
1036
1037   private:
1038   ::int32_t _internal_elem_type() const;
1039   void _internal_set_elem_type(::int32_t value);
1040
1041   public:
1042   // @@protoc_insertion_point(class_scope:onnx.SequenceProto)
1043  private:
1044   class _Internal;
1045   friend class ::google::protobuf::internal::TcParser;
1046   static const ::google::protobuf::internal::TcParseTable<3, 7,
1047                                    5, 31,
1048                                    2>
1049       _table_;
1050
1051   friend class ::google::protobuf::MessageLite;
1052   friend class ::google::protobuf::Arena;
1053   template <typename T>
1054   friend class ::google::protobuf::Arena::InternalHelper;
1055   using InternalArenaConstructable_ = void;
1056   using DestructorSkippable_ = void;
1057   struct Impl_ {
1058     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1059     inline explicit Impl_(
1060         ::google::protobuf::internal::InternalVisibility visibility,
1061         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1062     inline explicit Impl_(
1063         ::google::protobuf::internal::InternalVisibility visibility,
1064         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1065         const SequenceProto& from_msg);
1066     ::google::protobuf::internal::HasBits<1> _has_bits_;
1067     ::google::protobuf::internal::CachedSize _cached_size_;
1068     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensor_values_;
1069     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensor_values_;
1070     ::google::protobuf::RepeatedPtrField< ::onnx::SequenceProto > sequence_values_;
1071     ::google::protobuf::RepeatedPtrField< ::onnx::MapProto > map_values_;
1072     ::google::protobuf::RepeatedPtrField< ::onnx::OptionalProto > optional_values_;
1073     ::google::protobuf::internal::ArenaStringPtr name_;
1074     ::int32_t elem_type_;
1075     PROTOBUF_TSAN_DECLARE_MEMBER
1076   };
1077   union { Impl_ _impl_; };
1078   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
1079 };
1080
1081 ONNX_API extern const ::google::protobuf::internal::ClassDataFull SequenceProto_class_data_;
1082
1083 // ===================================================================
1084
1085
1086
1087
1088 // ===================================================================
1089
1090
1091 #ifdef __GNUC__
1092 #pragma GCC diagnostic push
1093 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1094 #endif  // __GNUC__
1095 // -------------------------------------------------------------------
1096
1097 // SequenceProto
1098
1099 // optional string name = 1;
1100 inline bool SequenceProto::has_name() const {
1101   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
1102   return value;
1103 }
1104 inline void SequenceProto::clear_name() {
1105   ::google::protobuf::internal::TSanWrite(&_impl_);
1106   _impl_.name_.ClearToEmpty();
1107   _impl_._has_bits_[0] &= ~0x00000001U;
1108 }
1109 inline const ::std::string& SequenceProto::name() const
1110     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1111   // @@protoc_insertion_point(field_get:onnx.SequenceProto.name)
1112   return _internal_name();
1113 }
1114 template <typename Arg_, typename... Args_>
1115 PROTOBUF_ALWAYS_INLINE void SequenceProto::set_name(Arg_&& arg, Args_... args) {
1116   ::google::protobuf::internal::TSanWrite(&_impl_);
1117   _impl_._has_bits_[0] |= 0x00000001U;
1118   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1119   // @@protoc_insertion_point(field_set:onnx.SequenceProto.name)
1120 }
1121 inline ::std::string* PROTOBUF_NONNULL SequenceProto::mutable_name()
1122     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1123   ::std::string* _s = _internal_mutable_name();
1124   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.name)
1125   return _s;
1126 }
1127 inline const ::std::string& SequenceProto::_internal_name() const {
1128   ::google::protobuf::internal::TSanRead(&_impl_);
1129   return _impl_.name_.Get();
1130 }
1131 inline void SequenceProto::_internal_set_name(const ::std::string& value) {
1132   ::google::protobuf::internal::TSanWrite(&_impl_);
1133   _impl_._has_bits_[0] |= 0x00000001U;
1134   _impl_.name_.Set(value, GetArena());
1135 }
1136 inline ::std::string* PROTOBUF_NONNULL SequenceProto::_internal_mutable_name() {
1137   ::google::protobuf::internal::TSanWrite(&_impl_);
1138   _impl_._has_bits_[0] |= 0x00000001U;
1139   return _impl_.name_.Mutable( GetArena());
1140 }
1141 inline ::std::string* PROTOBUF_NULLABLE SequenceProto::release_name() {
1142   ::google::protobuf::internal::TSanWrite(&_impl_);
1143   // @@protoc_insertion_point(field_release:onnx.SequenceProto.name)
1144   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
1145     return nullptr;
1146   }
1147   _impl_._has_bits_[0] &= ~0x00000001U;
1148   auto* released = _impl_.name_.Release();
1149   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
1150     _impl_.name_.Set("", GetArena());
1151   }
1152   return released;
1153 }
1154 inline void SequenceProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
1155   ::google::protobuf::internal::TSanWrite(&_impl_);
1156   if (value != nullptr) {
1157     _impl_._has_bits_[0] |= 0x00000001U;
1158   } else {
1159     _impl_._has_bits_[0] &= ~0x00000001U;
1160   }
1161   _impl_.name_.SetAllocated(value, GetArena());
1162   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
1163     _impl_.name_.Set("", GetArena());
1164   }
1165   // @@protoc_insertion_point(field_set_allocated:onnx.SequenceProto.name)
1166 }
1167
1168 // optional int32 elem_type = 2;
1169 inline bool SequenceProto::has_elem_type() const {
1170   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
1171   return value;
1172 }
1173 inline void SequenceProto::clear_elem_type() {
1174   ::google::protobuf::internal::TSanWrite(&_impl_);
1175   _impl_.elem_type_ = 0;
1176   _impl_._has_bits_[0] &= ~0x00000002U;
1177 }
1178 inline ::int32_t SequenceProto::elem_type() const {
1179   // @@protoc_insertion_point(field_get:onnx.SequenceProto.elem_type)
1180   return _internal_elem_type();
1181 }
1182 inline void SequenceProto::set_elem_type(::int32_t value) {
1183   _internal_set_elem_type(value);
1184   _impl_._has_bits_[0] |= 0x00000002U;
1185   // @@protoc_insertion_point(field_set:onnx.SequenceProto.elem_type)
1186 }
1187 inline ::int32_t SequenceProto::_internal_elem_type() const {
1188   ::google::protobuf::internal::TSanRead(&_impl_);
1189   return _impl_.elem_type_;
1190 }
1191 inline void SequenceProto::_internal_set_elem_type(::int32_t value) {
1192   ::google::protobuf::internal::TSanWrite(&_impl_);
1193   _impl_.elem_type_ = value;
1194 }
1195
1196 // repeated .onnx.TensorProto tensor_values = 3;
1197 inline int SequenceProto::_internal_tensor_values_size() const {
1198   return _internal_tensor_values().size();
1199 }
1200 inline int SequenceProto::tensor_values_size() const {
1201   return _internal_tensor_values_size();
1202 }
1203 inline ::onnx::TensorProto* PROTOBUF_NONNULL SequenceProto::mutable_tensor_values(int index)
1204     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1205   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.tensor_values)
1206   return _internal_mutable_tensor_values()->Mutable(index);
1207 }
1208 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL SequenceProto::mutable_tensor_values()
1209     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1210   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.tensor_values)
1211   ::google::protobuf::internal::TSanWrite(&_impl_);
1212   return _internal_mutable_tensor_values();
1213 }
1214 inline const ::onnx::TensorProto& SequenceProto::tensor_values(int index) const
1215     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1216   // @@protoc_insertion_point(field_get:onnx.SequenceProto.tensor_values)
1217   return _internal_tensor_values().Get(index);
1218 }
1219 inline ::onnx::TensorProto* PROTOBUF_NONNULL SequenceProto::add_tensor_values()
1220     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1221   ::google::protobuf::internal::TSanWrite(&_impl_);
1222   ::onnx::TensorProto* _add = _internal_mutable_tensor_values()->Add();
1223   // @@protoc_insertion_point(field_add:onnx.SequenceProto.tensor_values)
1224   return _add;
1225 }
1226 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& SequenceProto::tensor_values() const
1227     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1228   // @@protoc_insertion_point(field_list:onnx.SequenceProto.tensor_values)
1229   return _internal_tensor_values();
1230 }
1231 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
1232 SequenceProto::_internal_tensor_values() const {
1233   ::google::protobuf::internal::TSanRead(&_impl_);
1234   return _impl_.tensor_values_;
1235 }
1236 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
1237 SequenceProto::_internal_mutable_tensor_values() {
1238   ::google::protobuf::internal::TSanRead(&_impl_);
1239   return &_impl_.tensor_values_;
1240 }
1241
1242 // repeated .onnx.SparseTensorProto sparse_tensor_values = 4;
1243 inline int SequenceProto::_internal_sparse_tensor_values_size() const {
1244   return _internal_sparse_tensor_values().size();
1245 }
1246 inline int SequenceProto::sparse_tensor_values_size() const {
1247   return _internal_sparse_tensor_values_size();
1248 }
1249 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL SequenceProto::mutable_sparse_tensor_values(int index)
1250     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1251   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.sparse_tensor_values)
1252   return _internal_mutable_sparse_tensor_values()->Mutable(index);
1253 }
1254 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL SequenceProto::mutable_sparse_tensor_values()
1255     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1256   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.sparse_tensor_values)
1257   ::google::protobuf::internal::TSanWrite(&_impl_);
1258   return _internal_mutable_sparse_tensor_values();
1259 }
1260 inline const ::onnx::SparseTensorProto& SequenceProto::sparse_tensor_values(int index) const
1261     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1262   // @@protoc_insertion_point(field_get:onnx.SequenceProto.sparse_tensor_values)
1263   return _internal_sparse_tensor_values().Get(index);
1264 }
1265 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL SequenceProto::add_sparse_tensor_values()
1266     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1267   ::google::protobuf::internal::TSanWrite(&_impl_);
1268   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_tensor_values()->Add();
1269   // @@protoc_insertion_point(field_add:onnx.SequenceProto.sparse_tensor_values)
1270   return _add;
1271 }
1272 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& SequenceProto::sparse_tensor_values() const
1273     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1274   // @@protoc_insertion_point(field_list:onnx.SequenceProto.sparse_tensor_values)
1275   return _internal_sparse_tensor_values();
1276 }
1277 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
1278 SequenceProto::_internal_sparse_tensor_values() const {
1279   ::google::protobuf::internal::TSanRead(&_impl_);
1280   return _impl_.sparse_tensor_values_;
1281 }
1282 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
1283 SequenceProto::_internal_mutable_sparse_tensor_values() {
1284   ::google::protobuf::internal::TSanRead(&_impl_);
1285   return &_impl_.sparse_tensor_values_;
1286 }
1287
1288 // repeated .onnx.SequenceProto sequence_values = 5;
1289 inline int SequenceProto::_internal_sequence_values_size() const {
1290   return _internal_sequence_values().size();
1291 }
1292 inline int SequenceProto::sequence_values_size() const {
1293   return _internal_sequence_values_size();
1294 }
1295 inline void SequenceProto::clear_sequence_values() {
1296   ::google::protobuf::internal::TSanWrite(&_impl_);
1297   _impl_.sequence_values_.Clear();
1298 }
1299 inline ::onnx::SequenceProto* PROTOBUF_NONNULL SequenceProto::mutable_sequence_values(int index)
1300     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1301   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.sequence_values)
1302   return _internal_mutable_sequence_values()->Mutable(index);
1303 }
1304 inline ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* PROTOBUF_NONNULL SequenceProto::mutable_sequence_values()
1305     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1306   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.sequence_values)
1307   ::google::protobuf::internal::TSanWrite(&_impl_);
1308   return _internal_mutable_sequence_values();
1309 }
1310 inline const ::onnx::SequenceProto& SequenceProto::sequence_values(int index) const
1311     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1312   // @@protoc_insertion_point(field_get:onnx.SequenceProto.sequence_values)
1313   return _internal_sequence_values().Get(index);
1314 }
1315 inline ::onnx::SequenceProto* PROTOBUF_NONNULL SequenceProto::add_sequence_values()
1316     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1317   ::google::protobuf::internal::TSanWrite(&_impl_);
1318   ::onnx::SequenceProto* _add = _internal_mutable_sequence_values()->Add();
1319   // @@protoc_insertion_point(field_add:onnx.SequenceProto.sequence_values)
1320   return _add;
1321 }
1322 inline const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& SequenceProto::sequence_values() const
1323     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1324   // @@protoc_insertion_point(field_list:onnx.SequenceProto.sequence_values)
1325   return _internal_sequence_values();
1326 }
1327 inline const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>&
1328 SequenceProto::_internal_sequence_values() const {
1329   ::google::protobuf::internal::TSanRead(&_impl_);
1330   return _impl_.sequence_values_;
1331 }
1332 inline ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* PROTOBUF_NONNULL
1333 SequenceProto::_internal_mutable_sequence_values() {
1334   ::google::protobuf::internal::TSanRead(&_impl_);
1335   return &_impl_.sequence_values_;
1336 }
1337
1338 // repeated .onnx.MapProto map_values = 6;
1339 inline int SequenceProto::_internal_map_values_size() const {
1340   return _internal_map_values().size();
1341 }
1342 inline int SequenceProto::map_values_size() const {
1343   return _internal_map_values_size();
1344 }
1345 inline void SequenceProto::clear_map_values() {
1346   ::google::protobuf::internal::TSanWrite(&_impl_);
1347   _impl_.map_values_.Clear();
1348 }
1349 inline ::onnx::MapProto* PROTOBUF_NONNULL SequenceProto::mutable_map_values(int index)
1350     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1351   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.map_values)
1352   return _internal_mutable_map_values()->Mutable(index);
1353 }
1354 inline ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* PROTOBUF_NONNULL SequenceProto::mutable_map_values()
1355     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1356   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.map_values)
1357   ::google::protobuf::internal::TSanWrite(&_impl_);
1358   return _internal_mutable_map_values();
1359 }
1360 inline const ::onnx::MapProto& SequenceProto::map_values(int index) const
1361     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1362   // @@protoc_insertion_point(field_get:onnx.SequenceProto.map_values)
1363   return _internal_map_values().Get(index);
1364 }
1365 inline ::onnx::MapProto* PROTOBUF_NONNULL SequenceProto::add_map_values()
1366     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1367   ::google::protobuf::internal::TSanWrite(&_impl_);
1368   ::onnx::MapProto* _add = _internal_mutable_map_values()->Add();
1369   // @@protoc_insertion_point(field_add:onnx.SequenceProto.map_values)
1370   return _add;
1371 }
1372 inline const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& SequenceProto::map_values() const
1373     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1374   // @@protoc_insertion_point(field_list:onnx.SequenceProto.map_values)
1375   return _internal_map_values();
1376 }
1377 inline const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>&
1378 SequenceProto::_internal_map_values() const {
1379   ::google::protobuf::internal::TSanRead(&_impl_);
1380   return _impl_.map_values_;
1381 }
1382 inline ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* PROTOBUF_NONNULL
1383 SequenceProto::_internal_mutable_map_values() {
1384   ::google::protobuf::internal::TSanRead(&_impl_);
1385   return &_impl_.map_values_;
1386 }
1387
1388 // repeated .onnx.OptionalProto optional_values = 7;
1389 inline int SequenceProto::_internal_optional_values_size() const {
1390   return _internal_optional_values().size();
1391 }
1392 inline int SequenceProto::optional_values_size() const {
1393   return _internal_optional_values_size();
1394 }
1395 inline void SequenceProto::clear_optional_values() {
1396   ::google::protobuf::internal::TSanWrite(&_impl_);
1397   _impl_.optional_values_.Clear();
1398 }
1399 inline ::onnx::OptionalProto* PROTOBUF_NONNULL SequenceProto::mutable_optional_values(int index)
1400     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1401   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.optional_values)
1402   return _internal_mutable_optional_values()->Mutable(index);
1403 }
1404 inline ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* PROTOBUF_NONNULL SequenceProto::mutable_optional_values()
1405     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1406   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.optional_values)
1407   ::google::protobuf::internal::TSanWrite(&_impl_);
1408   return _internal_mutable_optional_values();
1409 }
1410 inline const ::onnx::OptionalProto& SequenceProto::optional_values(int index) const
1411     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1412   // @@protoc_insertion_point(field_get:onnx.SequenceProto.optional_values)
1413   return _internal_optional_values().Get(index);
1414 }
1415 inline ::onnx::OptionalProto* PROTOBUF_NONNULL SequenceProto::add_optional_values()
1416     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1417   ::google::protobuf::internal::TSanWrite(&_impl_);
1418   ::onnx::OptionalProto* _add = _internal_mutable_optional_values()->Add();
1419   // @@protoc_insertion_point(field_add:onnx.SequenceProto.optional_values)
1420   return _add;
1421 }
1422 inline const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& SequenceProto::optional_values() const
1423     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1424   // @@protoc_insertion_point(field_list:onnx.SequenceProto.optional_values)
1425   return _internal_optional_values();
1426 }
1427 inline const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>&
1428 SequenceProto::_internal_optional_values() const {
1429   ::google::protobuf::internal::TSanRead(&_impl_);
1430   return _impl_.optional_values_;
1431 }
1432 inline ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* PROTOBUF_NONNULL
1433 SequenceProto::_internal_mutable_optional_values() {
1434   ::google::protobuf::internal::TSanRead(&_impl_);
1435   return &_impl_.optional_values_;
1436 }
1437
1438 // -------------------------------------------------------------------
1439
1440 // MapProto
1441
1442 // optional string name = 1;
1443 inline bool MapProto::has_name() const {
1444   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
1445   return value;
1446 }
1447 inline void MapProto::clear_name() {
1448   ::google::protobuf::internal::TSanWrite(&_impl_);
1449   _impl_.name_.ClearToEmpty();
1450   _impl_._has_bits_[0] &= ~0x00000001U;
1451 }
1452 inline const ::std::string& MapProto::name() const
1453     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1454   // @@protoc_insertion_point(field_get:onnx.MapProto.name)
1455   return _internal_name();
1456 }
1457 template <typename Arg_, typename... Args_>
1458 PROTOBUF_ALWAYS_INLINE void MapProto::set_name(Arg_&& arg, Args_... args) {
1459   ::google::protobuf::internal::TSanWrite(&_impl_);
1460   _impl_._has_bits_[0] |= 0x00000001U;
1461   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1462   // @@protoc_insertion_point(field_set:onnx.MapProto.name)
1463 }
1464 inline ::std::string* PROTOBUF_NONNULL MapProto::mutable_name()
1465     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1466   ::std::string* _s = _internal_mutable_name();
1467   // @@protoc_insertion_point(field_mutable:onnx.MapProto.name)
1468   return _s;
1469 }
1470 inline const ::std::string& MapProto::_internal_name() const {
1471   ::google::protobuf::internal::TSanRead(&_impl_);
1472   return _impl_.name_.Get();
1473 }
1474 inline void MapProto::_internal_set_name(const ::std::string& value) {
1475   ::google::protobuf::internal::TSanWrite(&_impl_);
1476   _impl_._has_bits_[0] |= 0x00000001U;
1477   _impl_.name_.Set(value, GetArena());
1478 }
1479 inline ::std::string* PROTOBUF_NONNULL MapProto::_internal_mutable_name() {
1480   ::google::protobuf::internal::TSanWrite(&_impl_);
1481   _impl_._has_bits_[0] |= 0x00000001U;
1482   return _impl_.name_.Mutable( GetArena());
1483 }
1484 inline ::std::string* PROTOBUF_NULLABLE MapProto::release_name() {
1485   ::google::protobuf::internal::TSanWrite(&_impl_);
1486   // @@protoc_insertion_point(field_release:onnx.MapProto.name)
1487   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
1488     return nullptr;
1489   }
1490   _impl_._has_bits_[0] &= ~0x00000001U;
1491   auto* released = _impl_.name_.Release();
1492   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
1493     _impl_.name_.Set("", GetArena());
1494   }
1495   return released;
1496 }
1497 inline void MapProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
1498   ::google::protobuf::internal::TSanWrite(&_impl_);
1499   if (value != nullptr) {
1500     _impl_._has_bits_[0] |= 0x00000001U;
1501   } else {
1502     _impl_._has_bits_[0] &= ~0x00000001U;
1503   }
1504   _impl_.name_.SetAllocated(value, GetArena());
1505   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
1506     _impl_.name_.Set("", GetArena());
1507   }
1508   // @@protoc_insertion_point(field_set_allocated:onnx.MapProto.name)
1509 }
1510
1511 // optional int32 key_type = 2;
1512 inline bool MapProto::has_key_type() const {
1513   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
1514   return value;
1515 }
1516 inline void MapProto::clear_key_type() {
1517   ::google::protobuf::internal::TSanWrite(&_impl_);
1518   _impl_.key_type_ = 0;
1519   _impl_._has_bits_[0] &= ~0x00000004U;
1520 }
1521 inline ::int32_t MapProto::key_type() const {
1522   // @@protoc_insertion_point(field_get:onnx.MapProto.key_type)
1523   return _internal_key_type();
1524 }
1525 inline void MapProto::set_key_type(::int32_t value) {
1526   _internal_set_key_type(value);
1527   _impl_._has_bits_[0] |= 0x00000004U;
1528   // @@protoc_insertion_point(field_set:onnx.MapProto.key_type)
1529 }
1530 inline ::int32_t MapProto::_internal_key_type() const {
1531   ::google::protobuf::internal::TSanRead(&_impl_);
1532   return _impl_.key_type_;
1533 }
1534 inline void MapProto::_internal_set_key_type(::int32_t value) {
1535   ::google::protobuf::internal::TSanWrite(&_impl_);
1536   _impl_.key_type_ = value;
1537 }
1538
1539 // repeated int64 keys = 3;
1540 inline int MapProto::_internal_keys_size() const {
1541   return _internal_keys().size();
1542 }
1543 inline int MapProto::keys_size() const {
1544   return _internal_keys_size();
1545 }
1546 inline void MapProto::clear_keys() {
1547   ::google::protobuf::internal::TSanWrite(&_impl_);
1548   _impl_.keys_.Clear();
1549 }
1550 inline ::int64_t MapProto::keys(int index) const {
1551   // @@protoc_insertion_point(field_get:onnx.MapProto.keys)
1552   return _internal_keys().Get(index);
1553 }
1554 inline void MapProto::set_keys(int index, ::int64_t value) {
1555   _internal_mutable_keys()->Set(index, value);
1556   // @@protoc_insertion_point(field_set:onnx.MapProto.keys)
1557 }
1558 inline void MapProto::add_keys(::int64_t value) {
1559   ::google::protobuf::internal::TSanWrite(&_impl_);
1560   _internal_mutable_keys()->Add(value);
1561   // @@protoc_insertion_point(field_add:onnx.MapProto.keys)
1562 }
1563 inline const ::google::protobuf::RepeatedField<::int64_t>& MapProto::keys() const
1564     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1565   // @@protoc_insertion_point(field_list:onnx.MapProto.keys)
1566   return _internal_keys();
1567 }
1568 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL MapProto::mutable_keys()
1569     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1570   // @@protoc_insertion_point(field_mutable_list:onnx.MapProto.keys)
1571   ::google::protobuf::internal::TSanWrite(&_impl_);
1572   return _internal_mutable_keys();
1573 }
1574 inline const ::google::protobuf::RepeatedField<::int64_t>&
1575 MapProto::_internal_keys() const {
1576   ::google::protobuf::internal::TSanRead(&_impl_);
1577   return _impl_.keys_;
1578 }
1579 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
1580 MapProto::_internal_mutable_keys() {
1581   ::google::protobuf::internal::TSanRead(&_impl_);
1582   return &_impl_.keys_;
1583 }
1584
1585 // repeated bytes string_keys = 4;
1586 inline int MapProto::_internal_string_keys_size() const {
1587   return _internal_string_keys().size();
1588 }
1589 inline int MapProto::string_keys_size() const {
1590   return _internal_string_keys_size();
1591 }
1592 inline void MapProto::clear_string_keys() {
1593   ::google::protobuf::internal::TSanWrite(&_impl_);
1594   _impl_.string_keys_.Clear();
1595 }
1596 inline ::std::string* PROTOBUF_NONNULL MapProto::add_string_keys()
1597     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1598   ::google::protobuf::internal::TSanWrite(&_impl_);
1599   ::std::string* _s = _internal_mutable_string_keys()->Add();
1600   // @@protoc_insertion_point(field_add_mutable:onnx.MapProto.string_keys)
1601   return _s;
1602 }
1603 inline const ::std::string& MapProto::string_keys(int index) const
1604     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1605   // @@protoc_insertion_point(field_get:onnx.MapProto.string_keys)
1606   return _internal_string_keys().Get(index);
1607 }
1608 inline ::std::string* PROTOBUF_NONNULL MapProto::mutable_string_keys(int index)
1609     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1610   // @@protoc_insertion_point(field_mutable:onnx.MapProto.string_keys)
1611   return _internal_mutable_string_keys()->Mutable(index);
1612 }
1613 template <typename Arg_, typename... Args_>
1614 inline void MapProto::set_string_keys(int index, Arg_&& value, Args_... args) {
1615   ::google::protobuf::internal::AssignToString(*_internal_mutable_string_keys()->Mutable(index), ::std::forward<Arg_>(value),
1616                         args... , ::google::protobuf::internal::BytesTag{});
1617   // @@protoc_insertion_point(field_set:onnx.MapProto.string_keys)
1618 }
1619 template <typename Arg_, typename... Args_>
1620 inline void MapProto::add_string_keys(Arg_&& value, Args_... args) {
1621   ::google::protobuf::internal::TSanWrite(&_impl_);
1622   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_string_keys(),
1623                                ::std::forward<Arg_>(value),
1624                                args... , ::google::protobuf::internal::BytesTag{});
1625   // @@protoc_insertion_point(field_add:onnx.MapProto.string_keys)
1626 }
1627 inline const ::google::protobuf::RepeatedPtrField<::std::string>& MapProto::string_keys()
1628     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1629   // @@protoc_insertion_point(field_list:onnx.MapProto.string_keys)
1630   return _internal_string_keys();
1631 }
1632 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
1633 MapProto::mutable_string_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1634   // @@protoc_insertion_point(field_mutable_list:onnx.MapProto.string_keys)
1635   ::google::protobuf::internal::TSanWrite(&_impl_);
1636   return _internal_mutable_string_keys();
1637 }
1638 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
1639 MapProto::_internal_string_keys() const {
1640   ::google::protobuf::internal::TSanRead(&_impl_);
1641   return _impl_.string_keys_;
1642 }
1643 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
1644 MapProto::_internal_mutable_string_keys() {
1645   ::google::protobuf::internal::TSanRead(&_impl_);
1646   return &_impl_.string_keys_;
1647 }
1648
1649 // optional .onnx.SequenceProto values = 5;
1650 inline bool MapProto::has_values() const {
1651   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
1652   PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
1653   return value;
1654 }
1655 inline void MapProto::clear_values() {
1656   ::google::protobuf::internal::TSanWrite(&_impl_);
1657   if (_impl_.values_ != nullptr) _impl_.values_->Clear();
1658   _impl_._has_bits_[0] &= ~0x00000002U;
1659 }
1660 inline const ::onnx::SequenceProto& MapProto::_internal_values() const {
1661   ::google::protobuf::internal::TSanRead(&_impl_);
1662   const ::onnx::SequenceProto* p = _impl_.values_;
1663   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SequenceProto&>(::onnx::_SequenceProto_default_instance_);
1664 }
1665 inline const ::onnx::SequenceProto& MapProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1666   // @@protoc_insertion_point(field_get:onnx.MapProto.values)
1667   return _internal_values();
1668 }
1669 inline void MapProto::unsafe_arena_set_allocated_values(
1670     ::onnx::SequenceProto* PROTOBUF_NULLABLE value) {
1671   ::google::protobuf::internal::TSanWrite(&_impl_);
1672   if (GetArena() == nullptr) {
1673     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
1674   }
1675   _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(value);
1676   if (value != nullptr) {
1677     _impl_._has_bits_[0] |= 0x00000002U;
1678   } else {
1679     _impl_._has_bits_[0] &= ~0x00000002U;
1680   }
1681   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.MapProto.values)
1682 }
1683 inline ::onnx::SequenceProto* PROTOBUF_NULLABLE MapProto::release_values() {
1684   ::google::protobuf::internal::TSanWrite(&_impl_);
1685
1686   _impl_._has_bits_[0] &= ~0x00000002U;
1687   ::onnx::SequenceProto* released = _impl_.values_;
1688   _impl_.values_ = nullptr;
1689   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
1690     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1691     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1692     if (GetArena() == nullptr) {
1693       delete old;
1694     }
1695   } else {
1696     if (GetArena() != nullptr) {
1697       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1698     }
1699   }
1700   return released;
1701 }
1702 inline ::onnx::SequenceProto* PROTOBUF_NULLABLE MapProto::unsafe_arena_release_values() {
1703   ::google::protobuf::internal::TSanWrite(&_impl_);
1704   // @@protoc_insertion_point(field_release:onnx.MapProto.values)
1705
1706   _impl_._has_bits_[0] &= ~0x00000002U;
1707   ::onnx::SequenceProto* temp = _impl_.values_;
1708   _impl_.values_ = nullptr;
1709   return temp;
1710 }
1711 inline ::onnx::SequenceProto* PROTOBUF_NONNULL MapProto::_internal_mutable_values() {
1712   ::google::protobuf::internal::TSanWrite(&_impl_);
1713   if (_impl_.values_ == nullptr) {
1714     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SequenceProto>(GetArena());
1715     _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(p);
1716   }
1717   return _impl_.values_;
1718 }
1719 inline ::onnx::SequenceProto* PROTOBUF_NONNULL MapProto::mutable_values()
1720     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1721   _impl_._has_bits_[0] |= 0x00000002U;
1722   ::onnx::SequenceProto* _msg = _internal_mutable_values();
1723   // @@protoc_insertion_point(field_mutable:onnx.MapProto.values)
1724   return _msg;
1725 }
1726 inline void MapProto::set_allocated_values(::onnx::SequenceProto* PROTOBUF_NULLABLE value) {
1727   ::google::protobuf::Arena* message_arena = GetArena();
1728   ::google::protobuf::internal::TSanWrite(&_impl_);
1729   if (message_arena == nullptr) {
1730     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
1731   }
1732
1733   if (value != nullptr) {
1734     ::google::protobuf::Arena* submessage_arena = value->GetArena();
1735     if (message_arena != submessage_arena) {
1736       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
1737     }
1738     _impl_._has_bits_[0] |= 0x00000002U;
1739   } else {
1740     _impl_._has_bits_[0] &= ~0x00000002U;
1741   }
1742
1743   _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(value);
1744   // @@protoc_insertion_point(field_set_allocated:onnx.MapProto.values)
1745 }
1746
1747 // -------------------------------------------------------------------
1748
1749 // OptionalProto
1750
1751 // optional string name = 1;
1752 inline bool OptionalProto::has_name() const {
1753   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
1754   return value;
1755 }
1756 inline void OptionalProto::clear_name() {
1757   ::google::protobuf::internal::TSanWrite(&_impl_);
1758   _impl_.name_.ClearToEmpty();
1759   _impl_._has_bits_[0] &= ~0x00000001U;
1760 }
1761 inline const ::std::string& OptionalProto::name() const
1762     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1763   // @@protoc_insertion_point(field_get:onnx.OptionalProto.name)
1764   return _internal_name();
1765 }
1766 template <typename Arg_, typename... Args_>
1767 PROTOBUF_ALWAYS_INLINE void OptionalProto::set_name(Arg_&& arg, Args_... args) {
1768   ::google::protobuf::internal::TSanWrite(&_impl_);
1769   _impl_._has_bits_[0] |= 0x00000001U;
1770   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1771   // @@protoc_insertion_point(field_set:onnx.OptionalProto.name)
1772 }
1773 inline ::std::string* PROTOBUF_NONNULL OptionalProto::mutable_name()
1774     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1775   ::std::string* _s = _internal_mutable_name();
1776   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.name)
1777   return _s;
1778 }
1779 inline const ::std::string& OptionalProto::_internal_name() const {
1780   ::google::protobuf::internal::TSanRead(&_impl_);
1781   return _impl_.name_.Get();
1782 }
1783 inline void OptionalProto::_internal_set_name(const ::std::string& value) {
1784   ::google::protobuf::internal::TSanWrite(&_impl_);
1785   _impl_._has_bits_[0] |= 0x00000001U;
1786   _impl_.name_.Set(value, GetArena());
1787 }
1788 inline ::std::string* PROTOBUF_NONNULL OptionalProto::_internal_mutable_name() {
1789   ::google::protobuf::internal::TSanWrite(&_impl_);
1790   _impl_._has_bits_[0] |= 0x00000001U;
1791   return _impl_.name_.Mutable( GetArena());
1792 }
1793 inline ::std::string* PROTOBUF_NULLABLE OptionalProto::release_name() {
1794   ::google::protobuf::internal::TSanWrite(&_impl_);
1795   // @@protoc_insertion_point(field_release:onnx.OptionalProto.name)
1796   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
1797     return nullptr;
1798   }
1799   _impl_._has_bits_[0] &= ~0x00000001U;
1800   auto* released = _impl_.name_.Release();
1801   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
1802     _impl_.name_.Set("", GetArena());
1803   }
1804   return released;
1805 }
1806 inline void OptionalProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
1807   ::google::protobuf::internal::TSanWrite(&_impl_);
1808   if (value != nullptr) {
1809     _impl_._has_bits_[0] |= 0x00000001U;
1810   } else {
1811     _impl_._has_bits_[0] &= ~0x00000001U;
1812   }
1813   _impl_.name_.SetAllocated(value, GetArena());
1814   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
1815     _impl_.name_.Set("", GetArena());
1816   }
1817   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.name)
1818 }
1819
1820 // optional int32 elem_type = 2;
1821 inline bool OptionalProto::has_elem_type() const {
1822   bool value = (_impl_._has_bits_[0] & 0x00000040U) != 0;
1823   return value;
1824 }
1825 inline void OptionalProto::clear_elem_type() {
1826   ::google::protobuf::internal::TSanWrite(&_impl_);
1827   _impl_.elem_type_ = 0;
1828   _impl_._has_bits_[0] &= ~0x00000040U;
1829 }
1830 inline ::int32_t OptionalProto::elem_type() const {
1831   // @@protoc_insertion_point(field_get:onnx.OptionalProto.elem_type)
1832   return _internal_elem_type();
1833 }
1834 inline void OptionalProto::set_elem_type(::int32_t value) {
1835   _internal_set_elem_type(value);
1836   _impl_._has_bits_[0] |= 0x00000040U;
1837   // @@protoc_insertion_point(field_set:onnx.OptionalProto.elem_type)
1838 }
1839 inline ::int32_t OptionalProto::_internal_elem_type() const {
1840   ::google::protobuf::internal::TSanRead(&_impl_);
1841   return _impl_.elem_type_;
1842 }
1843 inline void OptionalProto::_internal_set_elem_type(::int32_t value) {
1844   ::google::protobuf::internal::TSanWrite(&_impl_);
1845   _impl_.elem_type_ = value;
1846 }
1847
1848 // optional .onnx.TensorProto tensor_value = 3;
1849 inline bool OptionalProto::has_tensor_value() const {
1850   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
1851   PROTOBUF_ASSUME(!value || _impl_.tensor_value_ != nullptr);
1852   return value;
1853 }
1854 inline const ::onnx::TensorProto& OptionalProto::_internal_tensor_value() const {
1855   ::google::protobuf::internal::TSanRead(&_impl_);
1856   const ::onnx::TensorProto* p = _impl_.tensor_value_;
1857   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
1858 }
1859 inline const ::onnx::TensorProto& OptionalProto::tensor_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1860   // @@protoc_insertion_point(field_get:onnx.OptionalProto.tensor_value)
1861   return _internal_tensor_value();
1862 }
1863 inline void OptionalProto::unsafe_arena_set_allocated_tensor_value(
1864     ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
1865   ::google::protobuf::internal::TSanWrite(&_impl_);
1866   if (GetArena() == nullptr) {
1867     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tensor_value_);
1868   }
1869   _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(value);
1870   if (value != nullptr) {
1871     _impl_._has_bits_[0] |= 0x00000002U;
1872   } else {
1873     _impl_._has_bits_[0] &= ~0x00000002U;
1874   }
1875   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.tensor_value)
1876 }
1877 inline ::onnx::TensorProto* PROTOBUF_NULLABLE OptionalProto::release_tensor_value() {
1878   ::google::protobuf::internal::TSanWrite(&_impl_);
1879
1880   _impl_._has_bits_[0] &= ~0x00000002U;
1881   ::onnx::TensorProto* released = _impl_.tensor_value_;
1882   _impl_.tensor_value_ = nullptr;
1883   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
1884     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1885     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1886     if (GetArena() == nullptr) {
1887       delete old;
1888     }
1889   } else {
1890     if (GetArena() != nullptr) {
1891       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1892     }
1893   }
1894   return released;
1895 }
1896 inline ::onnx::TensorProto* PROTOBUF_NULLABLE OptionalProto::unsafe_arena_release_tensor_value() {
1897   ::google::protobuf::internal::TSanWrite(&_impl_);
1898   // @@protoc_insertion_point(field_release:onnx.OptionalProto.tensor_value)
1899
1900   _impl_._has_bits_[0] &= ~0x00000002U;
1901   ::onnx::TensorProto* temp = _impl_.tensor_value_;
1902   _impl_.tensor_value_ = nullptr;
1903   return temp;
1904 }
1905 inline ::onnx::TensorProto* PROTOBUF_NONNULL OptionalProto::_internal_mutable_tensor_value() {
1906   ::google::protobuf::internal::TSanWrite(&_impl_);
1907   if (_impl_.tensor_value_ == nullptr) {
1908     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
1909     _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(p);
1910   }
1911   return _impl_.tensor_value_;
1912 }
1913 inline ::onnx::TensorProto* PROTOBUF_NONNULL OptionalProto::mutable_tensor_value()
1914     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1915   _impl_._has_bits_[0] |= 0x00000002U;
1916   ::onnx::TensorProto* _msg = _internal_mutable_tensor_value();
1917   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.tensor_value)
1918   return _msg;
1919 }
1920 inline void OptionalProto::set_allocated_tensor_value(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
1921   ::google::protobuf::Arena* message_arena = GetArena();
1922   ::google::protobuf::internal::TSanWrite(&_impl_);
1923   if (message_arena == nullptr) {
1924     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tensor_value_);
1925   }
1926
1927   if (value != nullptr) {
1928     ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
1929     if (message_arena != submessage_arena) {
1930       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
1931     }
1932     _impl_._has_bits_[0] |= 0x00000002U;
1933   } else {
1934     _impl_._has_bits_[0] &= ~0x00000002U;
1935   }
1936
1937   _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(value);
1938   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.tensor_value)
1939 }
1940
1941 // optional .onnx.SparseTensorProto sparse_tensor_value = 4;
1942 inline bool OptionalProto::has_sparse_tensor_value() const {
1943   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
1944   PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_value_ != nullptr);
1945   return value;
1946 }
1947 inline const ::onnx::SparseTensorProto& OptionalProto::_internal_sparse_tensor_value() const {
1948   ::google::protobuf::internal::TSanRead(&_impl_);
1949   const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_value_;
1950   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
1951 }
1952 inline const ::onnx::SparseTensorProto& OptionalProto::sparse_tensor_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1953   // @@protoc_insertion_point(field_get:onnx.OptionalProto.sparse_tensor_value)
1954   return _internal_sparse_tensor_value();
1955 }
1956 inline void OptionalProto::unsafe_arena_set_allocated_sparse_tensor_value(
1957     ::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
1958   ::google::protobuf::internal::TSanWrite(&_impl_);
1959   if (GetArena() == nullptr) {
1960     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_value_);
1961   }
1962   _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
1963   if (value != nullptr) {
1964     _impl_._has_bits_[0] |= 0x00000004U;
1965   } else {
1966     _impl_._has_bits_[0] &= ~0x00000004U;
1967   }
1968   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.sparse_tensor_value)
1969 }
1970 inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE OptionalProto::release_sparse_tensor_value() {
1971   ::google::protobuf::internal::TSanWrite(&_impl_);
1972
1973   _impl_._has_bits_[0] &= ~0x00000004U;
1974   ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_value_;
1975   _impl_.sparse_tensor_value_ = nullptr;
1976   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
1977     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1978     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1979     if (GetArena() == nullptr) {
1980       delete old;
1981     }
1982   } else {
1983     if (GetArena() != nullptr) {
1984       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1985     }
1986   }
1987   return released;
1988 }
1989 inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE OptionalProto::unsafe_arena_release_sparse_tensor_value() {
1990   ::google::protobuf::internal::TSanWrite(&_impl_);
1991   // @@protoc_insertion_point(field_release:onnx.OptionalProto.sparse_tensor_value)
1992
1993   _impl_._has_bits_[0] &= ~0x00000004U;
1994   ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_value_;
1995   _impl_.sparse_tensor_value_ = nullptr;
1996   return temp;
1997 }
1998 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL OptionalProto::_internal_mutable_sparse_tensor_value() {
1999   ::google::protobuf::internal::TSanWrite(&_impl_);
2000   if (_impl_.sparse_tensor_value_ == nullptr) {
2001     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
2002     _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
2003   }
2004   return _impl_.sparse_tensor_value_;
2005 }
2006 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL OptionalProto::mutable_sparse_tensor_value()
2007     ABSL_ATTRIBUTE_LIFETIME_BOUND {
2008   _impl_._has_bits_[0] |= 0x00000004U;
2009   ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor_value();
2010   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.sparse_tensor_value)
2011   return _msg;
2012 }
2013 inline void OptionalProto::set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
2014   ::google::protobuf::Arena* message_arena = GetArena();
2015   ::google::protobuf::internal::TSanWrite(&_impl_);
2016   if (message_arena == nullptr) {
2017     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_value_);
2018   }
2019
2020   if (value != nullptr) {
2021     ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
2022     if (message_arena != submessage_arena) {
2023       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2024     }
2025     _impl_._has_bits_[0] |= 0x00000004U;
2026   } else {
2027     _impl_._has_bits_[0] &= ~0x00000004U;
2028   }
2029
2030   _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
2031   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.sparse_tensor_value)
2032 }
2033
2034 // optional .onnx.SequenceProto sequence_value = 5;
2035 inline bool OptionalProto::has_sequence_value() const {
2036   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
2037   PROTOBUF_ASSUME(!value || _impl_.sequence_value_ != nullptr);
2038   return value;
2039 }
2040 inline void OptionalProto::clear_sequence_value() {
2041   ::google::protobuf::internal::TSanWrite(&_impl_);
2042   if (_impl_.sequence_value_ != nullptr) _impl_.sequence_value_->Clear();
2043   _impl_._has_bits_[0] &= ~0x00000008U;
2044 }
2045 inline const ::onnx::SequenceProto& OptionalProto::_internal_sequence_value() const {
2046   ::google::protobuf::internal::TSanRead(&_impl_);
2047   const ::onnx::SequenceProto* p = _impl_.sequence_value_;
2048   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SequenceProto&>(::onnx::_SequenceProto_default_instance_);
2049 }
2050 inline const ::onnx::SequenceProto& OptionalProto::sequence_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2051   // @@protoc_insertion_point(field_get:onnx.OptionalProto.sequence_value)
2052   return _internal_sequence_value();
2053 }
2054 inline void OptionalProto::unsafe_arena_set_allocated_sequence_value(
2055     ::onnx::SequenceProto* PROTOBUF_NULLABLE value) {
2056   ::google::protobuf::internal::TSanWrite(&_impl_);
2057   if (GetArena() == nullptr) {
2058     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sequence_value_);
2059   }
2060   _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(value);
2061   if (value != nullptr) {
2062     _impl_._has_bits_[0] |= 0x00000008U;
2063   } else {
2064     _impl_._has_bits_[0] &= ~0x00000008U;
2065   }
2066   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.sequence_value)
2067 }
2068 inline ::onnx::SequenceProto* PROTOBUF_NULLABLE OptionalProto::release_sequence_value() {
2069   ::google::protobuf::internal::TSanWrite(&_impl_);
2070
2071   _impl_._has_bits_[0] &= ~0x00000008U;
2072   ::onnx::SequenceProto* released = _impl_.sequence_value_;
2073   _impl_.sequence_value_ = nullptr;
2074   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
2075     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2076     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2077     if (GetArena() == nullptr) {
2078       delete old;
2079     }
2080   } else {
2081     if (GetArena() != nullptr) {
2082       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2083     }
2084   }
2085   return released;
2086 }
2087 inline ::onnx::SequenceProto* PROTOBUF_NULLABLE OptionalProto::unsafe_arena_release_sequence_value() {
2088   ::google::protobuf::internal::TSanWrite(&_impl_);
2089   // @@protoc_insertion_point(field_release:onnx.OptionalProto.sequence_value)
2090
2091   _impl_._has_bits_[0] &= ~0x00000008U;
2092   ::onnx::SequenceProto* temp = _impl_.sequence_value_;
2093   _impl_.sequence_value_ = nullptr;
2094   return temp;
2095 }
2096 inline ::onnx::SequenceProto* PROTOBUF_NONNULL OptionalProto::_internal_mutable_sequence_value() {
2097   ::google::protobuf::internal::TSanWrite(&_impl_);
2098   if (_impl_.sequence_value_ == nullptr) {
2099     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SequenceProto>(GetArena());
2100     _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(p);
2101   }
2102   return _impl_.sequence_value_;
2103 }
2104 inline ::onnx::SequenceProto* PROTOBUF_NONNULL OptionalProto::mutable_sequence_value()
2105     ABSL_ATTRIBUTE_LIFETIME_BOUND {
2106   _impl_._has_bits_[0] |= 0x00000008U;
2107   ::onnx::SequenceProto* _msg = _internal_mutable_sequence_value();
2108   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.sequence_value)
2109   return _msg;
2110 }
2111 inline void OptionalProto::set_allocated_sequence_value(::onnx::SequenceProto* PROTOBUF_NULLABLE value) {
2112   ::google::protobuf::Arena* message_arena = GetArena();
2113   ::google::protobuf::internal::TSanWrite(&_impl_);
2114   if (message_arena == nullptr) {
2115     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sequence_value_);
2116   }
2117
2118   if (value != nullptr) {
2119     ::google::protobuf::Arena* submessage_arena = value->GetArena();
2120     if (message_arena != submessage_arena) {
2121       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2122     }
2123     _impl_._has_bits_[0] |= 0x00000008U;
2124   } else {
2125     _impl_._has_bits_[0] &= ~0x00000008U;
2126   }
2127
2128   _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(value);
2129   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.sequence_value)
2130 }
2131
2132 // optional .onnx.MapProto map_value = 6;
2133 inline bool OptionalProto::has_map_value() const {
2134   bool value = (_impl_._has_bits_[0] & 0x00000010U) != 0;
2135   PROTOBUF_ASSUME(!value || _impl_.map_value_ != nullptr);
2136   return value;
2137 }
2138 inline void OptionalProto::clear_map_value() {
2139   ::google::protobuf::internal::TSanWrite(&_impl_);
2140   if (_impl_.map_value_ != nullptr) _impl_.map_value_->Clear();
2141   _impl_._has_bits_[0] &= ~0x00000010U;
2142 }
2143 inline const ::onnx::MapProto& OptionalProto::_internal_map_value() const {
2144   ::google::protobuf::internal::TSanRead(&_impl_);
2145   const ::onnx::MapProto* p = _impl_.map_value_;
2146   return p != nullptr ? *p : reinterpret_cast<const ::onnx::MapProto&>(::onnx::_MapProto_default_instance_);
2147 }
2148 inline const ::onnx::MapProto& OptionalProto::map_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2149   // @@protoc_insertion_point(field_get:onnx.OptionalProto.map_value)
2150   return _internal_map_value();
2151 }
2152 inline void OptionalProto::unsafe_arena_set_allocated_map_value(
2153     ::onnx::MapProto* PROTOBUF_NULLABLE value) {
2154   ::google::protobuf::internal::TSanWrite(&_impl_);
2155   if (GetArena() == nullptr) {
2156     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.map_value_);
2157   }
2158   _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(value);
2159   if (value != nullptr) {
2160     _impl_._has_bits_[0] |= 0x00000010U;
2161   } else {
2162     _impl_._has_bits_[0] &= ~0x00000010U;
2163   }
2164   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.map_value)
2165 }
2166 inline ::onnx::MapProto* PROTOBUF_NULLABLE OptionalProto::release_map_value() {
2167   ::google::protobuf::internal::TSanWrite(&_impl_);
2168
2169   _impl_._has_bits_[0] &= ~0x00000010U;
2170   ::onnx::MapProto* released = _impl_.map_value_;
2171   _impl_.map_value_ = nullptr;
2172   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
2173     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2174     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2175     if (GetArena() == nullptr) {
2176       delete old;
2177     }
2178   } else {
2179     if (GetArena() != nullptr) {
2180       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2181     }
2182   }
2183   return released;
2184 }
2185 inline ::onnx::MapProto* PROTOBUF_NULLABLE OptionalProto::unsafe_arena_release_map_value() {
2186   ::google::protobuf::internal::TSanWrite(&_impl_);
2187   // @@protoc_insertion_point(field_release:onnx.OptionalProto.map_value)
2188
2189   _impl_._has_bits_[0] &= ~0x00000010U;
2190   ::onnx::MapProto* temp = _impl_.map_value_;
2191   _impl_.map_value_ = nullptr;
2192   return temp;
2193 }
2194 inline ::onnx::MapProto* PROTOBUF_NONNULL OptionalProto::_internal_mutable_map_value() {
2195   ::google::protobuf::internal::TSanWrite(&_impl_);
2196   if (_impl_.map_value_ == nullptr) {
2197     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::MapProto>(GetArena());
2198     _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(p);
2199   }
2200   return _impl_.map_value_;
2201 }
2202 inline ::onnx::MapProto* PROTOBUF_NONNULL OptionalProto::mutable_map_value()
2203     ABSL_ATTRIBUTE_LIFETIME_BOUND {
2204   _impl_._has_bits_[0] |= 0x00000010U;
2205   ::onnx::MapProto* _msg = _internal_mutable_map_value();
2206   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.map_value)
2207   return _msg;
2208 }
2209 inline void OptionalProto::set_allocated_map_value(::onnx::MapProto* PROTOBUF_NULLABLE value) {
2210   ::google::protobuf::Arena* message_arena = GetArena();
2211   ::google::protobuf::internal::TSanWrite(&_impl_);
2212   if (message_arena == nullptr) {
2213     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.map_value_);
2214   }
2215
2216   if (value != nullptr) {
2217     ::google::protobuf::Arena* submessage_arena = value->GetArena();
2218     if (message_arena != submessage_arena) {
2219       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2220     }
2221     _impl_._has_bits_[0] |= 0x00000010U;
2222   } else {
2223     _impl_._has_bits_[0] &= ~0x00000010U;
2224   }
2225
2226   _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(value);
2227   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.map_value)
2228 }
2229
2230 // optional .onnx.OptionalProto optional_value = 7;
2231 inline bool OptionalProto::has_optional_value() const {
2232   bool value = (_impl_._has_bits_[0] & 0x00000020U) != 0;
2233   PROTOBUF_ASSUME(!value || _impl_.optional_value_ != nullptr);
2234   return value;
2235 }
2236 inline void OptionalProto::clear_optional_value() {
2237   ::google::protobuf::internal::TSanWrite(&_impl_);
2238   if (_impl_.optional_value_ != nullptr) _impl_.optional_value_->Clear();
2239   _impl_._has_bits_[0] &= ~0x00000020U;
2240 }
2241 inline const ::onnx::OptionalProto& OptionalProto::_internal_optional_value() const {
2242   ::google::protobuf::internal::TSanRead(&_impl_);
2243   const ::onnx::OptionalProto* p = _impl_.optional_value_;
2244   return p != nullptr ? *p : reinterpret_cast<const ::onnx::OptionalProto&>(::onnx::_OptionalProto_default_instance_);
2245 }
2246 inline const ::onnx::OptionalProto& OptionalProto::optional_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2247   // @@protoc_insertion_point(field_get:onnx.OptionalProto.optional_value)
2248   return _internal_optional_value();
2249 }
2250 inline void OptionalProto::unsafe_arena_set_allocated_optional_value(
2251     ::onnx::OptionalProto* PROTOBUF_NULLABLE value) {
2252   ::google::protobuf::internal::TSanWrite(&_impl_);
2253   if (GetArena() == nullptr) {
2254     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.optional_value_);
2255   }
2256   _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(value);
2257   if (value != nullptr) {
2258     _impl_._has_bits_[0] |= 0x00000020U;
2259   } else {
2260     _impl_._has_bits_[0] &= ~0x00000020U;
2261   }
2262   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.optional_value)
2263 }
2264 inline ::onnx::OptionalProto* PROTOBUF_NULLABLE OptionalProto::release_optional_value() {
2265   ::google::protobuf::internal::TSanWrite(&_impl_);
2266
2267   _impl_._has_bits_[0] &= ~0x00000020U;
2268   ::onnx::OptionalProto* released = _impl_.optional_value_;
2269   _impl_.optional_value_ = nullptr;
2270   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
2271     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2272     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2273     if (GetArena() == nullptr) {
2274       delete old;
2275     }
2276   } else {
2277     if (GetArena() != nullptr) {
2278       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2279     }
2280   }
2281   return released;
2282 }
2283 inline ::onnx::OptionalProto* PROTOBUF_NULLABLE OptionalProto::unsafe_arena_release_optional_value() {
2284   ::google::protobuf::internal::TSanWrite(&_impl_);
2285   // @@protoc_insertion_point(field_release:onnx.OptionalProto.optional_value)
2286
2287   _impl_._has_bits_[0] &= ~0x00000020U;
2288   ::onnx::OptionalProto* temp = _impl_.optional_value_;
2289   _impl_.optional_value_ = nullptr;
2290   return temp;
2291 }
2292 inline ::onnx::OptionalProto* PROTOBUF_NONNULL OptionalProto::_internal_mutable_optional_value() {
2293   ::google::protobuf::internal::TSanWrite(&_impl_);
2294   if (_impl_.optional_value_ == nullptr) {
2295     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::OptionalProto>(GetArena());
2296     _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(p);
2297   }
2298   return _impl_.optional_value_;
2299 }
2300 inline ::onnx::OptionalProto* PROTOBUF_NONNULL OptionalProto::mutable_optional_value()
2301     ABSL_ATTRIBUTE_LIFETIME_BOUND {
2302   _impl_._has_bits_[0] |= 0x00000020U;
2303   ::onnx::OptionalProto* _msg = _internal_mutable_optional_value();
2304   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.optional_value)
2305   return _msg;
2306 }
2307 inline void OptionalProto::set_allocated_optional_value(::onnx::OptionalProto* PROTOBUF_NULLABLE value) {
2308   ::google::protobuf::Arena* message_arena = GetArena();
2309   ::google::protobuf::internal::TSanWrite(&_impl_);
2310   if (message_arena == nullptr) {
2311     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.optional_value_);
2312   }
2313
2314   if (value != nullptr) {
2315     ::google::protobuf::Arena* submessage_arena = value->GetArena();
2316     if (message_arena != submessage_arena) {
2317       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2318     }
2319     _impl_._has_bits_[0] |= 0x00000020U;
2320   } else {
2321     _impl_._has_bits_[0] &= ~0x00000020U;
2322   }
2323
2324   _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(value);
2325   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.optional_value)
2326 }
2327
2328 #ifdef __GNUC__
2329 #pragma GCC diagnostic pop
2330 #endif  // __GNUC__
2331
2332 // @@protoc_insertion_point(namespace_scope)
2333 }  // namespace onnx
2334
2335
2336 namespace google {
2337 namespace protobuf {
2338
2339 template <>
2340 struct is_proto_enum<::onnx::SequenceProto_DataType> : std::true_type {};
2341 template <>
2342 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::SequenceProto_DataType>() {
2343   return ::onnx::SequenceProto_DataType_descriptor();
2344 }
2345 template <>
2346 struct is_proto_enum<::onnx::OptionalProto_DataType> : std::true_type {};
2347 template <>
2348 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::OptionalProto_DataType>() {
2349   return ::onnx::OptionalProto_DataType_descriptor();
2350 }
2351
2352 }  // namespace protobuf
2353 }  // namespace google
2354
2355 // @@protoc_insertion_point(global_scope)
2356
2357 #include "google/protobuf/port_undef.inc"
2358
2359 #endif  // onnx_2fonnx_2ddata_2eproto_2epb_2eh