Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-07-04 08:31:19 

0001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
0002 // NO CHECKED-IN PROTOBUF GENCODE
0003 // source: onnx/onnx-ml.proto
0004 // Protobuf C++ Version: 6.32.1
0005 
0006 #ifndef onnx_2fonnx_2dml_2eproto_2epb_2eh
0007 #define onnx_2fonnx_2dml_2eproto_2epb_2eh
0008 
0009 #include <limits>
0010 #include <string>
0011 #include <type_traits>
0012 #include <utility>
0013 
0014 #include "google/protobuf/runtime_version.h"
0015 #if PROTOBUF_VERSION != 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 // @@protoc_insertion_point(includes)
0034 
0035 // Must be included last.
0036 #include "google/protobuf/port_def.inc"
0037 
0038 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2dml_2eproto ONNX_API
0039 
0040 namespace google {
0041 namespace protobuf {
0042 namespace internal {
0043 template <typename T>
0044 ::absl::string_view GetAnyMessageName();
0045 }  // namespace internal
0046 }  // namespace protobuf
0047 }  // namespace google
0048 
0049 // Internal implementation detail -- do not use these members.
0050 struct ONNX_API TableStruct_onnx_2fonnx_2dml_2eproto {
0051   static const ::uint32_t offsets[];
0052 };
0053 extern "C" {
0054 ONNX_API extern const ::google::protobuf::internal::DescriptorTable descriptor_table_onnx_2fonnx_2dml_2eproto;
0055 }  // extern "C"
0056 namespace onnx {
0057 enum AttributeProto_AttributeType : int;
0058 ONNX_API extern const uint32_t AttributeProto_AttributeType_internal_data_[];
0059 enum OperatorStatus : int;
0060 ONNX_API extern const uint32_t OperatorStatus_internal_data_[];
0061 enum TensorProto_DataLocation : int;
0062 ONNX_API extern const uint32_t TensorProto_DataLocation_internal_data_[];
0063 enum TensorProto_DataType : int;
0064 ONNX_API extern const uint32_t TensorProto_DataType_internal_data_[];
0065 enum Version : int;
0066 ONNX_API extern const uint32_t Version_internal_data_[];
0067 class AttributeProto;
0068 struct AttributeProtoDefaultTypeInternal;
0069 ONNX_API extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
0070 ONNX_API extern const ::google::protobuf::internal::ClassDataFull AttributeProto_class_data_;
0071 class FunctionProto;
0072 struct FunctionProtoDefaultTypeInternal;
0073 ONNX_API extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
0074 ONNX_API extern const ::google::protobuf::internal::ClassDataFull FunctionProto_class_data_;
0075 class GraphProto;
0076 struct GraphProtoDefaultTypeInternal;
0077 ONNX_API extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
0078 ONNX_API extern const ::google::protobuf::internal::ClassDataFull GraphProto_class_data_;
0079 class ModelProto;
0080 struct ModelProtoDefaultTypeInternal;
0081 ONNX_API extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
0082 ONNX_API extern const ::google::protobuf::internal::ClassDataFull ModelProto_class_data_;
0083 class NodeProto;
0084 struct NodeProtoDefaultTypeInternal;
0085 ONNX_API extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
0086 ONNX_API extern const ::google::protobuf::internal::ClassDataFull NodeProto_class_data_;
0087 class OperatorSetIdProto;
0088 struct OperatorSetIdProtoDefaultTypeInternal;
0089 ONNX_API extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
0090 ONNX_API extern const ::google::protobuf::internal::ClassDataFull OperatorSetIdProto_class_data_;
0091 class SparseTensorProto;
0092 struct SparseTensorProtoDefaultTypeInternal;
0093 ONNX_API extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
0094 ONNX_API extern const ::google::protobuf::internal::ClassDataFull SparseTensorProto_class_data_;
0095 class StringStringEntryProto;
0096 struct StringStringEntryProtoDefaultTypeInternal;
0097 ONNX_API extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
0098 ONNX_API extern const ::google::protobuf::internal::ClassDataFull StringStringEntryProto_class_data_;
0099 class TensorAnnotation;
0100 struct TensorAnnotationDefaultTypeInternal;
0101 ONNX_API extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
0102 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorAnnotation_class_data_;
0103 class TensorProto;
0104 struct TensorProtoDefaultTypeInternal;
0105 ONNX_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
0106 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorProto_class_data_;
0107 class TensorProto_Segment;
0108 struct TensorProto_SegmentDefaultTypeInternal;
0109 ONNX_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
0110 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorProto_Segment_class_data_;
0111 class TensorShapeProto;
0112 struct TensorShapeProtoDefaultTypeInternal;
0113 ONNX_API extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
0114 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_class_data_;
0115 class TensorShapeProto_Dimension;
0116 struct TensorShapeProto_DimensionDefaultTypeInternal;
0117 ONNX_API extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
0118 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_Dimension_class_data_;
0119 class TrainingInfoProto;
0120 struct TrainingInfoProtoDefaultTypeInternal;
0121 ONNX_API extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
0122 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TrainingInfoProto_class_data_;
0123 class TypeProto;
0124 struct TypeProtoDefaultTypeInternal;
0125 ONNX_API extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
0126 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_class_data_;
0127 class TypeProto_Map;
0128 struct TypeProto_MapDefaultTypeInternal;
0129 ONNX_API extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
0130 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Map_class_data_;
0131 class TypeProto_Opaque;
0132 struct TypeProto_OpaqueDefaultTypeInternal;
0133 ONNX_API extern TypeProto_OpaqueDefaultTypeInternal _TypeProto_Opaque_default_instance_;
0134 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Opaque_class_data_;
0135 class TypeProto_Optional;
0136 struct TypeProto_OptionalDefaultTypeInternal;
0137 ONNX_API extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
0138 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Optional_class_data_;
0139 class TypeProto_Sequence;
0140 struct TypeProto_SequenceDefaultTypeInternal;
0141 ONNX_API extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
0142 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Sequence_class_data_;
0143 class TypeProto_SparseTensor;
0144 struct TypeProto_SparseTensorDefaultTypeInternal;
0145 ONNX_API extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
0146 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_SparseTensor_class_data_;
0147 class TypeProto_Tensor;
0148 struct TypeProto_TensorDefaultTypeInternal;
0149 ONNX_API extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
0150 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Tensor_class_data_;
0151 class ValueInfoProto;
0152 struct ValueInfoProtoDefaultTypeInternal;
0153 ONNX_API extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
0154 ONNX_API extern const ::google::protobuf::internal::ClassDataFull ValueInfoProto_class_data_;
0155 }  // namespace onnx
0156 namespace google {
0157 namespace protobuf {
0158 template <>
0159 internal::EnumTraitsT<::onnx::AttributeProto_AttributeType_internal_data_>
0160     internal::EnumTraitsImpl::value<::onnx::AttributeProto_AttributeType>;
0161 template <>
0162 internal::EnumTraitsT<::onnx::OperatorStatus_internal_data_>
0163     internal::EnumTraitsImpl::value<::onnx::OperatorStatus>;
0164 template <>
0165 internal::EnumTraitsT<::onnx::TensorProto_DataLocation_internal_data_>
0166     internal::EnumTraitsImpl::value<::onnx::TensorProto_DataLocation>;
0167 template <>
0168 internal::EnumTraitsT<::onnx::TensorProto_DataType_internal_data_>
0169     internal::EnumTraitsImpl::value<::onnx::TensorProto_DataType>;
0170 template <>
0171 internal::EnumTraitsT<::onnx::Version_internal_data_>
0172     internal::EnumTraitsImpl::value<::onnx::Version>;
0173 }  // namespace protobuf
0174 }  // namespace google
0175 
0176 namespace onnx {
0177 enum AttributeProto_AttributeType : int {
0178   AttributeProto_AttributeType_UNDEFINED = 0,
0179   AttributeProto_AttributeType_FLOAT = 1,
0180   AttributeProto_AttributeType_INT = 2,
0181   AttributeProto_AttributeType_STRING = 3,
0182   AttributeProto_AttributeType_TENSOR = 4,
0183   AttributeProto_AttributeType_GRAPH = 5,
0184   AttributeProto_AttributeType_SPARSE_TENSOR = 11,
0185   AttributeProto_AttributeType_TYPE_PROTO = 13,
0186   AttributeProto_AttributeType_FLOATS = 6,
0187   AttributeProto_AttributeType_INTS = 7,
0188   AttributeProto_AttributeType_STRINGS = 8,
0189   AttributeProto_AttributeType_TENSORS = 9,
0190   AttributeProto_AttributeType_GRAPHS = 10,
0191   AttributeProto_AttributeType_SPARSE_TENSORS = 12,
0192   AttributeProto_AttributeType_TYPE_PROTOS = 14,
0193 };
0194 
0195 ONNX_API extern const uint32_t AttributeProto_AttributeType_internal_data_[];
0196 inline constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN =
0197     static_cast<AttributeProto_AttributeType>(0);
0198 inline constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX =
0199     static_cast<AttributeProto_AttributeType>(14);
0200 inline bool AttributeProto_AttributeType_IsValid(int value) {
0201   return 0 <= value && value <= 14;
0202 }
0203 inline constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = 14 + 1;
0204 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL AttributeProto_AttributeType_descriptor();
0205 template <typename T>
0206 const ::std::string& AttributeProto_AttributeType_Name(T value) {
0207   static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
0208                     ::std::is_integral<T>::value,
0209                 "Incorrect type passed to AttributeType_Name().");
0210   return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(value));
0211 }
0212 template <>
0213 inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
0214   return ::google::protobuf::internal::NameOfDenseEnum<AttributeProto_AttributeType_descriptor, 0, 14>(
0215       static_cast<int>(value));
0216 }
0217 inline bool AttributeProto_AttributeType_Parse(
0218     ::absl::string_view name, AttributeProto_AttributeType* PROTOBUF_NONNULL value) {
0219   return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(AttributeProto_AttributeType_descriptor(), name,
0220                                            value);
0221 }
0222 enum TensorProto_DataType : int {
0223   TensorProto_DataType_UNDEFINED = 0,
0224   TensorProto_DataType_FLOAT = 1,
0225   TensorProto_DataType_UINT8 = 2,
0226   TensorProto_DataType_INT8 = 3,
0227   TensorProto_DataType_UINT16 = 4,
0228   TensorProto_DataType_INT16 = 5,
0229   TensorProto_DataType_INT32 = 6,
0230   TensorProto_DataType_INT64 = 7,
0231   TensorProto_DataType_STRING = 8,
0232   TensorProto_DataType_BOOL = 9,
0233   TensorProto_DataType_FLOAT16 = 10,
0234   TensorProto_DataType_DOUBLE = 11,
0235   TensorProto_DataType_UINT32 = 12,
0236   TensorProto_DataType_UINT64 = 13,
0237   TensorProto_DataType_COMPLEX64 = 14,
0238   TensorProto_DataType_COMPLEX128 = 15,
0239   TensorProto_DataType_BFLOAT16 = 16,
0240   TensorProto_DataType_FLOAT8E4M3FN = 17,
0241   TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
0242   TensorProto_DataType_FLOAT8E5M2 = 19,
0243   TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
0244   TensorProto_DataType_UINT4 = 21,
0245   TensorProto_DataType_INT4 = 22,
0246 };
0247 
0248 ONNX_API extern const uint32_t TensorProto_DataType_internal_data_[];
0249 inline constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN =
0250     static_cast<TensorProto_DataType>(0);
0251 inline constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX =
0252     static_cast<TensorProto_DataType>(22);
0253 inline bool TensorProto_DataType_IsValid(int value) {
0254   return 0 <= value && value <= 22;
0255 }
0256 inline constexpr int TensorProto_DataType_DataType_ARRAYSIZE = 22 + 1;
0257 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TensorProto_DataType_descriptor();
0258 template <typename T>
0259 const ::std::string& TensorProto_DataType_Name(T value) {
0260   static_assert(::std::is_same<T, TensorProto_DataType>::value ||
0261                     ::std::is_integral<T>::value,
0262                 "Incorrect type passed to DataType_Name().");
0263   return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(value));
0264 }
0265 template <>
0266 inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
0267   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataType_descriptor, 0, 22>(
0268       static_cast<int>(value));
0269 }
0270 inline bool TensorProto_DataType_Parse(
0271     ::absl::string_view name, TensorProto_DataType* PROTOBUF_NONNULL value) {
0272   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(TensorProto_DataType_descriptor(), name,
0273                                            value);
0274 }
0275 enum TensorProto_DataLocation : int {
0276   TensorProto_DataLocation_DEFAULT = 0,
0277   TensorProto_DataLocation_EXTERNAL = 1,
0278 };
0279 
0280 ONNX_API extern const uint32_t TensorProto_DataLocation_internal_data_[];
0281 inline constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN =
0282     static_cast<TensorProto_DataLocation>(0);
0283 inline constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX =
0284     static_cast<TensorProto_DataLocation>(1);
0285 inline bool TensorProto_DataLocation_IsValid(int value) {
0286   return 0 <= value && value <= 1;
0287 }
0288 inline constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = 1 + 1;
0289 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TensorProto_DataLocation_descriptor();
0290 template <typename T>
0291 const ::std::string& TensorProto_DataLocation_Name(T value) {
0292   static_assert(::std::is_same<T, TensorProto_DataLocation>::value ||
0293                     ::std::is_integral<T>::value,
0294                 "Incorrect type passed to DataLocation_Name().");
0295   return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(value));
0296 }
0297 template <>
0298 inline const ::std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value) {
0299   return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataLocation_descriptor, 0, 1>(
0300       static_cast<int>(value));
0301 }
0302 inline bool TensorProto_DataLocation_Parse(
0303     ::absl::string_view name, TensorProto_DataLocation* PROTOBUF_NONNULL value) {
0304   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataLocation>(TensorProto_DataLocation_descriptor(), name,
0305                                            value);
0306 }
0307 enum Version : int {
0308   _START_VERSION = 0,
0309   IR_VERSION_2017_10_10 = 1,
0310   IR_VERSION_2017_10_30 = 2,
0311   IR_VERSION_2017_11_3 = 3,
0312   IR_VERSION_2019_1_22 = 4,
0313   IR_VERSION_2019_3_18 = 5,
0314   IR_VERSION_2019_9_19 = 6,
0315   IR_VERSION_2020_5_8 = 7,
0316   IR_VERSION_2021_7_30 = 8,
0317   IR_VERSION_2023_5_5 = 9,
0318   IR_VERSION = 10,
0319 };
0320 
0321 ONNX_API extern const uint32_t Version_internal_data_[];
0322 inline constexpr Version Version_MIN =
0323     static_cast<Version>(0);
0324 inline constexpr Version Version_MAX =
0325     static_cast<Version>(10);
0326 inline bool Version_IsValid(int value) {
0327   return 0 <= value && value <= 10;
0328 }
0329 inline constexpr int Version_ARRAYSIZE = 10 + 1;
0330 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Version_descriptor();
0331 template <typename T>
0332 const ::std::string& Version_Name(T value) {
0333   static_assert(::std::is_same<T, Version>::value ||
0334                     ::std::is_integral<T>::value,
0335                 "Incorrect type passed to Version_Name().");
0336   return Version_Name(static_cast<Version>(value));
0337 }
0338 template <>
0339 inline const ::std::string& Version_Name(Version value) {
0340   return ::google::protobuf::internal::NameOfDenseEnum<Version_descriptor, 0, 10>(
0341       static_cast<int>(value));
0342 }
0343 inline bool Version_Parse(
0344     ::absl::string_view name, Version* PROTOBUF_NONNULL value) {
0345   return ::google::protobuf::internal::ParseNamedEnum<Version>(Version_descriptor(), name,
0346                                            value);
0347 }
0348 enum OperatorStatus : int {
0349   EXPERIMENTAL = 0,
0350   STABLE = 1,
0351 };
0352 
0353 ONNX_API extern const uint32_t OperatorStatus_internal_data_[];
0354 inline constexpr OperatorStatus OperatorStatus_MIN =
0355     static_cast<OperatorStatus>(0);
0356 inline constexpr OperatorStatus OperatorStatus_MAX =
0357     static_cast<OperatorStatus>(1);
0358 inline bool OperatorStatus_IsValid(int value) {
0359   return 0 <= value && value <= 1;
0360 }
0361 inline constexpr int OperatorStatus_ARRAYSIZE = 1 + 1;
0362 ONNX_API const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL OperatorStatus_descriptor();
0363 template <typename T>
0364 const ::std::string& OperatorStatus_Name(T value) {
0365   static_assert(::std::is_same<T, OperatorStatus>::value ||
0366                     ::std::is_integral<T>::value,
0367                 "Incorrect type passed to OperatorStatus_Name().");
0368   return OperatorStatus_Name(static_cast<OperatorStatus>(value));
0369 }
0370 template <>
0371 inline const ::std::string& OperatorStatus_Name(OperatorStatus value) {
0372   return ::google::protobuf::internal::NameOfDenseEnum<OperatorStatus_descriptor, 0, 1>(
0373       static_cast<int>(value));
0374 }
0375 inline bool OperatorStatus_Parse(
0376     ::absl::string_view name, OperatorStatus* PROTOBUF_NONNULL value) {
0377   return ::google::protobuf::internal::ParseNamedEnum<OperatorStatus>(OperatorStatus_descriptor(), name,
0378                                            value);
0379 }
0380 
0381 // ===================================================================
0382 
0383 
0384 // -------------------------------------------------------------------
0385 
0386 class ONNX_API TypeProto_Opaque final : public ::google::protobuf::Message
0387 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Opaque) */ {
0388  public:
0389   inline TypeProto_Opaque() : TypeProto_Opaque(nullptr) {}
0390   ~TypeProto_Opaque() PROTOBUF_FINAL;
0391 
0392 #if defined(PROTOBUF_CUSTOM_VTABLE)
0393   void operator delete(TypeProto_Opaque* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0394     SharedDtor(*msg);
0395     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Opaque));
0396   }
0397 #endif
0398 
0399   template <typename = void>
0400   explicit PROTOBUF_CONSTEXPR TypeProto_Opaque(::google::protobuf::internal::ConstantInitialized);
0401 
0402   inline TypeProto_Opaque(const TypeProto_Opaque& from) : TypeProto_Opaque(nullptr, from) {}
0403   inline TypeProto_Opaque(TypeProto_Opaque&& from) noexcept
0404       : TypeProto_Opaque(nullptr, ::std::move(from)) {}
0405   inline TypeProto_Opaque& operator=(const TypeProto_Opaque& from) {
0406     CopyFrom(from);
0407     return *this;
0408   }
0409   inline TypeProto_Opaque& operator=(TypeProto_Opaque&& from) noexcept {
0410     if (this == &from) return *this;
0411     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0412       InternalSwap(&from);
0413     } else {
0414       CopyFrom(from);
0415     }
0416     return *this;
0417   }
0418 
0419   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0420       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0421     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0422   }
0423   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0424       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0425     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0426   }
0427 
0428   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0429     return GetDescriptor();
0430   }
0431   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0432     return default_instance().GetMetadata().descriptor;
0433   }
0434   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0435     return default_instance().GetMetadata().reflection;
0436   }
0437   static const TypeProto_Opaque& default_instance() {
0438     return *reinterpret_cast<const TypeProto_Opaque*>(
0439         &_TypeProto_Opaque_default_instance_);
0440   }
0441   static constexpr int kIndexInFileMessages = 18;
0442   friend void swap(TypeProto_Opaque& a, TypeProto_Opaque& b) { a.Swap(&b); }
0443   inline void Swap(TypeProto_Opaque* PROTOBUF_NONNULL other) {
0444     if (other == this) return;
0445     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0446       InternalSwap(other);
0447     } else {
0448       ::google::protobuf::internal::GenericSwap(this, other);
0449     }
0450   }
0451   void UnsafeArenaSwap(TypeProto_Opaque* PROTOBUF_NONNULL other) {
0452     if (other == this) return;
0453     ABSL_DCHECK(GetArena() == other->GetArena());
0454     InternalSwap(other);
0455   }
0456 
0457   // implements Message ----------------------------------------------
0458 
0459   TypeProto_Opaque* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0460     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Opaque>(arena);
0461   }
0462   using ::google::protobuf::Message::CopyFrom;
0463   void CopyFrom(const TypeProto_Opaque& from);
0464   using ::google::protobuf::Message::MergeFrom;
0465   void MergeFrom(const TypeProto_Opaque& from) { TypeProto_Opaque::MergeImpl(*this, from); }
0466 
0467   private:
0468   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0469                         const ::google::protobuf::MessageLite& from_msg);
0470 
0471   public:
0472   bool IsInitialized() const {
0473     return true;
0474   }
0475   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0476   #if defined(PROTOBUF_CUSTOM_VTABLE)
0477   private:
0478   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0479   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0480       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0481       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0482 
0483   public:
0484   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0485   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0486       ::uint8_t* PROTOBUF_NONNULL target,
0487       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0488     return _InternalSerialize(*this, target, stream);
0489   }
0490   #else   // PROTOBUF_CUSTOM_VTABLE
0491   ::size_t ByteSizeLong() const final;
0492   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0493       ::uint8_t* PROTOBUF_NONNULL target,
0494       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0495   #endif  // PROTOBUF_CUSTOM_VTABLE
0496   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0497 
0498   private:
0499   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0500   static void SharedDtor(MessageLite& self);
0501   void InternalSwap(TypeProto_Opaque* PROTOBUF_NONNULL other);
0502  private:
0503   template <typename T>
0504   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0505   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Opaque"; }
0506 
0507  protected:
0508   explicit TypeProto_Opaque(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0509   TypeProto_Opaque(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Opaque& from);
0510   TypeProto_Opaque(
0511       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Opaque&& from) noexcept
0512       : TypeProto_Opaque(arena) {
0513     *this = ::std::move(from);
0514   }
0515   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0516   static void* PROTOBUF_NONNULL PlacementNew_(
0517       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0518       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0519   static constexpr auto InternalNewImpl_();
0520 
0521  public:
0522   static constexpr auto InternalGenerateClassData_();
0523 
0524   ::google::protobuf::Metadata GetMetadata() const;
0525   // nested types ----------------------------------------------------
0526 
0527   // accessors -------------------------------------------------------
0528   enum : int {
0529     kDomainFieldNumber = 1,
0530     kNameFieldNumber = 2,
0531   };
0532   // optional string domain = 1;
0533   bool has_domain() const;
0534   void clear_domain() ;
0535   const ::std::string& domain() const;
0536   template <typename Arg_ = const ::std::string&, typename... Args_>
0537   void set_domain(Arg_&& arg, Args_... args);
0538   ::std::string* PROTOBUF_NONNULL mutable_domain();
0539   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
0540   void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);
0541 
0542   private:
0543   const ::std::string& _internal_domain() const;
0544   PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
0545   ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();
0546 
0547   public:
0548   // optional string name = 2;
0549   bool has_name() const;
0550   void clear_name() ;
0551   const ::std::string& name() const;
0552   template <typename Arg_ = const ::std::string&, typename... Args_>
0553   void set_name(Arg_&& arg, Args_... args);
0554   ::std::string* PROTOBUF_NONNULL mutable_name();
0555   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
0556   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
0557 
0558   private:
0559   const ::std::string& _internal_name() const;
0560   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
0561   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
0562 
0563   public:
0564   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Opaque)
0565  private:
0566   class _Internal;
0567   friend class ::google::protobuf::internal::TcParser;
0568   static const ::google::protobuf::internal::TcParseTable<1, 2,
0569                                    0, 40,
0570                                    2>
0571       _table_;
0572 
0573   friend class ::google::protobuf::MessageLite;
0574   friend class ::google::protobuf::Arena;
0575   template <typename T>
0576   friend class ::google::protobuf::Arena::InternalHelper;
0577   using InternalArenaConstructable_ = void;
0578   using DestructorSkippable_ = void;
0579   struct Impl_ {
0580     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
0581     inline explicit Impl_(
0582         ::google::protobuf::internal::InternalVisibility visibility,
0583         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0584     inline explicit Impl_(
0585         ::google::protobuf::internal::InternalVisibility visibility,
0586         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
0587         const TypeProto_Opaque& from_msg);
0588     ::google::protobuf::internal::HasBits<1> _has_bits_;
0589     ::google::protobuf::internal::CachedSize _cached_size_;
0590     ::google::protobuf::internal::ArenaStringPtr domain_;
0591     ::google::protobuf::internal::ArenaStringPtr name_;
0592     PROTOBUF_TSAN_DECLARE_MEMBER
0593   };
0594   union { Impl_ _impl_; };
0595   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
0596 };
0597 
0598 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Opaque_class_data_;
0599 // -------------------------------------------------------------------
0600 
0601 class ONNX_API TensorShapeProto_Dimension final : public ::google::protobuf::Message
0602 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
0603  public:
0604   inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
0605   ~TensorShapeProto_Dimension() PROTOBUF_FINAL;
0606 
0607 #if defined(PROTOBUF_CUSTOM_VTABLE)
0608   void operator delete(TensorShapeProto_Dimension* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0609     SharedDtor(*msg);
0610     ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorShapeProto_Dimension));
0611   }
0612 #endif
0613 
0614   template <typename = void>
0615   explicit PROTOBUF_CONSTEXPR TensorShapeProto_Dimension(::google::protobuf::internal::ConstantInitialized);
0616 
0617   inline TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from) : TensorShapeProto_Dimension(nullptr, from) {}
0618   inline TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
0619       : TensorShapeProto_Dimension(nullptr, ::std::move(from)) {}
0620   inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
0621     CopyFrom(from);
0622     return *this;
0623   }
0624   inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
0625     if (this == &from) return *this;
0626     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0627       InternalSwap(&from);
0628     } else {
0629       CopyFrom(from);
0630     }
0631     return *this;
0632   }
0633 
0634   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0635       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0636     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0637   }
0638   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0639       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0640     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0641   }
0642 
0643   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0644     return GetDescriptor();
0645   }
0646   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0647     return default_instance().GetMetadata().descriptor;
0648   }
0649   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0650     return default_instance().GetMetadata().reflection;
0651   }
0652   static const TensorShapeProto_Dimension& default_instance() {
0653     return *reinterpret_cast<const TensorShapeProto_Dimension*>(
0654         &_TensorShapeProto_Dimension_default_instance_);
0655   }
0656   enum ValueCase {
0657     kDimValue = 1,
0658     kDimParam = 2,
0659     VALUE_NOT_SET = 0,
0660   };
0661   static constexpr int kIndexInFileMessages = 11;
0662   friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) { a.Swap(&b); }
0663   inline void Swap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other) {
0664     if (other == this) return;
0665     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0666       InternalSwap(other);
0667     } else {
0668       ::google::protobuf::internal::GenericSwap(this, other);
0669     }
0670   }
0671   void UnsafeArenaSwap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other) {
0672     if (other == this) return;
0673     ABSL_DCHECK(GetArena() == other->GetArena());
0674     InternalSwap(other);
0675   }
0676 
0677   // implements Message ----------------------------------------------
0678 
0679   TensorShapeProto_Dimension* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0680     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto_Dimension>(arena);
0681   }
0682   using ::google::protobuf::Message::CopyFrom;
0683   void CopyFrom(const TensorShapeProto_Dimension& from);
0684   using ::google::protobuf::Message::MergeFrom;
0685   void MergeFrom(const TensorShapeProto_Dimension& from) { TensorShapeProto_Dimension::MergeImpl(*this, from); }
0686 
0687   private:
0688   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0689                         const ::google::protobuf::MessageLite& from_msg);
0690 
0691   public:
0692   bool IsInitialized() const {
0693     return true;
0694   }
0695   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0696   #if defined(PROTOBUF_CUSTOM_VTABLE)
0697   private:
0698   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0699   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0700       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0701       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0702 
0703   public:
0704   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0705   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0706       ::uint8_t* PROTOBUF_NONNULL target,
0707       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0708     return _InternalSerialize(*this, target, stream);
0709   }
0710   #else   // PROTOBUF_CUSTOM_VTABLE
0711   ::size_t ByteSizeLong() const final;
0712   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0713       ::uint8_t* PROTOBUF_NONNULL target,
0714       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0715   #endif  // PROTOBUF_CUSTOM_VTABLE
0716   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0717 
0718   private:
0719   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0720   static void SharedDtor(MessageLite& self);
0721   void InternalSwap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other);
0722  private:
0723   template <typename T>
0724   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0725   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto.Dimension"; }
0726 
0727  protected:
0728   explicit TensorShapeProto_Dimension(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0729   TensorShapeProto_Dimension(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorShapeProto_Dimension& from);
0730   TensorShapeProto_Dimension(
0731       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorShapeProto_Dimension&& from) noexcept
0732       : TensorShapeProto_Dimension(arena) {
0733     *this = ::std::move(from);
0734   }
0735   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0736   static void* PROTOBUF_NONNULL PlacementNew_(
0737       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0738       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0739   static constexpr auto InternalNewImpl_();
0740 
0741  public:
0742   static constexpr auto InternalGenerateClassData_();
0743 
0744   ::google::protobuf::Metadata GetMetadata() const;
0745   // nested types ----------------------------------------------------
0746 
0747   // accessors -------------------------------------------------------
0748   enum : int {
0749     kDenotationFieldNumber = 3,
0750     kDimValueFieldNumber = 1,
0751     kDimParamFieldNumber = 2,
0752   };
0753   // optional string denotation = 3;
0754   bool has_denotation() const;
0755   void clear_denotation() ;
0756   const ::std::string& denotation() const;
0757   template <typename Arg_ = const ::std::string&, typename... Args_>
0758   void set_denotation(Arg_&& arg, Args_... args);
0759   ::std::string* PROTOBUF_NONNULL mutable_denotation();
0760   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_denotation();
0761   void set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value);
0762 
0763   private:
0764   const ::std::string& _internal_denotation() const;
0765   PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const ::std::string& value);
0766   ::std::string* PROTOBUF_NONNULL _internal_mutable_denotation();
0767 
0768   public:
0769   // int64 dim_value = 1;
0770   bool has_dim_value() const;
0771   void clear_dim_value() ;
0772   ::int64_t dim_value() const;
0773   void set_dim_value(::int64_t value);
0774 
0775   private:
0776   ::int64_t _internal_dim_value() const;
0777   void _internal_set_dim_value(::int64_t value);
0778 
0779   public:
0780   // string dim_param = 2;
0781   bool has_dim_param() const;
0782   void clear_dim_param() ;
0783   const ::std::string& dim_param() const;
0784   template <typename Arg_ = const ::std::string&, typename... Args_>
0785   void set_dim_param(Arg_&& arg, Args_... args);
0786   ::std::string* PROTOBUF_NONNULL mutable_dim_param();
0787   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dim_param();
0788   void set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value);
0789 
0790   private:
0791   const ::std::string& _internal_dim_param() const;
0792   PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const ::std::string& value);
0793   ::std::string* PROTOBUF_NONNULL _internal_mutable_dim_param();
0794 
0795   public:
0796   void clear_value();
0797   ValueCase value_case() const;
0798   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
0799  private:
0800   class _Internal;
0801   void set_has_dim_value();
0802   void set_has_dim_param();
0803   inline bool has_value() const;
0804   inline void clear_has_value();
0805   friend class ::google::protobuf::internal::TcParser;
0806   static const ::google::protobuf::internal::TcParseTable<0, 3,
0807                                    0, 59,
0808                                    2>
0809       _table_;
0810 
0811   friend class ::google::protobuf::MessageLite;
0812   friend class ::google::protobuf::Arena;
0813   template <typename T>
0814   friend class ::google::protobuf::Arena::InternalHelper;
0815   using InternalArenaConstructable_ = void;
0816   using DestructorSkippable_ = void;
0817   struct Impl_ {
0818     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
0819     inline explicit Impl_(
0820         ::google::protobuf::internal::InternalVisibility visibility,
0821         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0822     inline explicit Impl_(
0823         ::google::protobuf::internal::InternalVisibility visibility,
0824         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
0825         const TensorShapeProto_Dimension& from_msg);
0826     ::google::protobuf::internal::HasBits<1> _has_bits_;
0827     ::google::protobuf::internal::CachedSize _cached_size_;
0828     ::google::protobuf::internal::ArenaStringPtr denotation_;
0829     union ValueUnion {
0830       constexpr ValueUnion() : _constinit_{} {}
0831       ::google::protobuf::internal::ConstantInitialized _constinit_;
0832       ::int64_t dim_value_;
0833       ::google::protobuf::internal::ArenaStringPtr dim_param_;
0834     } value_;
0835     ::uint32_t _oneof_case_[1];
0836     PROTOBUF_TSAN_DECLARE_MEMBER
0837   };
0838   union { Impl_ _impl_; };
0839   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
0840 };
0841 
0842 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_Dimension_class_data_;
0843 // -------------------------------------------------------------------
0844 
0845 class ONNX_API TensorProto_Segment final : public ::google::protobuf::Message
0846 /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
0847  public:
0848   inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
0849   ~TensorProto_Segment() PROTOBUF_FINAL;
0850 
0851 #if defined(PROTOBUF_CUSTOM_VTABLE)
0852   void operator delete(TensorProto_Segment* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
0853     SharedDtor(*msg);
0854     ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorProto_Segment));
0855   }
0856 #endif
0857 
0858   template <typename = void>
0859   explicit PROTOBUF_CONSTEXPR TensorProto_Segment(::google::protobuf::internal::ConstantInitialized);
0860 
0861   inline TensorProto_Segment(const TensorProto_Segment& from) : TensorProto_Segment(nullptr, from) {}
0862   inline TensorProto_Segment(TensorProto_Segment&& from) noexcept
0863       : TensorProto_Segment(nullptr, ::std::move(from)) {}
0864   inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
0865     CopyFrom(from);
0866     return *this;
0867   }
0868   inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
0869     if (this == &from) return *this;
0870     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
0871       InternalSwap(&from);
0872     } else {
0873       CopyFrom(from);
0874     }
0875     return *this;
0876   }
0877 
0878   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0879       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0880     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0881   }
0882   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
0883       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0884     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0885   }
0886 
0887   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
0888     return GetDescriptor();
0889   }
0890   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
0891     return default_instance().GetMetadata().descriptor;
0892   }
0893   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
0894     return default_instance().GetMetadata().reflection;
0895   }
0896   static const TensorProto_Segment& default_instance() {
0897     return *reinterpret_cast<const TensorProto_Segment*>(
0898         &_TensorProto_Segment_default_instance_);
0899   }
0900   static constexpr int kIndexInFileMessages = 8;
0901   friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) { a.Swap(&b); }
0902   inline void Swap(TensorProto_Segment* PROTOBUF_NONNULL other) {
0903     if (other == this) return;
0904     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
0905       InternalSwap(other);
0906     } else {
0907       ::google::protobuf::internal::GenericSwap(this, other);
0908     }
0909   }
0910   void UnsafeArenaSwap(TensorProto_Segment* PROTOBUF_NONNULL other) {
0911     if (other == this) return;
0912     ABSL_DCHECK(GetArena() == other->GetArena());
0913     InternalSwap(other);
0914   }
0915 
0916   // implements Message ----------------------------------------------
0917 
0918   TensorProto_Segment* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
0919     return ::google::protobuf::Message::DefaultConstruct<TensorProto_Segment>(arena);
0920   }
0921   using ::google::protobuf::Message::CopyFrom;
0922   void CopyFrom(const TensorProto_Segment& from);
0923   using ::google::protobuf::Message::MergeFrom;
0924   void MergeFrom(const TensorProto_Segment& from) { TensorProto_Segment::MergeImpl(*this, from); }
0925 
0926   private:
0927   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
0928                         const ::google::protobuf::MessageLite& from_msg);
0929 
0930   public:
0931   bool IsInitialized() const {
0932     return true;
0933   }
0934   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0935   #if defined(PROTOBUF_CUSTOM_VTABLE)
0936   private:
0937   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0938   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0939       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
0940       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
0941 
0942   public:
0943   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0944   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0945       ::uint8_t* PROTOBUF_NONNULL target,
0946       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
0947     return _InternalSerialize(*this, target, stream);
0948   }
0949   #else   // PROTOBUF_CUSTOM_VTABLE
0950   ::size_t ByteSizeLong() const final;
0951   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
0952       ::uint8_t* PROTOBUF_NONNULL target,
0953       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
0954   #endif  // PROTOBUF_CUSTOM_VTABLE
0955   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0956 
0957   private:
0958   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0959   static void SharedDtor(MessageLite& self);
0960   void InternalSwap(TensorProto_Segment* PROTOBUF_NONNULL other);
0961  private:
0962   template <typename T>
0963   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
0964   static ::absl::string_view FullMessageName() { return "onnx.TensorProto.Segment"; }
0965 
0966  protected:
0967   explicit TensorProto_Segment(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0968   TensorProto_Segment(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorProto_Segment& from);
0969   TensorProto_Segment(
0970       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorProto_Segment&& from) noexcept
0971       : TensorProto_Segment(arena) {
0972     *this = ::std::move(from);
0973   }
0974   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
0975   static void* PROTOBUF_NONNULL PlacementNew_(
0976       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
0977       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
0978   static constexpr auto InternalNewImpl_();
0979 
0980  public:
0981   static constexpr auto InternalGenerateClassData_();
0982 
0983   ::google::protobuf::Metadata GetMetadata() const;
0984   // nested types ----------------------------------------------------
0985 
0986   // accessors -------------------------------------------------------
0987   enum : int {
0988     kBeginFieldNumber = 1,
0989     kEndFieldNumber = 2,
0990   };
0991   // optional int64 begin = 1;
0992   bool has_begin() const;
0993   void clear_begin() ;
0994   ::int64_t begin() const;
0995   void set_begin(::int64_t value);
0996 
0997   private:
0998   ::int64_t _internal_begin() const;
0999   void _internal_set_begin(::int64_t value);
1000 
1001   public:
1002   // optional int64 end = 2;
1003   bool has_end() const;
1004   void clear_end() ;
1005   ::int64_t end() const;
1006   void set_end(::int64_t value);
1007 
1008   private:
1009   ::int64_t _internal_end() const;
1010   void _internal_set_end(::int64_t value);
1011 
1012   public:
1013   // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment)
1014  private:
1015   class _Internal;
1016   friend class ::google::protobuf::internal::TcParser;
1017   static const ::google::protobuf::internal::TcParseTable<1, 2,
1018                                    0, 0,
1019                                    2>
1020       _table_;
1021 
1022   friend class ::google::protobuf::MessageLite;
1023   friend class ::google::protobuf::Arena;
1024   template <typename T>
1025   friend class ::google::protobuf::Arena::InternalHelper;
1026   using InternalArenaConstructable_ = void;
1027   using DestructorSkippable_ = void;
1028   struct Impl_ {
1029     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1030     inline explicit Impl_(
1031         ::google::protobuf::internal::InternalVisibility visibility,
1032         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1033     inline explicit Impl_(
1034         ::google::protobuf::internal::InternalVisibility visibility,
1035         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1036         const TensorProto_Segment& from_msg);
1037     ::google::protobuf::internal::HasBits<1> _has_bits_;
1038     ::google::protobuf::internal::CachedSize _cached_size_;
1039     ::int64_t begin_;
1040     ::int64_t end_;
1041     PROTOBUF_TSAN_DECLARE_MEMBER
1042   };
1043   union { Impl_ _impl_; };
1044   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1045 };
1046 
1047 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorProto_Segment_class_data_;
1048 // -------------------------------------------------------------------
1049 
1050 class ONNX_API StringStringEntryProto final : public ::google::protobuf::Message
1051 /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
1052  public:
1053   inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
1054   ~StringStringEntryProto() PROTOBUF_FINAL;
1055 
1056 #if defined(PROTOBUF_CUSTOM_VTABLE)
1057   void operator delete(StringStringEntryProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
1058     SharedDtor(*msg);
1059     ::google::protobuf::internal::SizedDelete(msg, sizeof(StringStringEntryProto));
1060   }
1061 #endif
1062 
1063   template <typename = void>
1064   explicit PROTOBUF_CONSTEXPR StringStringEntryProto(::google::protobuf::internal::ConstantInitialized);
1065 
1066   inline StringStringEntryProto(const StringStringEntryProto& from) : StringStringEntryProto(nullptr, from) {}
1067   inline StringStringEntryProto(StringStringEntryProto&& from) noexcept
1068       : StringStringEntryProto(nullptr, ::std::move(from)) {}
1069   inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
1070     CopyFrom(from);
1071     return *this;
1072   }
1073   inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
1074     if (this == &from) return *this;
1075     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
1076       InternalSwap(&from);
1077     } else {
1078       CopyFrom(from);
1079     }
1080     return *this;
1081   }
1082 
1083   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1084       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1085     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1086   }
1087   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
1088       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1089     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1090   }
1091 
1092   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
1093     return GetDescriptor();
1094   }
1095   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
1096     return default_instance().GetMetadata().descriptor;
1097   }
1098   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
1099     return default_instance().GetMetadata().reflection;
1100   }
1101   static const StringStringEntryProto& default_instance() {
1102     return *reinterpret_cast<const StringStringEntryProto*>(
1103         &_StringStringEntryProto_default_instance_);
1104   }
1105   static constexpr int kIndexInFileMessages = 5;
1106   friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) { a.Swap(&b); }
1107   inline void Swap(StringStringEntryProto* PROTOBUF_NONNULL other) {
1108     if (other == this) return;
1109     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
1110       InternalSwap(other);
1111     } else {
1112       ::google::protobuf::internal::GenericSwap(this, other);
1113     }
1114   }
1115   void UnsafeArenaSwap(StringStringEntryProto* PROTOBUF_NONNULL other) {
1116     if (other == this) return;
1117     ABSL_DCHECK(GetArena() == other->GetArena());
1118     InternalSwap(other);
1119   }
1120 
1121   // implements Message ----------------------------------------------
1122 
1123   StringStringEntryProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
1124     return ::google::protobuf::Message::DefaultConstruct<StringStringEntryProto>(arena);
1125   }
1126   using ::google::protobuf::Message::CopyFrom;
1127   void CopyFrom(const StringStringEntryProto& from);
1128   using ::google::protobuf::Message::MergeFrom;
1129   void MergeFrom(const StringStringEntryProto& from) { StringStringEntryProto::MergeImpl(*this, from); }
1130 
1131   private:
1132   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
1133                         const ::google::protobuf::MessageLite& from_msg);
1134 
1135   public:
1136   bool IsInitialized() const {
1137     return true;
1138   }
1139   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1140   #if defined(PROTOBUF_CUSTOM_VTABLE)
1141   private:
1142   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1143   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1144       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
1145       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
1146 
1147   public:
1148   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1149   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1150       ::uint8_t* PROTOBUF_NONNULL target,
1151       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
1152     return _InternalSerialize(*this, target, stream);
1153   }
1154   #else   // PROTOBUF_CUSTOM_VTABLE
1155   ::size_t ByteSizeLong() const final;
1156   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1157       ::uint8_t* PROTOBUF_NONNULL target,
1158       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
1159   #endif  // PROTOBUF_CUSTOM_VTABLE
1160   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1161 
1162   private:
1163   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1164   static void SharedDtor(MessageLite& self);
1165   void InternalSwap(StringStringEntryProto* PROTOBUF_NONNULL other);
1166  private:
1167   template <typename T>
1168   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
1169   static ::absl::string_view FullMessageName() { return "onnx.StringStringEntryProto"; }
1170 
1171  protected:
1172   explicit StringStringEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1173   StringStringEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StringStringEntryProto& from);
1174   StringStringEntryProto(
1175       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StringStringEntryProto&& from) noexcept
1176       : StringStringEntryProto(arena) {
1177     *this = ::std::move(from);
1178   }
1179   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
1180   static void* PROTOBUF_NONNULL PlacementNew_(
1181       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
1182       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1183   static constexpr auto InternalNewImpl_();
1184 
1185  public:
1186   static constexpr auto InternalGenerateClassData_();
1187 
1188   ::google::protobuf::Metadata GetMetadata() const;
1189   // nested types ----------------------------------------------------
1190 
1191   // accessors -------------------------------------------------------
1192   enum : int {
1193     kKeyFieldNumber = 1,
1194     kValueFieldNumber = 2,
1195   };
1196   // optional string key = 1;
1197   bool has_key() const;
1198   void clear_key() ;
1199   const ::std::string& key() const;
1200   template <typename Arg_ = const ::std::string&, typename... Args_>
1201   void set_key(Arg_&& arg, Args_... args);
1202   ::std::string* PROTOBUF_NONNULL mutable_key();
1203   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key();
1204   void set_allocated_key(::std::string* PROTOBUF_NULLABLE value);
1205 
1206   private:
1207   const ::std::string& _internal_key() const;
1208   PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value);
1209   ::std::string* PROTOBUF_NONNULL _internal_mutable_key();
1210 
1211   public:
1212   // optional string value = 2;
1213   bool has_value() const;
1214   void clear_value() ;
1215   const ::std::string& value() const;
1216   template <typename Arg_ = const ::std::string&, typename... Args_>
1217   void set_value(Arg_&& arg, Args_... args);
1218   ::std::string* PROTOBUF_NONNULL mutable_value();
1219   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_value();
1220   void set_allocated_value(::std::string* PROTOBUF_NULLABLE value);
1221 
1222   private:
1223   const ::std::string& _internal_value() const;
1224   PROTOBUF_ALWAYS_INLINE void _internal_set_value(const ::std::string& value);
1225   ::std::string* PROTOBUF_NONNULL _internal_mutable_value();
1226 
1227   public:
1228   // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto)
1229  private:
1230   class _Internal;
1231   friend class ::google::protobuf::internal::TcParser;
1232   static const ::google::protobuf::internal::TcParseTable<1, 2,
1233                                    0, 44,
1234                                    2>
1235       _table_;
1236 
1237   friend class ::google::protobuf::MessageLite;
1238   friend class ::google::protobuf::Arena;
1239   template <typename T>
1240   friend class ::google::protobuf::Arena::InternalHelper;
1241   using InternalArenaConstructable_ = void;
1242   using DestructorSkippable_ = void;
1243   struct Impl_ {
1244     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1245     inline explicit Impl_(
1246         ::google::protobuf::internal::InternalVisibility visibility,
1247         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1248     inline explicit Impl_(
1249         ::google::protobuf::internal::InternalVisibility visibility,
1250         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1251         const StringStringEntryProto& from_msg);
1252     ::google::protobuf::internal::HasBits<1> _has_bits_;
1253     ::google::protobuf::internal::CachedSize _cached_size_;
1254     ::google::protobuf::internal::ArenaStringPtr key_;
1255     ::google::protobuf::internal::ArenaStringPtr value_;
1256     PROTOBUF_TSAN_DECLARE_MEMBER
1257   };
1258   union { Impl_ _impl_; };
1259   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1260 };
1261 
1262 ONNX_API extern const ::google::protobuf::internal::ClassDataFull StringStringEntryProto_class_data_;
1263 // -------------------------------------------------------------------
1264 
1265 class ONNX_API OperatorSetIdProto final : public ::google::protobuf::Message
1266 /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
1267  public:
1268   inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
1269   ~OperatorSetIdProto() PROTOBUF_FINAL;
1270 
1271 #if defined(PROTOBUF_CUSTOM_VTABLE)
1272   void operator delete(OperatorSetIdProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
1273     SharedDtor(*msg);
1274     ::google::protobuf::internal::SizedDelete(msg, sizeof(OperatorSetIdProto));
1275   }
1276 #endif
1277 
1278   template <typename = void>
1279   explicit PROTOBUF_CONSTEXPR OperatorSetIdProto(::google::protobuf::internal::ConstantInitialized);
1280 
1281   inline OperatorSetIdProto(const OperatorSetIdProto& from) : OperatorSetIdProto(nullptr, from) {}
1282   inline OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
1283       : OperatorSetIdProto(nullptr, ::std::move(from)) {}
1284   inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
1285     CopyFrom(from);
1286     return *this;
1287   }
1288   inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
1289     if (this == &from) return *this;
1290     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
1291       InternalSwap(&from);
1292     } else {
1293       CopyFrom(from);
1294     }
1295     return *this;
1296   }
1297 
1298   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1299       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1300     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1301   }
1302   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
1303       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1304     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1305   }
1306 
1307   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
1308     return GetDescriptor();
1309   }
1310   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
1311     return default_instance().GetMetadata().descriptor;
1312   }
1313   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
1314     return default_instance().GetMetadata().reflection;
1315   }
1316   static const OperatorSetIdProto& default_instance() {
1317     return *reinterpret_cast<const OperatorSetIdProto*>(
1318         &_OperatorSetIdProto_default_instance_);
1319   }
1320   static constexpr int kIndexInFileMessages = 20;
1321   friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) { a.Swap(&b); }
1322   inline void Swap(OperatorSetIdProto* PROTOBUF_NONNULL other) {
1323     if (other == this) return;
1324     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
1325       InternalSwap(other);
1326     } else {
1327       ::google::protobuf::internal::GenericSwap(this, other);
1328     }
1329   }
1330   void UnsafeArenaSwap(OperatorSetIdProto* PROTOBUF_NONNULL other) {
1331     if (other == this) return;
1332     ABSL_DCHECK(GetArena() == other->GetArena());
1333     InternalSwap(other);
1334   }
1335 
1336   // implements Message ----------------------------------------------
1337 
1338   OperatorSetIdProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
1339     return ::google::protobuf::Message::DefaultConstruct<OperatorSetIdProto>(arena);
1340   }
1341   using ::google::protobuf::Message::CopyFrom;
1342   void CopyFrom(const OperatorSetIdProto& from);
1343   using ::google::protobuf::Message::MergeFrom;
1344   void MergeFrom(const OperatorSetIdProto& from) { OperatorSetIdProto::MergeImpl(*this, from); }
1345 
1346   private:
1347   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
1348                         const ::google::protobuf::MessageLite& from_msg);
1349 
1350   public:
1351   bool IsInitialized() const {
1352     return true;
1353   }
1354   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1355   #if defined(PROTOBUF_CUSTOM_VTABLE)
1356   private:
1357   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1358   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1359       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
1360       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
1361 
1362   public:
1363   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1364   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1365       ::uint8_t* PROTOBUF_NONNULL target,
1366       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
1367     return _InternalSerialize(*this, target, stream);
1368   }
1369   #else   // PROTOBUF_CUSTOM_VTABLE
1370   ::size_t ByteSizeLong() const final;
1371   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1372       ::uint8_t* PROTOBUF_NONNULL target,
1373       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
1374   #endif  // PROTOBUF_CUSTOM_VTABLE
1375   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1376 
1377   private:
1378   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1379   static void SharedDtor(MessageLite& self);
1380   void InternalSwap(OperatorSetIdProto* PROTOBUF_NONNULL other);
1381  private:
1382   template <typename T>
1383   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
1384   static ::absl::string_view FullMessageName() { return "onnx.OperatorSetIdProto"; }
1385 
1386  protected:
1387   explicit OperatorSetIdProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1388   OperatorSetIdProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OperatorSetIdProto& from);
1389   OperatorSetIdProto(
1390       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OperatorSetIdProto&& from) noexcept
1391       : OperatorSetIdProto(arena) {
1392     *this = ::std::move(from);
1393   }
1394   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
1395   static void* PROTOBUF_NONNULL PlacementNew_(
1396       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
1397       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1398   static constexpr auto InternalNewImpl_();
1399 
1400  public:
1401   static constexpr auto InternalGenerateClassData_();
1402 
1403   ::google::protobuf::Metadata GetMetadata() const;
1404   // nested types ----------------------------------------------------
1405 
1406   // accessors -------------------------------------------------------
1407   enum : int {
1408     kDomainFieldNumber = 1,
1409     kVersionFieldNumber = 2,
1410   };
1411   // optional string domain = 1;
1412   bool has_domain() const;
1413   void clear_domain() ;
1414   const ::std::string& domain() const;
1415   template <typename Arg_ = const ::std::string&, typename... Args_>
1416   void set_domain(Arg_&& arg, Args_... args);
1417   ::std::string* PROTOBUF_NONNULL mutable_domain();
1418   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
1419   void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);
1420 
1421   private:
1422   const ::std::string& _internal_domain() const;
1423   PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
1424   ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();
1425 
1426   public:
1427   // optional int64 version = 2;
1428   bool has_version() const;
1429   void clear_version() ;
1430   ::int64_t version() const;
1431   void set_version(::int64_t value);
1432 
1433   private:
1434   ::int64_t _internal_version() const;
1435   void _internal_set_version(::int64_t value);
1436 
1437   public:
1438   // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto)
1439  private:
1440   class _Internal;
1441   friend class ::google::protobuf::internal::TcParser;
1442   static const ::google::protobuf::internal::TcParseTable<1, 2,
1443                                    0, 38,
1444                                    2>
1445       _table_;
1446 
1447   friend class ::google::protobuf::MessageLite;
1448   friend class ::google::protobuf::Arena;
1449   template <typename T>
1450   friend class ::google::protobuf::Arena::InternalHelper;
1451   using InternalArenaConstructable_ = void;
1452   using DestructorSkippable_ = void;
1453   struct Impl_ {
1454     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1455     inline explicit Impl_(
1456         ::google::protobuf::internal::InternalVisibility visibility,
1457         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1458     inline explicit Impl_(
1459         ::google::protobuf::internal::InternalVisibility visibility,
1460         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1461         const OperatorSetIdProto& from_msg);
1462     ::google::protobuf::internal::HasBits<1> _has_bits_;
1463     ::google::protobuf::internal::CachedSize _cached_size_;
1464     ::google::protobuf::internal::ArenaStringPtr domain_;
1465     ::int64_t version_;
1466     PROTOBUF_TSAN_DECLARE_MEMBER
1467   };
1468   union { Impl_ _impl_; };
1469   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1470 };
1471 
1472 ONNX_API extern const ::google::protobuf::internal::ClassDataFull OperatorSetIdProto_class_data_;
1473 // -------------------------------------------------------------------
1474 
1475 class ONNX_API TensorShapeProto final : public ::google::protobuf::Message
1476 /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
1477  public:
1478   inline TensorShapeProto() : TensorShapeProto(nullptr) {}
1479   ~TensorShapeProto() PROTOBUF_FINAL;
1480 
1481 #if defined(PROTOBUF_CUSTOM_VTABLE)
1482   void operator delete(TensorShapeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
1483     SharedDtor(*msg);
1484     ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorShapeProto));
1485   }
1486 #endif
1487 
1488   template <typename = void>
1489   explicit PROTOBUF_CONSTEXPR TensorShapeProto(::google::protobuf::internal::ConstantInitialized);
1490 
1491   inline TensorShapeProto(const TensorShapeProto& from) : TensorShapeProto(nullptr, from) {}
1492   inline TensorShapeProto(TensorShapeProto&& from) noexcept
1493       : TensorShapeProto(nullptr, ::std::move(from)) {}
1494   inline TensorShapeProto& operator=(const TensorShapeProto& from) {
1495     CopyFrom(from);
1496     return *this;
1497   }
1498   inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
1499     if (this == &from) return *this;
1500     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
1501       InternalSwap(&from);
1502     } else {
1503       CopyFrom(from);
1504     }
1505     return *this;
1506   }
1507 
1508   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1509       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1510     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1511   }
1512   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
1513       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1514     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1515   }
1516 
1517   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
1518     return GetDescriptor();
1519   }
1520   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
1521     return default_instance().GetMetadata().descriptor;
1522   }
1523   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
1524     return default_instance().GetMetadata().reflection;
1525   }
1526   static const TensorShapeProto& default_instance() {
1527     return *reinterpret_cast<const TensorShapeProto*>(
1528         &_TensorShapeProto_default_instance_);
1529   }
1530   static constexpr int kIndexInFileMessages = 12;
1531   friend void swap(TensorShapeProto& a, TensorShapeProto& b) { a.Swap(&b); }
1532   inline void Swap(TensorShapeProto* PROTOBUF_NONNULL other) {
1533     if (other == this) return;
1534     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
1535       InternalSwap(other);
1536     } else {
1537       ::google::protobuf::internal::GenericSwap(this, other);
1538     }
1539   }
1540   void UnsafeArenaSwap(TensorShapeProto* PROTOBUF_NONNULL other) {
1541     if (other == this) return;
1542     ABSL_DCHECK(GetArena() == other->GetArena());
1543     InternalSwap(other);
1544   }
1545 
1546   // implements Message ----------------------------------------------
1547 
1548   TensorShapeProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
1549     return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto>(arena);
1550   }
1551   using ::google::protobuf::Message::CopyFrom;
1552   void CopyFrom(const TensorShapeProto& from);
1553   using ::google::protobuf::Message::MergeFrom;
1554   void MergeFrom(const TensorShapeProto& from) { TensorShapeProto::MergeImpl(*this, from); }
1555 
1556   private:
1557   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
1558                         const ::google::protobuf::MessageLite& from_msg);
1559 
1560   public:
1561   bool IsInitialized() const {
1562     return true;
1563   }
1564   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1565   #if defined(PROTOBUF_CUSTOM_VTABLE)
1566   private:
1567   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1568   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1569       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
1570       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
1571 
1572   public:
1573   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1574   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1575       ::uint8_t* PROTOBUF_NONNULL target,
1576       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
1577     return _InternalSerialize(*this, target, stream);
1578   }
1579   #else   // PROTOBUF_CUSTOM_VTABLE
1580   ::size_t ByteSizeLong() const final;
1581   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1582       ::uint8_t* PROTOBUF_NONNULL target,
1583       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
1584   #endif  // PROTOBUF_CUSTOM_VTABLE
1585   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1586 
1587   private:
1588   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1589   static void SharedDtor(MessageLite& self);
1590   void InternalSwap(TensorShapeProto* PROTOBUF_NONNULL other);
1591  private:
1592   template <typename T>
1593   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
1594   static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto"; }
1595 
1596  protected:
1597   explicit TensorShapeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1598   TensorShapeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorShapeProto& from);
1599   TensorShapeProto(
1600       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorShapeProto&& from) noexcept
1601       : TensorShapeProto(arena) {
1602     *this = ::std::move(from);
1603   }
1604   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
1605   static void* PROTOBUF_NONNULL PlacementNew_(
1606       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
1607       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1608   static constexpr auto InternalNewImpl_();
1609 
1610  public:
1611   static constexpr auto InternalGenerateClassData_();
1612 
1613   ::google::protobuf::Metadata GetMetadata() const;
1614   // nested types ----------------------------------------------------
1615   using Dimension = TensorShapeProto_Dimension;
1616 
1617   // accessors -------------------------------------------------------
1618   enum : int {
1619     kDimFieldNumber = 1,
1620   };
1621   // repeated .onnx.TensorShapeProto.Dimension dim = 1;
1622   int dim_size() const;
1623   private:
1624   int _internal_dim_size() const;
1625 
1626   public:
1627   void clear_dim() ;
1628   ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL mutable_dim(int index);
1629   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL mutable_dim();
1630 
1631   private:
1632   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& _internal_dim() const;
1633   ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL _internal_mutable_dim();
1634   public:
1635   const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
1636   ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL add_dim();
1637   const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& dim() const;
1638   // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
1639  private:
1640   class _Internal;
1641   friend class ::google::protobuf::internal::TcParser;
1642   static const ::google::protobuf::internal::TcParseTable<0, 1,
1643                                    1, 0,
1644                                    2>
1645       _table_;
1646 
1647   friend class ::google::protobuf::MessageLite;
1648   friend class ::google::protobuf::Arena;
1649   template <typename T>
1650   friend class ::google::protobuf::Arena::InternalHelper;
1651   using InternalArenaConstructable_ = void;
1652   using DestructorSkippable_ = void;
1653   struct Impl_ {
1654     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1655     inline explicit Impl_(
1656         ::google::protobuf::internal::InternalVisibility visibility,
1657         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1658     inline explicit Impl_(
1659         ::google::protobuf::internal::InternalVisibility visibility,
1660         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1661         const TensorShapeProto& from_msg);
1662     ::google::protobuf::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
1663     ::google::protobuf::internal::CachedSize _cached_size_;
1664     PROTOBUF_TSAN_DECLARE_MEMBER
1665   };
1666   union { Impl_ _impl_; };
1667   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
1668 };
1669 
1670 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_class_data_;
1671 // -------------------------------------------------------------------
1672 
1673 class ONNX_API TensorProto final : public ::google::protobuf::Message
1674 /* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
1675  public:
1676   inline TensorProto() : TensorProto(nullptr) {}
1677   ~TensorProto() PROTOBUF_FINAL;
1678 
1679 #if defined(PROTOBUF_CUSTOM_VTABLE)
1680   void operator delete(TensorProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
1681     SharedDtor(*msg);
1682     ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorProto));
1683   }
1684 #endif
1685 
1686   template <typename = void>
1687   explicit PROTOBUF_CONSTEXPR TensorProto(::google::protobuf::internal::ConstantInitialized);
1688 
1689   inline TensorProto(const TensorProto& from) : TensorProto(nullptr, from) {}
1690   inline TensorProto(TensorProto&& from) noexcept
1691       : TensorProto(nullptr, ::std::move(from)) {}
1692   inline TensorProto& operator=(const TensorProto& from) {
1693     CopyFrom(from);
1694     return *this;
1695   }
1696   inline TensorProto& operator=(TensorProto&& from) noexcept {
1697     if (this == &from) return *this;
1698     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
1699       InternalSwap(&from);
1700     } else {
1701       CopyFrom(from);
1702     }
1703     return *this;
1704   }
1705 
1706   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
1707       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1708     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
1709   }
1710   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
1711       ABSL_ATTRIBUTE_LIFETIME_BOUND {
1712     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
1713   }
1714 
1715   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
1716     return GetDescriptor();
1717   }
1718   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
1719     return default_instance().GetMetadata().descriptor;
1720   }
1721   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
1722     return default_instance().GetMetadata().reflection;
1723   }
1724   static const TensorProto& default_instance() {
1725     return *reinterpret_cast<const TensorProto*>(
1726         &_TensorProto_default_instance_);
1727   }
1728   static constexpr int kIndexInFileMessages = 9;
1729   friend void swap(TensorProto& a, TensorProto& b) { a.Swap(&b); }
1730   inline void Swap(TensorProto* PROTOBUF_NONNULL other) {
1731     if (other == this) return;
1732     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
1733       InternalSwap(other);
1734     } else {
1735       ::google::protobuf::internal::GenericSwap(this, other);
1736     }
1737   }
1738   void UnsafeArenaSwap(TensorProto* PROTOBUF_NONNULL other) {
1739     if (other == this) return;
1740     ABSL_DCHECK(GetArena() == other->GetArena());
1741     InternalSwap(other);
1742   }
1743 
1744   // implements Message ----------------------------------------------
1745 
1746   TensorProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
1747     return ::google::protobuf::Message::DefaultConstruct<TensorProto>(arena);
1748   }
1749   using ::google::protobuf::Message::CopyFrom;
1750   void CopyFrom(const TensorProto& from);
1751   using ::google::protobuf::Message::MergeFrom;
1752   void MergeFrom(const TensorProto& from) { TensorProto::MergeImpl(*this, from); }
1753 
1754   private:
1755   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
1756                         const ::google::protobuf::MessageLite& from_msg);
1757 
1758   public:
1759   bool IsInitialized() const {
1760     return true;
1761   }
1762   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
1763   #if defined(PROTOBUF_CUSTOM_VTABLE)
1764   private:
1765   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
1766   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1767       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
1768       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
1769 
1770   public:
1771   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
1772   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1773       ::uint8_t* PROTOBUF_NONNULL target,
1774       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
1775     return _InternalSerialize(*this, target, stream);
1776   }
1777   #else   // PROTOBUF_CUSTOM_VTABLE
1778   ::size_t ByteSizeLong() const final;
1779   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
1780       ::uint8_t* PROTOBUF_NONNULL target,
1781       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
1782   #endif  // PROTOBUF_CUSTOM_VTABLE
1783   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
1784 
1785   private:
1786   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1787   static void SharedDtor(MessageLite& self);
1788   void InternalSwap(TensorProto* PROTOBUF_NONNULL other);
1789  private:
1790   template <typename T>
1791   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
1792   static ::absl::string_view FullMessageName() { return "onnx.TensorProto"; }
1793 
1794  protected:
1795   explicit TensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1796   TensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorProto& from);
1797   TensorProto(
1798       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorProto&& from) noexcept
1799       : TensorProto(arena) {
1800     *this = ::std::move(from);
1801   }
1802   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
1803   static void* PROTOBUF_NONNULL PlacementNew_(
1804       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
1805       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1806   static constexpr auto InternalNewImpl_();
1807 
1808  public:
1809   static constexpr auto InternalGenerateClassData_();
1810 
1811   ::google::protobuf::Metadata GetMetadata() const;
1812   // nested types ----------------------------------------------------
1813   using Segment = TensorProto_Segment;
1814   using DataType = TensorProto_DataType;
1815   static constexpr DataType UNDEFINED = TensorProto_DataType_UNDEFINED;
1816   static constexpr DataType FLOAT = TensorProto_DataType_FLOAT;
1817   static constexpr DataType UINT8 = TensorProto_DataType_UINT8;
1818   static constexpr DataType INT8 = TensorProto_DataType_INT8;
1819   static constexpr DataType UINT16 = TensorProto_DataType_UINT16;
1820   static constexpr DataType INT16 = TensorProto_DataType_INT16;
1821   static constexpr DataType INT32 = TensorProto_DataType_INT32;
1822   static constexpr DataType INT64 = TensorProto_DataType_INT64;
1823   static constexpr DataType STRING = TensorProto_DataType_STRING;
1824   static constexpr DataType BOOL = TensorProto_DataType_BOOL;
1825   static constexpr DataType FLOAT16 = TensorProto_DataType_FLOAT16;
1826   static constexpr DataType DOUBLE = TensorProto_DataType_DOUBLE;
1827   static constexpr DataType UINT32 = TensorProto_DataType_UINT32;
1828   static constexpr DataType UINT64 = TensorProto_DataType_UINT64;
1829   static constexpr DataType COMPLEX64 = TensorProto_DataType_COMPLEX64;
1830   static constexpr DataType COMPLEX128 = TensorProto_DataType_COMPLEX128;
1831   static constexpr DataType BFLOAT16 = TensorProto_DataType_BFLOAT16;
1832   static constexpr DataType FLOAT8E4M3FN = TensorProto_DataType_FLOAT8E4M3FN;
1833   static constexpr DataType FLOAT8E4M3FNUZ = TensorProto_DataType_FLOAT8E4M3FNUZ;
1834   static constexpr DataType FLOAT8E5M2 = TensorProto_DataType_FLOAT8E5M2;
1835   static constexpr DataType FLOAT8E5M2FNUZ = TensorProto_DataType_FLOAT8E5M2FNUZ;
1836   static constexpr DataType UINT4 = TensorProto_DataType_UINT4;
1837   static constexpr DataType INT4 = TensorProto_DataType_INT4;
1838   static inline bool DataType_IsValid(int value) {
1839     return TensorProto_DataType_IsValid(value);
1840   }
1841   static constexpr DataType DataType_MIN = TensorProto_DataType_DataType_MIN;
1842   static constexpr DataType DataType_MAX = TensorProto_DataType_DataType_MAX;
1843   static constexpr int DataType_ARRAYSIZE = TensorProto_DataType_DataType_ARRAYSIZE;
1844   static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataType_descriptor() {
1845     return TensorProto_DataType_descriptor();
1846   }
1847   template <typename T>
1848   static inline const ::std::string& DataType_Name(T value) {
1849     return TensorProto_DataType_Name(value);
1850   }
1851   static inline bool DataType_Parse(
1852       ::absl::string_view name, DataType* PROTOBUF_NONNULL value) {
1853     return TensorProto_DataType_Parse(name, value);
1854   }
1855   using DataLocation = TensorProto_DataLocation;
1856   static constexpr DataLocation DEFAULT = TensorProto_DataLocation_DEFAULT;
1857   static constexpr DataLocation EXTERNAL = TensorProto_DataLocation_EXTERNAL;
1858   static inline bool DataLocation_IsValid(int value) {
1859     return TensorProto_DataLocation_IsValid(value);
1860   }
1861   static constexpr DataLocation DataLocation_MIN = TensorProto_DataLocation_DataLocation_MIN;
1862   static constexpr DataLocation DataLocation_MAX = TensorProto_DataLocation_DataLocation_MAX;
1863   static constexpr int DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_ARRAYSIZE;
1864   static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataLocation_descriptor() {
1865     return TensorProto_DataLocation_descriptor();
1866   }
1867   template <typename T>
1868   static inline const ::std::string& DataLocation_Name(T value) {
1869     return TensorProto_DataLocation_Name(value);
1870   }
1871   static inline bool DataLocation_Parse(
1872       ::absl::string_view name, DataLocation* PROTOBUF_NONNULL value) {
1873     return TensorProto_DataLocation_Parse(name, value);
1874   }
1875 
1876   // accessors -------------------------------------------------------
1877   enum : int {
1878     kDimsFieldNumber = 1,
1879     kFloatDataFieldNumber = 4,
1880     kInt32DataFieldNumber = 5,
1881     kStringDataFieldNumber = 6,
1882     kInt64DataFieldNumber = 7,
1883     kDoubleDataFieldNumber = 10,
1884     kUint64DataFieldNumber = 11,
1885     kExternalDataFieldNumber = 13,
1886     kMetadataPropsFieldNumber = 16,
1887     kNameFieldNumber = 8,
1888     kRawDataFieldNumber = 9,
1889     kDocStringFieldNumber = 12,
1890     kSegmentFieldNumber = 3,
1891     kDataTypeFieldNumber = 2,
1892     kDataLocationFieldNumber = 14,
1893   };
1894   // repeated int64 dims = 1;
1895   int dims_size() const;
1896   private:
1897   int _internal_dims_size() const;
1898 
1899   public:
1900   void clear_dims() ;
1901   ::int64_t dims(int index) const;
1902   void set_dims(int index, ::int64_t value);
1903   void add_dims(::int64_t value);
1904   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
1905   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_dims();
1906 
1907   private:
1908   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
1909   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_dims();
1910 
1911   public:
1912   // repeated float float_data = 4 [packed = true];
1913   int float_data_size() const;
1914   private:
1915   int _internal_float_data_size() const;
1916 
1917   public:
1918   void clear_float_data() ;
1919   float float_data(int index) const;
1920   void set_float_data(int index, float value);
1921   void add_float_data(float value);
1922   const ::google::protobuf::RepeatedField<float>& float_data() const;
1923   ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL mutable_float_data();
1924 
1925   private:
1926   const ::google::protobuf::RepeatedField<float>& _internal_float_data() const;
1927   ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL _internal_mutable_float_data();
1928 
1929   public:
1930   // repeated int32 int32_data = 5 [packed = true];
1931   int int32_data_size() const;
1932   private:
1933   int _internal_int32_data_size() const;
1934 
1935   public:
1936   void clear_int32_data() ;
1937   ::int32_t int32_data(int index) const;
1938   void set_int32_data(int index, ::int32_t value);
1939   void add_int32_data(::int32_t value);
1940   const ::google::protobuf::RepeatedField<::int32_t>& int32_data() const;
1941   ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL mutable_int32_data();
1942 
1943   private:
1944   const ::google::protobuf::RepeatedField<::int32_t>& _internal_int32_data() const;
1945   ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL _internal_mutable_int32_data();
1946 
1947   public:
1948   // repeated bytes string_data = 6;
1949   int string_data_size() const;
1950   private:
1951   int _internal_string_data_size() const;
1952 
1953   public:
1954   void clear_string_data() ;
1955   const ::std::string& string_data(int index) const;
1956   ::std::string* PROTOBUF_NONNULL mutable_string_data(int index);
1957   template <typename Arg_ = const ::std::string&, typename... Args_>
1958   void set_string_data(int index, Arg_&& value, Args_... args);
1959   ::std::string* PROTOBUF_NONNULL add_string_data();
1960   template <typename Arg_ = const ::std::string&, typename... Args_>
1961   void add_string_data(Arg_&& value, Args_... args);
1962   const ::google::protobuf::RepeatedPtrField<::std::string>& string_data() const;
1963   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_string_data();
1964 
1965   private:
1966   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_string_data() const;
1967   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_string_data();
1968 
1969   public:
1970   // repeated int64 int64_data = 7 [packed = true];
1971   int int64_data_size() const;
1972   private:
1973   int _internal_int64_data_size() const;
1974 
1975   public:
1976   void clear_int64_data() ;
1977   ::int64_t int64_data(int index) const;
1978   void set_int64_data(int index, ::int64_t value);
1979   void add_int64_data(::int64_t value);
1980   const ::google::protobuf::RepeatedField<::int64_t>& int64_data() const;
1981   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_int64_data();
1982 
1983   private:
1984   const ::google::protobuf::RepeatedField<::int64_t>& _internal_int64_data() const;
1985   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_int64_data();
1986 
1987   public:
1988   // repeated double double_data = 10 [packed = true];
1989   int double_data_size() const;
1990   private:
1991   int _internal_double_data_size() const;
1992 
1993   public:
1994   void clear_double_data() ;
1995   double double_data(int index) const;
1996   void set_double_data(int index, double value);
1997   void add_double_data(double value);
1998   const ::google::protobuf::RepeatedField<double>& double_data() const;
1999   ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL mutable_double_data();
2000 
2001   private:
2002   const ::google::protobuf::RepeatedField<double>& _internal_double_data() const;
2003   ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL _internal_mutable_double_data();
2004 
2005   public:
2006   // repeated uint64 uint64_data = 11 [packed = true];
2007   int uint64_data_size() const;
2008   private:
2009   int _internal_uint64_data_size() const;
2010 
2011   public:
2012   void clear_uint64_data() ;
2013   ::uint64_t uint64_data(int index) const;
2014   void set_uint64_data(int index, ::uint64_t value);
2015   void add_uint64_data(::uint64_t value);
2016   const ::google::protobuf::RepeatedField<::uint64_t>& uint64_data() const;
2017   ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL mutable_uint64_data();
2018 
2019   private:
2020   const ::google::protobuf::RepeatedField<::uint64_t>& _internal_uint64_data() const;
2021   ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL _internal_mutable_uint64_data();
2022 
2023   public:
2024   // repeated .onnx.StringStringEntryProto external_data = 13;
2025   int external_data_size() const;
2026   private:
2027   int _internal_external_data_size() const;
2028 
2029   public:
2030   void clear_external_data() ;
2031   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_external_data(int index);
2032   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_external_data();
2033 
2034   private:
2035   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_external_data() const;
2036   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_external_data();
2037   public:
2038   const ::onnx::StringStringEntryProto& external_data(int index) const;
2039   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_external_data();
2040   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& external_data() const;
2041   // repeated .onnx.StringStringEntryProto metadata_props = 16;
2042   int metadata_props_size() const;
2043   private:
2044   int _internal_metadata_props_size() const;
2045 
2046   public:
2047   void clear_metadata_props() ;
2048   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
2049   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
2050 
2051   private:
2052   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
2053   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
2054   public:
2055   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
2056   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
2057   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
2058   // optional string name = 8;
2059   bool has_name() const;
2060   void clear_name() ;
2061   const ::std::string& name() const;
2062   template <typename Arg_ = const ::std::string&, typename... Args_>
2063   void set_name(Arg_&& arg, Args_... args);
2064   ::std::string* PROTOBUF_NONNULL mutable_name();
2065   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
2066   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
2067 
2068   private:
2069   const ::std::string& _internal_name() const;
2070   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
2071   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
2072 
2073   public:
2074   // optional bytes raw_data = 9;
2075   bool has_raw_data() const;
2076   void clear_raw_data() ;
2077   const ::std::string& raw_data() const;
2078   template <typename Arg_ = const ::std::string&, typename... Args_>
2079   void set_raw_data(Arg_&& arg, Args_... args);
2080   ::std::string* PROTOBUF_NONNULL mutable_raw_data();
2081   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_raw_data();
2082   void set_allocated_raw_data(::std::string* PROTOBUF_NULLABLE value);
2083 
2084   private:
2085   const ::std::string& _internal_raw_data() const;
2086   PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const ::std::string& value);
2087   ::std::string* PROTOBUF_NONNULL _internal_mutable_raw_data();
2088 
2089   public:
2090   // optional string doc_string = 12;
2091   bool has_doc_string() const;
2092   void clear_doc_string() ;
2093   const ::std::string& doc_string() const;
2094   template <typename Arg_ = const ::std::string&, typename... Args_>
2095   void set_doc_string(Arg_&& arg, Args_... args);
2096   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
2097   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
2098   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
2099 
2100   private:
2101   const ::std::string& _internal_doc_string() const;
2102   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
2103   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
2104 
2105   public:
2106   // optional .onnx.TensorProto.Segment segment = 3;
2107   bool has_segment() const;
2108   void clear_segment() ;
2109   const ::onnx::TensorProto_Segment& segment() const;
2110   [[nodiscard]] ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE release_segment();
2111   ::onnx::TensorProto_Segment* PROTOBUF_NONNULL mutable_segment();
2112   void set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value);
2113   void unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value);
2114   ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE unsafe_arena_release_segment();
2115 
2116   private:
2117   const ::onnx::TensorProto_Segment& _internal_segment() const;
2118   ::onnx::TensorProto_Segment* PROTOBUF_NONNULL _internal_mutable_segment();
2119 
2120   public:
2121   // optional int32 data_type = 2;
2122   bool has_data_type() const;
2123   void clear_data_type() ;
2124   ::int32_t data_type() const;
2125   void set_data_type(::int32_t value);
2126 
2127   private:
2128   ::int32_t _internal_data_type() const;
2129   void _internal_set_data_type(::int32_t value);
2130 
2131   public:
2132   // optional .onnx.TensorProto.DataLocation data_location = 14;
2133   bool has_data_location() const;
2134   void clear_data_location() ;
2135   ::onnx::TensorProto_DataLocation data_location() const;
2136   void set_data_location(::onnx::TensorProto_DataLocation value);
2137 
2138   private:
2139   ::onnx::TensorProto_DataLocation _internal_data_location() const;
2140   void _internal_set_data_location(::onnx::TensorProto_DataLocation value);
2141 
2142   public:
2143   // @@protoc_insertion_point(class_scope:onnx.TensorProto)
2144  private:
2145   class _Internal;
2146   friend class ::google::protobuf::internal::TcParser;
2147   static const ::google::protobuf::internal::TcParseTable<4, 15,
2148                                    4, 47,
2149                                    2>
2150       _table_;
2151 
2152   friend class ::google::protobuf::MessageLite;
2153   friend class ::google::protobuf::Arena;
2154   template <typename T>
2155   friend class ::google::protobuf::Arena::InternalHelper;
2156   using InternalArenaConstructable_ = void;
2157   using DestructorSkippable_ = void;
2158   struct Impl_ {
2159     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
2160     inline explicit Impl_(
2161         ::google::protobuf::internal::InternalVisibility visibility,
2162         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2163     inline explicit Impl_(
2164         ::google::protobuf::internal::InternalVisibility visibility,
2165         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
2166         const TensorProto& from_msg);
2167     ::google::protobuf::internal::HasBits<1> _has_bits_;
2168     ::google::protobuf::internal::CachedSize _cached_size_;
2169     ::google::protobuf::RepeatedField<::int64_t> dims_;
2170     ::google::protobuf::RepeatedField<float> float_data_;
2171     ::google::protobuf::RepeatedField<::int32_t> int32_data_;
2172     ::google::protobuf::internal::CachedSize _int32_data_cached_byte_size_;
2173     ::google::protobuf::RepeatedPtrField<::std::string> string_data_;
2174     ::google::protobuf::RepeatedField<::int64_t> int64_data_;
2175     ::google::protobuf::internal::CachedSize _int64_data_cached_byte_size_;
2176     ::google::protobuf::RepeatedField<double> double_data_;
2177     ::google::protobuf::RepeatedField<::uint64_t> uint64_data_;
2178     ::google::protobuf::internal::CachedSize _uint64_data_cached_byte_size_;
2179     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
2180     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
2181     ::google::protobuf::internal::ArenaStringPtr name_;
2182     ::google::protobuf::internal::ArenaStringPtr raw_data_;
2183     ::google::protobuf::internal::ArenaStringPtr doc_string_;
2184     ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE segment_;
2185     ::int32_t data_type_;
2186     int data_location_;
2187     PROTOBUF_TSAN_DECLARE_MEMBER
2188   };
2189   union { Impl_ _impl_; };
2190   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2191 };
2192 
2193 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorProto_class_data_;
2194 // -------------------------------------------------------------------
2195 
2196 class ONNX_API TensorAnnotation final : public ::google::protobuf::Message
2197 /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
2198  public:
2199   inline TensorAnnotation() : TensorAnnotation(nullptr) {}
2200   ~TensorAnnotation() PROTOBUF_FINAL;
2201 
2202 #if defined(PROTOBUF_CUSTOM_VTABLE)
2203   void operator delete(TensorAnnotation* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
2204     SharedDtor(*msg);
2205     ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorAnnotation));
2206   }
2207 #endif
2208 
2209   template <typename = void>
2210   explicit PROTOBUF_CONSTEXPR TensorAnnotation(::google::protobuf::internal::ConstantInitialized);
2211 
2212   inline TensorAnnotation(const TensorAnnotation& from) : TensorAnnotation(nullptr, from) {}
2213   inline TensorAnnotation(TensorAnnotation&& from) noexcept
2214       : TensorAnnotation(nullptr, ::std::move(from)) {}
2215   inline TensorAnnotation& operator=(const TensorAnnotation& from) {
2216     CopyFrom(from);
2217     return *this;
2218   }
2219   inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
2220     if (this == &from) return *this;
2221     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
2222       InternalSwap(&from);
2223     } else {
2224       CopyFrom(from);
2225     }
2226     return *this;
2227   }
2228 
2229   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2230       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2231     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2232   }
2233   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
2234       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2235     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2236   }
2237 
2238   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
2239     return GetDescriptor();
2240   }
2241   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
2242     return default_instance().GetMetadata().descriptor;
2243   }
2244   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
2245     return default_instance().GetMetadata().reflection;
2246   }
2247   static const TensorAnnotation& default_instance() {
2248     return *reinterpret_cast<const TensorAnnotation*>(
2249         &_TensorAnnotation_default_instance_);
2250   }
2251   static constexpr int kIndexInFileMessages = 6;
2252   friend void swap(TensorAnnotation& a, TensorAnnotation& b) { a.Swap(&b); }
2253   inline void Swap(TensorAnnotation* PROTOBUF_NONNULL other) {
2254     if (other == this) return;
2255     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
2256       InternalSwap(other);
2257     } else {
2258       ::google::protobuf::internal::GenericSwap(this, other);
2259     }
2260   }
2261   void UnsafeArenaSwap(TensorAnnotation* PROTOBUF_NONNULL other) {
2262     if (other == this) return;
2263     ABSL_DCHECK(GetArena() == other->GetArena());
2264     InternalSwap(other);
2265   }
2266 
2267   // implements Message ----------------------------------------------
2268 
2269   TensorAnnotation* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
2270     return ::google::protobuf::Message::DefaultConstruct<TensorAnnotation>(arena);
2271   }
2272   using ::google::protobuf::Message::CopyFrom;
2273   void CopyFrom(const TensorAnnotation& from);
2274   using ::google::protobuf::Message::MergeFrom;
2275   void MergeFrom(const TensorAnnotation& from) { TensorAnnotation::MergeImpl(*this, from); }
2276 
2277   private:
2278   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
2279                         const ::google::protobuf::MessageLite& from_msg);
2280 
2281   public:
2282   bool IsInitialized() const {
2283     return true;
2284   }
2285   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2286   #if defined(PROTOBUF_CUSTOM_VTABLE)
2287   private:
2288   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2289   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2290       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
2291       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
2292 
2293   public:
2294   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2295   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2296       ::uint8_t* PROTOBUF_NONNULL target,
2297       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
2298     return _InternalSerialize(*this, target, stream);
2299   }
2300   #else   // PROTOBUF_CUSTOM_VTABLE
2301   ::size_t ByteSizeLong() const final;
2302   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2303       ::uint8_t* PROTOBUF_NONNULL target,
2304       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
2305   #endif  // PROTOBUF_CUSTOM_VTABLE
2306   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2307 
2308   private:
2309   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2310   static void SharedDtor(MessageLite& self);
2311   void InternalSwap(TensorAnnotation* PROTOBUF_NONNULL other);
2312  private:
2313   template <typename T>
2314   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
2315   static ::absl::string_view FullMessageName() { return "onnx.TensorAnnotation"; }
2316 
2317  protected:
2318   explicit TensorAnnotation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2319   TensorAnnotation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorAnnotation& from);
2320   TensorAnnotation(
2321       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorAnnotation&& from) noexcept
2322       : TensorAnnotation(arena) {
2323     *this = ::std::move(from);
2324   }
2325   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
2326   static void* PROTOBUF_NONNULL PlacementNew_(
2327       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
2328       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2329   static constexpr auto InternalNewImpl_();
2330 
2331  public:
2332   static constexpr auto InternalGenerateClassData_();
2333 
2334   ::google::protobuf::Metadata GetMetadata() const;
2335   // nested types ----------------------------------------------------
2336 
2337   // accessors -------------------------------------------------------
2338   enum : int {
2339     kQuantParameterTensorNamesFieldNumber = 2,
2340     kTensorNameFieldNumber = 1,
2341   };
2342   // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
2343   int quant_parameter_tensor_names_size() const;
2344   private:
2345   int _internal_quant_parameter_tensor_names_size() const;
2346 
2347   public:
2348   void clear_quant_parameter_tensor_names() ;
2349   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_quant_parameter_tensor_names(int index);
2350   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_quant_parameter_tensor_names();
2351 
2352   private:
2353   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_quant_parameter_tensor_names() const;
2354   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_quant_parameter_tensor_names();
2355   public:
2356   const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
2357   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_quant_parameter_tensor_names();
2358   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& quant_parameter_tensor_names() const;
2359   // optional string tensor_name = 1;
2360   bool has_tensor_name() const;
2361   void clear_tensor_name() ;
2362   const ::std::string& tensor_name() const;
2363   template <typename Arg_ = const ::std::string&, typename... Args_>
2364   void set_tensor_name(Arg_&& arg, Args_... args);
2365   ::std::string* PROTOBUF_NONNULL mutable_tensor_name();
2366   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tensor_name();
2367   void set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value);
2368 
2369   private:
2370   const ::std::string& _internal_tensor_name() const;
2371   PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const ::std::string& value);
2372   ::std::string* PROTOBUF_NONNULL _internal_mutable_tensor_name();
2373 
2374   public:
2375   // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation)
2376  private:
2377   class _Internal;
2378   friend class ::google::protobuf::internal::TcParser;
2379   static const ::google::protobuf::internal::TcParseTable<1, 2,
2380                                    1, 41,
2381                                    2>
2382       _table_;
2383 
2384   friend class ::google::protobuf::MessageLite;
2385   friend class ::google::protobuf::Arena;
2386   template <typename T>
2387   friend class ::google::protobuf::Arena::InternalHelper;
2388   using InternalArenaConstructable_ = void;
2389   using DestructorSkippable_ = void;
2390   struct Impl_ {
2391     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
2392     inline explicit Impl_(
2393         ::google::protobuf::internal::InternalVisibility visibility,
2394         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2395     inline explicit Impl_(
2396         ::google::protobuf::internal::InternalVisibility visibility,
2397         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
2398         const TensorAnnotation& from_msg);
2399     ::google::protobuf::internal::HasBits<1> _has_bits_;
2400     ::google::protobuf::internal::CachedSize _cached_size_;
2401     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
2402     ::google::protobuf::internal::ArenaStringPtr tensor_name_;
2403     PROTOBUF_TSAN_DECLARE_MEMBER
2404   };
2405   union { Impl_ _impl_; };
2406   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2407 };
2408 
2409 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TensorAnnotation_class_data_;
2410 // -------------------------------------------------------------------
2411 
2412 class ONNX_API TypeProto_Tensor final : public ::google::protobuf::Message
2413 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
2414  public:
2415   inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
2416   ~TypeProto_Tensor() PROTOBUF_FINAL;
2417 
2418 #if defined(PROTOBUF_CUSTOM_VTABLE)
2419   void operator delete(TypeProto_Tensor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
2420     SharedDtor(*msg);
2421     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Tensor));
2422   }
2423 #endif
2424 
2425   template <typename = void>
2426   explicit PROTOBUF_CONSTEXPR TypeProto_Tensor(::google::protobuf::internal::ConstantInitialized);
2427 
2428   inline TypeProto_Tensor(const TypeProto_Tensor& from) : TypeProto_Tensor(nullptr, from) {}
2429   inline TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
2430       : TypeProto_Tensor(nullptr, ::std::move(from)) {}
2431   inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
2432     CopyFrom(from);
2433     return *this;
2434   }
2435   inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
2436     if (this == &from) return *this;
2437     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
2438       InternalSwap(&from);
2439     } else {
2440       CopyFrom(from);
2441     }
2442     return *this;
2443   }
2444 
2445   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2446       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2447     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2448   }
2449   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
2450       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2451     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2452   }
2453 
2454   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
2455     return GetDescriptor();
2456   }
2457   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
2458     return default_instance().GetMetadata().descriptor;
2459   }
2460   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
2461     return default_instance().GetMetadata().reflection;
2462   }
2463   static const TypeProto_Tensor& default_instance() {
2464     return *reinterpret_cast<const TypeProto_Tensor*>(
2465         &_TypeProto_Tensor_default_instance_);
2466   }
2467   static constexpr int kIndexInFileMessages = 13;
2468   friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) { a.Swap(&b); }
2469   inline void Swap(TypeProto_Tensor* PROTOBUF_NONNULL other) {
2470     if (other == this) return;
2471     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
2472       InternalSwap(other);
2473     } else {
2474       ::google::protobuf::internal::GenericSwap(this, other);
2475     }
2476   }
2477   void UnsafeArenaSwap(TypeProto_Tensor* PROTOBUF_NONNULL other) {
2478     if (other == this) return;
2479     ABSL_DCHECK(GetArena() == other->GetArena());
2480     InternalSwap(other);
2481   }
2482 
2483   // implements Message ----------------------------------------------
2484 
2485   TypeProto_Tensor* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
2486     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Tensor>(arena);
2487   }
2488   using ::google::protobuf::Message::CopyFrom;
2489   void CopyFrom(const TypeProto_Tensor& from);
2490   using ::google::protobuf::Message::MergeFrom;
2491   void MergeFrom(const TypeProto_Tensor& from) { TypeProto_Tensor::MergeImpl(*this, from); }
2492 
2493   private:
2494   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
2495                         const ::google::protobuf::MessageLite& from_msg);
2496 
2497   public:
2498   bool IsInitialized() const {
2499     return true;
2500   }
2501   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2502   #if defined(PROTOBUF_CUSTOM_VTABLE)
2503   private:
2504   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2505   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2506       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
2507       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
2508 
2509   public:
2510   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2511   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2512       ::uint8_t* PROTOBUF_NONNULL target,
2513       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
2514     return _InternalSerialize(*this, target, stream);
2515   }
2516   #else   // PROTOBUF_CUSTOM_VTABLE
2517   ::size_t ByteSizeLong() const final;
2518   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2519       ::uint8_t* PROTOBUF_NONNULL target,
2520       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
2521   #endif  // PROTOBUF_CUSTOM_VTABLE
2522   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2523 
2524   private:
2525   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2526   static void SharedDtor(MessageLite& self);
2527   void InternalSwap(TypeProto_Tensor* PROTOBUF_NONNULL other);
2528  private:
2529   template <typename T>
2530   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
2531   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Tensor"; }
2532 
2533  protected:
2534   explicit TypeProto_Tensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2535   TypeProto_Tensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Tensor& from);
2536   TypeProto_Tensor(
2537       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Tensor&& from) noexcept
2538       : TypeProto_Tensor(arena) {
2539     *this = ::std::move(from);
2540   }
2541   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
2542   static void* PROTOBUF_NONNULL PlacementNew_(
2543       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
2544       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2545   static constexpr auto InternalNewImpl_();
2546 
2547  public:
2548   static constexpr auto InternalGenerateClassData_();
2549 
2550   ::google::protobuf::Metadata GetMetadata() const;
2551   // nested types ----------------------------------------------------
2552 
2553   // accessors -------------------------------------------------------
2554   enum : int {
2555     kShapeFieldNumber = 2,
2556     kElemTypeFieldNumber = 1,
2557   };
2558   // optional .onnx.TensorShapeProto shape = 2;
2559   bool has_shape() const;
2560   void clear_shape() ;
2561   const ::onnx::TensorShapeProto& shape() const;
2562   [[nodiscard]] ::onnx::TensorShapeProto* PROTOBUF_NULLABLE release_shape();
2563   ::onnx::TensorShapeProto* PROTOBUF_NONNULL mutable_shape();
2564   void set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
2565   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
2566   ::onnx::TensorShapeProto* PROTOBUF_NULLABLE unsafe_arena_release_shape();
2567 
2568   private:
2569   const ::onnx::TensorShapeProto& _internal_shape() const;
2570   ::onnx::TensorShapeProto* PROTOBUF_NONNULL _internal_mutable_shape();
2571 
2572   public:
2573   // optional int32 elem_type = 1;
2574   bool has_elem_type() const;
2575   void clear_elem_type() ;
2576   ::int32_t elem_type() const;
2577   void set_elem_type(::int32_t value);
2578 
2579   private:
2580   ::int32_t _internal_elem_type() const;
2581   void _internal_set_elem_type(::int32_t value);
2582 
2583   public:
2584   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor)
2585  private:
2586   class _Internal;
2587   friend class ::google::protobuf::internal::TcParser;
2588   static const ::google::protobuf::internal::TcParseTable<1, 2,
2589                                    1, 0,
2590                                    2>
2591       _table_;
2592 
2593   friend class ::google::protobuf::MessageLite;
2594   friend class ::google::protobuf::Arena;
2595   template <typename T>
2596   friend class ::google::protobuf::Arena::InternalHelper;
2597   using InternalArenaConstructable_ = void;
2598   using DestructorSkippable_ = void;
2599   struct Impl_ {
2600     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
2601     inline explicit Impl_(
2602         ::google::protobuf::internal::InternalVisibility visibility,
2603         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2604     inline explicit Impl_(
2605         ::google::protobuf::internal::InternalVisibility visibility,
2606         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
2607         const TypeProto_Tensor& from_msg);
2608     ::google::protobuf::internal::HasBits<1> _has_bits_;
2609     ::google::protobuf::internal::CachedSize _cached_size_;
2610     ::onnx::TensorShapeProto* PROTOBUF_NULLABLE shape_;
2611     ::int32_t elem_type_;
2612     PROTOBUF_TSAN_DECLARE_MEMBER
2613   };
2614   union { Impl_ _impl_; };
2615   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2616 };
2617 
2618 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Tensor_class_data_;
2619 // -------------------------------------------------------------------
2620 
2621 class ONNX_API TypeProto_SparseTensor final : public ::google::protobuf::Message
2622 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
2623  public:
2624   inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {}
2625   ~TypeProto_SparseTensor() PROTOBUF_FINAL;
2626 
2627 #if defined(PROTOBUF_CUSTOM_VTABLE)
2628   void operator delete(TypeProto_SparseTensor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
2629     SharedDtor(*msg);
2630     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_SparseTensor));
2631   }
2632 #endif
2633 
2634   template <typename = void>
2635   explicit PROTOBUF_CONSTEXPR TypeProto_SparseTensor(::google::protobuf::internal::ConstantInitialized);
2636 
2637   inline TypeProto_SparseTensor(const TypeProto_SparseTensor& from) : TypeProto_SparseTensor(nullptr, from) {}
2638   inline TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
2639       : TypeProto_SparseTensor(nullptr, ::std::move(from)) {}
2640   inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
2641     CopyFrom(from);
2642     return *this;
2643   }
2644   inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
2645     if (this == &from) return *this;
2646     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
2647       InternalSwap(&from);
2648     } else {
2649       CopyFrom(from);
2650     }
2651     return *this;
2652   }
2653 
2654   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2655       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2656     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2657   }
2658   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
2659       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2660     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2661   }
2662 
2663   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
2664     return GetDescriptor();
2665   }
2666   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
2667     return default_instance().GetMetadata().descriptor;
2668   }
2669   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
2670     return default_instance().GetMetadata().reflection;
2671   }
2672   static const TypeProto_SparseTensor& default_instance() {
2673     return *reinterpret_cast<const TypeProto_SparseTensor*>(
2674         &_TypeProto_SparseTensor_default_instance_);
2675   }
2676   static constexpr int kIndexInFileMessages = 17;
2677   friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) { a.Swap(&b); }
2678   inline void Swap(TypeProto_SparseTensor* PROTOBUF_NONNULL other) {
2679     if (other == this) return;
2680     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
2681       InternalSwap(other);
2682     } else {
2683       ::google::protobuf::internal::GenericSwap(this, other);
2684     }
2685   }
2686   void UnsafeArenaSwap(TypeProto_SparseTensor* PROTOBUF_NONNULL other) {
2687     if (other == this) return;
2688     ABSL_DCHECK(GetArena() == other->GetArena());
2689     InternalSwap(other);
2690   }
2691 
2692   // implements Message ----------------------------------------------
2693 
2694   TypeProto_SparseTensor* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
2695     return ::google::protobuf::Message::DefaultConstruct<TypeProto_SparseTensor>(arena);
2696   }
2697   using ::google::protobuf::Message::CopyFrom;
2698   void CopyFrom(const TypeProto_SparseTensor& from);
2699   using ::google::protobuf::Message::MergeFrom;
2700   void MergeFrom(const TypeProto_SparseTensor& from) { TypeProto_SparseTensor::MergeImpl(*this, from); }
2701 
2702   private:
2703   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
2704                         const ::google::protobuf::MessageLite& from_msg);
2705 
2706   public:
2707   bool IsInitialized() const {
2708     return true;
2709   }
2710   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2711   #if defined(PROTOBUF_CUSTOM_VTABLE)
2712   private:
2713   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2714   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2715       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
2716       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
2717 
2718   public:
2719   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2720   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2721       ::uint8_t* PROTOBUF_NONNULL target,
2722       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
2723     return _InternalSerialize(*this, target, stream);
2724   }
2725   #else   // PROTOBUF_CUSTOM_VTABLE
2726   ::size_t ByteSizeLong() const final;
2727   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2728       ::uint8_t* PROTOBUF_NONNULL target,
2729       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
2730   #endif  // PROTOBUF_CUSTOM_VTABLE
2731   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2732 
2733   private:
2734   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2735   static void SharedDtor(MessageLite& self);
2736   void InternalSwap(TypeProto_SparseTensor* PROTOBUF_NONNULL other);
2737  private:
2738   template <typename T>
2739   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
2740   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.SparseTensor"; }
2741 
2742  protected:
2743   explicit TypeProto_SparseTensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2744   TypeProto_SparseTensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_SparseTensor& from);
2745   TypeProto_SparseTensor(
2746       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_SparseTensor&& from) noexcept
2747       : TypeProto_SparseTensor(arena) {
2748     *this = ::std::move(from);
2749   }
2750   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
2751   static void* PROTOBUF_NONNULL PlacementNew_(
2752       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
2753       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2754   static constexpr auto InternalNewImpl_();
2755 
2756  public:
2757   static constexpr auto InternalGenerateClassData_();
2758 
2759   ::google::protobuf::Metadata GetMetadata() const;
2760   // nested types ----------------------------------------------------
2761 
2762   // accessors -------------------------------------------------------
2763   enum : int {
2764     kShapeFieldNumber = 2,
2765     kElemTypeFieldNumber = 1,
2766   };
2767   // optional .onnx.TensorShapeProto shape = 2;
2768   bool has_shape() const;
2769   void clear_shape() ;
2770   const ::onnx::TensorShapeProto& shape() const;
2771   [[nodiscard]] ::onnx::TensorShapeProto* PROTOBUF_NULLABLE release_shape();
2772   ::onnx::TensorShapeProto* PROTOBUF_NONNULL mutable_shape();
2773   void set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
2774   void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
2775   ::onnx::TensorShapeProto* PROTOBUF_NULLABLE unsafe_arena_release_shape();
2776 
2777   private:
2778   const ::onnx::TensorShapeProto& _internal_shape() const;
2779   ::onnx::TensorShapeProto* PROTOBUF_NONNULL _internal_mutable_shape();
2780 
2781   public:
2782   // optional int32 elem_type = 1;
2783   bool has_elem_type() const;
2784   void clear_elem_type() ;
2785   ::int32_t elem_type() const;
2786   void set_elem_type(::int32_t value);
2787 
2788   private:
2789   ::int32_t _internal_elem_type() const;
2790   void _internal_set_elem_type(::int32_t value);
2791 
2792   public:
2793   // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor)
2794  private:
2795   class _Internal;
2796   friend class ::google::protobuf::internal::TcParser;
2797   static const ::google::protobuf::internal::TcParseTable<1, 2,
2798                                    1, 0,
2799                                    2>
2800       _table_;
2801 
2802   friend class ::google::protobuf::MessageLite;
2803   friend class ::google::protobuf::Arena;
2804   template <typename T>
2805   friend class ::google::protobuf::Arena::InternalHelper;
2806   using InternalArenaConstructable_ = void;
2807   using DestructorSkippable_ = void;
2808   struct Impl_ {
2809     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
2810     inline explicit Impl_(
2811         ::google::protobuf::internal::InternalVisibility visibility,
2812         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2813     inline explicit Impl_(
2814         ::google::protobuf::internal::InternalVisibility visibility,
2815         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
2816         const TypeProto_SparseTensor& from_msg);
2817     ::google::protobuf::internal::HasBits<1> _has_bits_;
2818     ::google::protobuf::internal::CachedSize _cached_size_;
2819     ::onnx::TensorShapeProto* PROTOBUF_NULLABLE shape_;
2820     ::int32_t elem_type_;
2821     PROTOBUF_TSAN_DECLARE_MEMBER
2822   };
2823   union { Impl_ _impl_; };
2824   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
2825 };
2826 
2827 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_SparseTensor_class_data_;
2828 // -------------------------------------------------------------------
2829 
2830 class ONNX_API SparseTensorProto final : public ::google::protobuf::Message
2831 /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
2832  public:
2833   inline SparseTensorProto() : SparseTensorProto(nullptr) {}
2834   ~SparseTensorProto() PROTOBUF_FINAL;
2835 
2836 #if defined(PROTOBUF_CUSTOM_VTABLE)
2837   void operator delete(SparseTensorProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
2838     SharedDtor(*msg);
2839     ::google::protobuf::internal::SizedDelete(msg, sizeof(SparseTensorProto));
2840   }
2841 #endif
2842 
2843   template <typename = void>
2844   explicit PROTOBUF_CONSTEXPR SparseTensorProto(::google::protobuf::internal::ConstantInitialized);
2845 
2846   inline SparseTensorProto(const SparseTensorProto& from) : SparseTensorProto(nullptr, from) {}
2847   inline SparseTensorProto(SparseTensorProto&& from) noexcept
2848       : SparseTensorProto(nullptr, ::std::move(from)) {}
2849   inline SparseTensorProto& operator=(const SparseTensorProto& from) {
2850     CopyFrom(from);
2851     return *this;
2852   }
2853   inline SparseTensorProto& operator=(SparseTensorProto&& from) noexcept {
2854     if (this == &from) return *this;
2855     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
2856       InternalSwap(&from);
2857     } else {
2858       CopyFrom(from);
2859     }
2860     return *this;
2861   }
2862 
2863   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
2864       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2865     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
2866   }
2867   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
2868       ABSL_ATTRIBUTE_LIFETIME_BOUND {
2869     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
2870   }
2871 
2872   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
2873     return GetDescriptor();
2874   }
2875   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
2876     return default_instance().GetMetadata().descriptor;
2877   }
2878   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
2879     return default_instance().GetMetadata().reflection;
2880   }
2881   static const SparseTensorProto& default_instance() {
2882     return *reinterpret_cast<const SparseTensorProto*>(
2883         &_SparseTensorProto_default_instance_);
2884   }
2885   static constexpr int kIndexInFileMessages = 10;
2886   friend void swap(SparseTensorProto& a, SparseTensorProto& b) { a.Swap(&b); }
2887   inline void Swap(SparseTensorProto* PROTOBUF_NONNULL other) {
2888     if (other == this) return;
2889     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
2890       InternalSwap(other);
2891     } else {
2892       ::google::protobuf::internal::GenericSwap(this, other);
2893     }
2894   }
2895   void UnsafeArenaSwap(SparseTensorProto* PROTOBUF_NONNULL other) {
2896     if (other == this) return;
2897     ABSL_DCHECK(GetArena() == other->GetArena());
2898     InternalSwap(other);
2899   }
2900 
2901   // implements Message ----------------------------------------------
2902 
2903   SparseTensorProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
2904     return ::google::protobuf::Message::DefaultConstruct<SparseTensorProto>(arena);
2905   }
2906   using ::google::protobuf::Message::CopyFrom;
2907   void CopyFrom(const SparseTensorProto& from);
2908   using ::google::protobuf::Message::MergeFrom;
2909   void MergeFrom(const SparseTensorProto& from) { SparseTensorProto::MergeImpl(*this, from); }
2910 
2911   private:
2912   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
2913                         const ::google::protobuf::MessageLite& from_msg);
2914 
2915   public:
2916   bool IsInitialized() const {
2917     return true;
2918   }
2919   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
2920   #if defined(PROTOBUF_CUSTOM_VTABLE)
2921   private:
2922   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
2923   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2924       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
2925       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
2926 
2927   public:
2928   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
2929   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2930       ::uint8_t* PROTOBUF_NONNULL target,
2931       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
2932     return _InternalSerialize(*this, target, stream);
2933   }
2934   #else   // PROTOBUF_CUSTOM_VTABLE
2935   ::size_t ByteSizeLong() const final;
2936   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
2937       ::uint8_t* PROTOBUF_NONNULL target,
2938       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
2939   #endif  // PROTOBUF_CUSTOM_VTABLE
2940   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
2941 
2942   private:
2943   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2944   static void SharedDtor(MessageLite& self);
2945   void InternalSwap(SparseTensorProto* PROTOBUF_NONNULL other);
2946  private:
2947   template <typename T>
2948   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
2949   static ::absl::string_view FullMessageName() { return "onnx.SparseTensorProto"; }
2950 
2951  protected:
2952   explicit SparseTensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2953   SparseTensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SparseTensorProto& from);
2954   SparseTensorProto(
2955       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SparseTensorProto&& from) noexcept
2956       : SparseTensorProto(arena) {
2957     *this = ::std::move(from);
2958   }
2959   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
2960   static void* PROTOBUF_NONNULL PlacementNew_(
2961       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
2962       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
2963   static constexpr auto InternalNewImpl_();
2964 
2965  public:
2966   static constexpr auto InternalGenerateClassData_();
2967 
2968   ::google::protobuf::Metadata GetMetadata() const;
2969   // nested types ----------------------------------------------------
2970 
2971   // accessors -------------------------------------------------------
2972   enum : int {
2973     kDimsFieldNumber = 3,
2974     kValuesFieldNumber = 1,
2975     kIndicesFieldNumber = 2,
2976   };
2977   // repeated int64 dims = 3;
2978   int dims_size() const;
2979   private:
2980   int _internal_dims_size() const;
2981 
2982   public:
2983   void clear_dims() ;
2984   ::int64_t dims(int index) const;
2985   void set_dims(int index, ::int64_t value);
2986   void add_dims(::int64_t value);
2987   const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
2988   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_dims();
2989 
2990   private:
2991   const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
2992   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_dims();
2993 
2994   public:
2995   // optional .onnx.TensorProto values = 1;
2996   bool has_values() const;
2997   void clear_values() ;
2998   const ::onnx::TensorProto& values() const;
2999   [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_values();
3000   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_values();
3001   void set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value);
3002   void unsafe_arena_set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value);
3003   ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_values();
3004 
3005   private:
3006   const ::onnx::TensorProto& _internal_values() const;
3007   ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_values();
3008 
3009   public:
3010   // optional .onnx.TensorProto indices = 2;
3011   bool has_indices() const;
3012   void clear_indices() ;
3013   const ::onnx::TensorProto& indices() const;
3014   [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_indices();
3015   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_indices();
3016   void set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value);
3017   void unsafe_arena_set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value);
3018   ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_indices();
3019 
3020   private:
3021   const ::onnx::TensorProto& _internal_indices() const;
3022   ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_indices();
3023 
3024   public:
3025   // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto)
3026  private:
3027   class _Internal;
3028   friend class ::google::protobuf::internal::TcParser;
3029   static const ::google::protobuf::internal::TcParseTable<2, 3,
3030                                    2, 0,
3031                                    2>
3032       _table_;
3033 
3034   friend class ::google::protobuf::MessageLite;
3035   friend class ::google::protobuf::Arena;
3036   template <typename T>
3037   friend class ::google::protobuf::Arena::InternalHelper;
3038   using InternalArenaConstructable_ = void;
3039   using DestructorSkippable_ = void;
3040   struct Impl_ {
3041     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
3042     inline explicit Impl_(
3043         ::google::protobuf::internal::InternalVisibility visibility,
3044         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3045     inline explicit Impl_(
3046         ::google::protobuf::internal::InternalVisibility visibility,
3047         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
3048         const SparseTensorProto& from_msg);
3049     ::google::protobuf::internal::HasBits<1> _has_bits_;
3050     ::google::protobuf::internal::CachedSize _cached_size_;
3051     ::google::protobuf::RepeatedField<::int64_t> dims_;
3052     ::onnx::TensorProto* PROTOBUF_NULLABLE values_;
3053     ::onnx::TensorProto* PROTOBUF_NULLABLE indices_;
3054     PROTOBUF_TSAN_DECLARE_MEMBER
3055   };
3056   union { Impl_ _impl_; };
3057   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3058 };
3059 
3060 ONNX_API extern const ::google::protobuf::internal::ClassDataFull SparseTensorProto_class_data_;
3061 // -------------------------------------------------------------------
3062 
3063 class ONNX_API TypeProto final : public ::google::protobuf::Message
3064 /* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
3065  public:
3066   inline TypeProto() : TypeProto(nullptr) {}
3067   ~TypeProto() PROTOBUF_FINAL;
3068 
3069 #if defined(PROTOBUF_CUSTOM_VTABLE)
3070   void operator delete(TypeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
3071     SharedDtor(*msg);
3072     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto));
3073   }
3074 #endif
3075 
3076   template <typename = void>
3077   explicit PROTOBUF_CONSTEXPR TypeProto(::google::protobuf::internal::ConstantInitialized);
3078 
3079   inline TypeProto(const TypeProto& from) : TypeProto(nullptr, from) {}
3080   inline TypeProto(TypeProto&& from) noexcept
3081       : TypeProto(nullptr, ::std::move(from)) {}
3082   inline TypeProto& operator=(const TypeProto& from) {
3083     CopyFrom(from);
3084     return *this;
3085   }
3086   inline TypeProto& operator=(TypeProto&& from) noexcept {
3087     if (this == &from) return *this;
3088     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
3089       InternalSwap(&from);
3090     } else {
3091       CopyFrom(from);
3092     }
3093     return *this;
3094   }
3095 
3096   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3097       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3098     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3099   }
3100   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
3101       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3102     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3103   }
3104 
3105   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
3106     return GetDescriptor();
3107   }
3108   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
3109     return default_instance().GetMetadata().descriptor;
3110   }
3111   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
3112     return default_instance().GetMetadata().reflection;
3113   }
3114   static const TypeProto& default_instance() {
3115     return *reinterpret_cast<const TypeProto*>(
3116         &_TypeProto_default_instance_);
3117   }
3118   enum ValueCase {
3119     kTensorType = 1,
3120     kSequenceType = 4,
3121     kMapType = 5,
3122     kOptionalType = 9,
3123     kSparseTensorType = 8,
3124     kOpaqueType = 7,
3125     VALUE_NOT_SET = 0,
3126   };
3127   static constexpr int kIndexInFileMessages = 19;
3128   friend void swap(TypeProto& a, TypeProto& b) { a.Swap(&b); }
3129   inline void Swap(TypeProto* PROTOBUF_NONNULL other) {
3130     if (other == this) return;
3131     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
3132       InternalSwap(other);
3133     } else {
3134       ::google::protobuf::internal::GenericSwap(this, other);
3135     }
3136   }
3137   void UnsafeArenaSwap(TypeProto* PROTOBUF_NONNULL other) {
3138     if (other == this) return;
3139     ABSL_DCHECK(GetArena() == other->GetArena());
3140     InternalSwap(other);
3141   }
3142 
3143   // implements Message ----------------------------------------------
3144 
3145   TypeProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
3146     return ::google::protobuf::Message::DefaultConstruct<TypeProto>(arena);
3147   }
3148   using ::google::protobuf::Message::CopyFrom;
3149   void CopyFrom(const TypeProto& from);
3150   using ::google::protobuf::Message::MergeFrom;
3151   void MergeFrom(const TypeProto& from) { TypeProto::MergeImpl(*this, from); }
3152 
3153   private:
3154   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
3155                         const ::google::protobuf::MessageLite& from_msg);
3156 
3157   public:
3158   bool IsInitialized() const {
3159     return true;
3160   }
3161   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3162   #if defined(PROTOBUF_CUSTOM_VTABLE)
3163   private:
3164   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3165   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3166       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
3167       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
3168 
3169   public:
3170   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3171   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3172       ::uint8_t* PROTOBUF_NONNULL target,
3173       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
3174     return _InternalSerialize(*this, target, stream);
3175   }
3176   #else   // PROTOBUF_CUSTOM_VTABLE
3177   ::size_t ByteSizeLong() const final;
3178   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3179       ::uint8_t* PROTOBUF_NONNULL target,
3180       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
3181   #endif  // PROTOBUF_CUSTOM_VTABLE
3182   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3183 
3184   private:
3185   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3186   static void SharedDtor(MessageLite& self);
3187   void InternalSwap(TypeProto* PROTOBUF_NONNULL other);
3188  private:
3189   template <typename T>
3190   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
3191   static ::absl::string_view FullMessageName() { return "onnx.TypeProto"; }
3192 
3193  protected:
3194   explicit TypeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3195   TypeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto& from);
3196   TypeProto(
3197       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto&& from) noexcept
3198       : TypeProto(arena) {
3199     *this = ::std::move(from);
3200   }
3201   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
3202   static void* PROTOBUF_NONNULL PlacementNew_(
3203       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
3204       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3205   static constexpr auto InternalNewImpl_();
3206 
3207  public:
3208   static constexpr auto InternalGenerateClassData_();
3209 
3210   ::google::protobuf::Metadata GetMetadata() const;
3211   // nested types ----------------------------------------------------
3212   using Tensor = TypeProto_Tensor;
3213   using Sequence = TypeProto_Sequence;
3214   using Map = TypeProto_Map;
3215   using Optional = TypeProto_Optional;
3216   using SparseTensor = TypeProto_SparseTensor;
3217   using Opaque = TypeProto_Opaque;
3218 
3219   // accessors -------------------------------------------------------
3220   enum : int {
3221     kDenotationFieldNumber = 6,
3222     kTensorTypeFieldNumber = 1,
3223     kSequenceTypeFieldNumber = 4,
3224     kMapTypeFieldNumber = 5,
3225     kOptionalTypeFieldNumber = 9,
3226     kSparseTensorTypeFieldNumber = 8,
3227     kOpaqueTypeFieldNumber = 7,
3228   };
3229   // optional string denotation = 6;
3230   bool has_denotation() const;
3231   void clear_denotation() ;
3232   const ::std::string& denotation() const;
3233   template <typename Arg_ = const ::std::string&, typename... Args_>
3234   void set_denotation(Arg_&& arg, Args_... args);
3235   ::std::string* PROTOBUF_NONNULL mutable_denotation();
3236   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_denotation();
3237   void set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value);
3238 
3239   private:
3240   const ::std::string& _internal_denotation() const;
3241   PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const ::std::string& value);
3242   ::std::string* PROTOBUF_NONNULL _internal_mutable_denotation();
3243 
3244   public:
3245   // .onnx.TypeProto.Tensor tensor_type = 1;
3246   bool has_tensor_type() const;
3247   private:
3248   bool _internal_has_tensor_type() const;
3249 
3250   public:
3251   void clear_tensor_type() ;
3252   const ::onnx::TypeProto_Tensor& tensor_type() const;
3253   [[nodiscard]] ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE release_tensor_type();
3254   ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL mutable_tensor_type();
3255   void set_allocated_tensor_type(::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value);
3256   void unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value);
3257   ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE unsafe_arena_release_tensor_type();
3258 
3259   private:
3260   const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
3261   ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL _internal_mutable_tensor_type();
3262 
3263   public:
3264   // .onnx.TypeProto.Sequence sequence_type = 4;
3265   bool has_sequence_type() const;
3266   private:
3267   bool _internal_has_sequence_type() const;
3268 
3269   public:
3270   void clear_sequence_type() ;
3271   const ::onnx::TypeProto_Sequence& sequence_type() const;
3272   [[nodiscard]] ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE release_sequence_type();
3273   ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL mutable_sequence_type();
3274   void set_allocated_sequence_type(::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value);
3275   void unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value);
3276   ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE unsafe_arena_release_sequence_type();
3277 
3278   private:
3279   const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
3280   ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL _internal_mutable_sequence_type();
3281 
3282   public:
3283   // .onnx.TypeProto.Map map_type = 5;
3284   bool has_map_type() const;
3285   private:
3286   bool _internal_has_map_type() const;
3287 
3288   public:
3289   void clear_map_type() ;
3290   const ::onnx::TypeProto_Map& map_type() const;
3291   [[nodiscard]] ::onnx::TypeProto_Map* PROTOBUF_NULLABLE release_map_type();
3292   ::onnx::TypeProto_Map* PROTOBUF_NONNULL mutable_map_type();
3293   void set_allocated_map_type(::onnx::TypeProto_Map* PROTOBUF_NULLABLE value);
3294   void unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* PROTOBUF_NULLABLE value);
3295   ::onnx::TypeProto_Map* PROTOBUF_NULLABLE unsafe_arena_release_map_type();
3296 
3297   private:
3298   const ::onnx::TypeProto_Map& _internal_map_type() const;
3299   ::onnx::TypeProto_Map* PROTOBUF_NONNULL _internal_mutable_map_type();
3300 
3301   public:
3302   // .onnx.TypeProto.Optional optional_type = 9;
3303   bool has_optional_type() const;
3304   private:
3305   bool _internal_has_optional_type() const;
3306 
3307   public:
3308   void clear_optional_type() ;
3309   const ::onnx::TypeProto_Optional& optional_type() const;
3310   [[nodiscard]] ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE release_optional_type();
3311   ::onnx::TypeProto_Optional* PROTOBUF_NONNULL mutable_optional_type();
3312   void set_allocated_optional_type(::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value);
3313   void unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value);
3314   ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE unsafe_arena_release_optional_type();
3315 
3316   private:
3317   const ::onnx::TypeProto_Optional& _internal_optional_type() const;
3318   ::onnx::TypeProto_Optional* PROTOBUF_NONNULL _internal_mutable_optional_type();
3319 
3320   public:
3321   // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
3322   bool has_sparse_tensor_type() const;
3323   private:
3324   bool _internal_has_sparse_tensor_type() const;
3325 
3326   public:
3327   void clear_sparse_tensor_type() ;
3328   const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
3329   [[nodiscard]] ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE release_sparse_tensor_type();
3330   ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL mutable_sparse_tensor_type();
3331   void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value);
3332   void unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value);
3333   ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE unsafe_arena_release_sparse_tensor_type();
3334 
3335   private:
3336   const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
3337   ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL _internal_mutable_sparse_tensor_type();
3338 
3339   public:
3340   // .onnx.TypeProto.Opaque opaque_type = 7;
3341   bool has_opaque_type() const;
3342   private:
3343   bool _internal_has_opaque_type() const;
3344 
3345   public:
3346   void clear_opaque_type() ;
3347   const ::onnx::TypeProto_Opaque& opaque_type() const;
3348   [[nodiscard]] ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE release_opaque_type();
3349   ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL mutable_opaque_type();
3350   void set_allocated_opaque_type(::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value);
3351   void unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value);
3352   ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE unsafe_arena_release_opaque_type();
3353 
3354   private:
3355   const ::onnx::TypeProto_Opaque& _internal_opaque_type() const;
3356   ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL _internal_mutable_opaque_type();
3357 
3358   public:
3359   void clear_value();
3360   ValueCase value_case() const;
3361   // @@protoc_insertion_point(class_scope:onnx.TypeProto)
3362  private:
3363   class _Internal;
3364   void set_has_tensor_type();
3365   void set_has_sequence_type();
3366   void set_has_map_type();
3367   void set_has_optional_type();
3368   void set_has_sparse_tensor_type();
3369   void set_has_opaque_type();
3370   inline bool has_value() const;
3371   inline void clear_has_value();
3372   friend class ::google::protobuf::internal::TcParser;
3373   static const ::google::protobuf::internal::TcParseTable<0, 7,
3374                                    6, 33,
3375                                    2>
3376       _table_;
3377 
3378   friend class ::google::protobuf::MessageLite;
3379   friend class ::google::protobuf::Arena;
3380   template <typename T>
3381   friend class ::google::protobuf::Arena::InternalHelper;
3382   using InternalArenaConstructable_ = void;
3383   using DestructorSkippable_ = void;
3384   struct Impl_ {
3385     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
3386     inline explicit Impl_(
3387         ::google::protobuf::internal::InternalVisibility visibility,
3388         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3389     inline explicit Impl_(
3390         ::google::protobuf::internal::InternalVisibility visibility,
3391         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
3392         const TypeProto& from_msg);
3393     ::google::protobuf::internal::HasBits<1> _has_bits_;
3394     ::google::protobuf::internal::CachedSize _cached_size_;
3395     ::google::protobuf::internal::ArenaStringPtr denotation_;
3396     union ValueUnion {
3397       constexpr ValueUnion() : _constinit_{} {}
3398       ::google::protobuf::internal::ConstantInitialized _constinit_;
3399       ::google::protobuf::Message* PROTOBUF_NULLABLE tensor_type_;
3400       ::google::protobuf::Message* PROTOBUF_NULLABLE sequence_type_;
3401       ::google::protobuf::Message* PROTOBUF_NULLABLE map_type_;
3402       ::google::protobuf::Message* PROTOBUF_NULLABLE optional_type_;
3403       ::google::protobuf::Message* PROTOBUF_NULLABLE sparse_tensor_type_;
3404       ::google::protobuf::Message* PROTOBUF_NULLABLE opaque_type_;
3405     } value_;
3406     ::uint32_t _oneof_case_[1];
3407     PROTOBUF_TSAN_DECLARE_MEMBER
3408   };
3409   union { Impl_ _impl_; };
3410   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3411 };
3412 
3413 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_class_data_;
3414 // -------------------------------------------------------------------
3415 
3416 class ONNX_API TypeProto_Map final : public ::google::protobuf::Message
3417 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
3418  public:
3419   inline TypeProto_Map() : TypeProto_Map(nullptr) {}
3420   ~TypeProto_Map() PROTOBUF_FINAL;
3421 
3422 #if defined(PROTOBUF_CUSTOM_VTABLE)
3423   void operator delete(TypeProto_Map* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
3424     SharedDtor(*msg);
3425     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Map));
3426   }
3427 #endif
3428 
3429   template <typename = void>
3430   explicit PROTOBUF_CONSTEXPR TypeProto_Map(::google::protobuf::internal::ConstantInitialized);
3431 
3432   inline TypeProto_Map(const TypeProto_Map& from) : TypeProto_Map(nullptr, from) {}
3433   inline TypeProto_Map(TypeProto_Map&& from) noexcept
3434       : TypeProto_Map(nullptr, ::std::move(from)) {}
3435   inline TypeProto_Map& operator=(const TypeProto_Map& from) {
3436     CopyFrom(from);
3437     return *this;
3438   }
3439   inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
3440     if (this == &from) return *this;
3441     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
3442       InternalSwap(&from);
3443     } else {
3444       CopyFrom(from);
3445     }
3446     return *this;
3447   }
3448 
3449   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3450       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3451     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3452   }
3453   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
3454       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3455     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3456   }
3457 
3458   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
3459     return GetDescriptor();
3460   }
3461   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
3462     return default_instance().GetMetadata().descriptor;
3463   }
3464   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
3465     return default_instance().GetMetadata().reflection;
3466   }
3467   static const TypeProto_Map& default_instance() {
3468     return *reinterpret_cast<const TypeProto_Map*>(
3469         &_TypeProto_Map_default_instance_);
3470   }
3471   static constexpr int kIndexInFileMessages = 15;
3472   friend void swap(TypeProto_Map& a, TypeProto_Map& b) { a.Swap(&b); }
3473   inline void Swap(TypeProto_Map* PROTOBUF_NONNULL other) {
3474     if (other == this) return;
3475     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
3476       InternalSwap(other);
3477     } else {
3478       ::google::protobuf::internal::GenericSwap(this, other);
3479     }
3480   }
3481   void UnsafeArenaSwap(TypeProto_Map* PROTOBUF_NONNULL other) {
3482     if (other == this) return;
3483     ABSL_DCHECK(GetArena() == other->GetArena());
3484     InternalSwap(other);
3485   }
3486 
3487   // implements Message ----------------------------------------------
3488 
3489   TypeProto_Map* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
3490     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Map>(arena);
3491   }
3492   using ::google::protobuf::Message::CopyFrom;
3493   void CopyFrom(const TypeProto_Map& from);
3494   using ::google::protobuf::Message::MergeFrom;
3495   void MergeFrom(const TypeProto_Map& from) { TypeProto_Map::MergeImpl(*this, from); }
3496 
3497   private:
3498   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
3499                         const ::google::protobuf::MessageLite& from_msg);
3500 
3501   public:
3502   bool IsInitialized() const {
3503     return true;
3504   }
3505   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3506   #if defined(PROTOBUF_CUSTOM_VTABLE)
3507   private:
3508   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3509   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3510       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
3511       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
3512 
3513   public:
3514   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3515   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3516       ::uint8_t* PROTOBUF_NONNULL target,
3517       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
3518     return _InternalSerialize(*this, target, stream);
3519   }
3520   #else   // PROTOBUF_CUSTOM_VTABLE
3521   ::size_t ByteSizeLong() const final;
3522   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3523       ::uint8_t* PROTOBUF_NONNULL target,
3524       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
3525   #endif  // PROTOBUF_CUSTOM_VTABLE
3526   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3527 
3528   private:
3529   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3530   static void SharedDtor(MessageLite& self);
3531   void InternalSwap(TypeProto_Map* PROTOBUF_NONNULL other);
3532  private:
3533   template <typename T>
3534   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
3535   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Map"; }
3536 
3537  protected:
3538   explicit TypeProto_Map(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3539   TypeProto_Map(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Map& from);
3540   TypeProto_Map(
3541       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Map&& from) noexcept
3542       : TypeProto_Map(arena) {
3543     *this = ::std::move(from);
3544   }
3545   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
3546   static void* PROTOBUF_NONNULL PlacementNew_(
3547       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
3548       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3549   static constexpr auto InternalNewImpl_();
3550 
3551  public:
3552   static constexpr auto InternalGenerateClassData_();
3553 
3554   ::google::protobuf::Metadata GetMetadata() const;
3555   // nested types ----------------------------------------------------
3556 
3557   // accessors -------------------------------------------------------
3558   enum : int {
3559     kValueTypeFieldNumber = 2,
3560     kKeyTypeFieldNumber = 1,
3561   };
3562   // optional .onnx.TypeProto value_type = 2;
3563   bool has_value_type() const;
3564   void clear_value_type() ;
3565   const ::onnx::TypeProto& value_type() const;
3566   [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_value_type();
3567   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_value_type();
3568   void set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3569   void unsafe_arena_set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3570   ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_value_type();
3571 
3572   private:
3573   const ::onnx::TypeProto& _internal_value_type() const;
3574   ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_value_type();
3575 
3576   public:
3577   // optional int32 key_type = 1;
3578   bool has_key_type() const;
3579   void clear_key_type() ;
3580   ::int32_t key_type() const;
3581   void set_key_type(::int32_t value);
3582 
3583   private:
3584   ::int32_t _internal_key_type() const;
3585   void _internal_set_key_type(::int32_t value);
3586 
3587   public:
3588   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map)
3589  private:
3590   class _Internal;
3591   friend class ::google::protobuf::internal::TcParser;
3592   static const ::google::protobuf::internal::TcParseTable<1, 2,
3593                                    1, 0,
3594                                    2>
3595       _table_;
3596 
3597   friend class ::google::protobuf::MessageLite;
3598   friend class ::google::protobuf::Arena;
3599   template <typename T>
3600   friend class ::google::protobuf::Arena::InternalHelper;
3601   using InternalArenaConstructable_ = void;
3602   using DestructorSkippable_ = void;
3603   struct Impl_ {
3604     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
3605     inline explicit Impl_(
3606         ::google::protobuf::internal::InternalVisibility visibility,
3607         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3608     inline explicit Impl_(
3609         ::google::protobuf::internal::InternalVisibility visibility,
3610         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
3611         const TypeProto_Map& from_msg);
3612     ::google::protobuf::internal::HasBits<1> _has_bits_;
3613     ::google::protobuf::internal::CachedSize _cached_size_;
3614     ::onnx::TypeProto* PROTOBUF_NULLABLE value_type_;
3615     ::int32_t key_type_;
3616     PROTOBUF_TSAN_DECLARE_MEMBER
3617   };
3618   union { Impl_ _impl_; };
3619   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3620 };
3621 
3622 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Map_class_data_;
3623 // -------------------------------------------------------------------
3624 
3625 class ONNX_API TypeProto_Optional final : public ::google::protobuf::Message
3626 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
3627  public:
3628   inline TypeProto_Optional() : TypeProto_Optional(nullptr) {}
3629   ~TypeProto_Optional() PROTOBUF_FINAL;
3630 
3631 #if defined(PROTOBUF_CUSTOM_VTABLE)
3632   void operator delete(TypeProto_Optional* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
3633     SharedDtor(*msg);
3634     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Optional));
3635   }
3636 #endif
3637 
3638   template <typename = void>
3639   explicit PROTOBUF_CONSTEXPR TypeProto_Optional(::google::protobuf::internal::ConstantInitialized);
3640 
3641   inline TypeProto_Optional(const TypeProto_Optional& from) : TypeProto_Optional(nullptr, from) {}
3642   inline TypeProto_Optional(TypeProto_Optional&& from) noexcept
3643       : TypeProto_Optional(nullptr, ::std::move(from)) {}
3644   inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
3645     CopyFrom(from);
3646     return *this;
3647   }
3648   inline TypeProto_Optional& operator=(TypeProto_Optional&& from) noexcept {
3649     if (this == &from) return *this;
3650     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
3651       InternalSwap(&from);
3652     } else {
3653       CopyFrom(from);
3654     }
3655     return *this;
3656   }
3657 
3658   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3659       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3660     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3661   }
3662   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
3663       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3664     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3665   }
3666 
3667   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
3668     return GetDescriptor();
3669   }
3670   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
3671     return default_instance().GetMetadata().descriptor;
3672   }
3673   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
3674     return default_instance().GetMetadata().reflection;
3675   }
3676   static const TypeProto_Optional& default_instance() {
3677     return *reinterpret_cast<const TypeProto_Optional*>(
3678         &_TypeProto_Optional_default_instance_);
3679   }
3680   static constexpr int kIndexInFileMessages = 16;
3681   friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) { a.Swap(&b); }
3682   inline void Swap(TypeProto_Optional* PROTOBUF_NONNULL other) {
3683     if (other == this) return;
3684     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
3685       InternalSwap(other);
3686     } else {
3687       ::google::protobuf::internal::GenericSwap(this, other);
3688     }
3689   }
3690   void UnsafeArenaSwap(TypeProto_Optional* PROTOBUF_NONNULL other) {
3691     if (other == this) return;
3692     ABSL_DCHECK(GetArena() == other->GetArena());
3693     InternalSwap(other);
3694   }
3695 
3696   // implements Message ----------------------------------------------
3697 
3698   TypeProto_Optional* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
3699     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Optional>(arena);
3700   }
3701   using ::google::protobuf::Message::CopyFrom;
3702   void CopyFrom(const TypeProto_Optional& from);
3703   using ::google::protobuf::Message::MergeFrom;
3704   void MergeFrom(const TypeProto_Optional& from) { TypeProto_Optional::MergeImpl(*this, from); }
3705 
3706   private:
3707   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
3708                         const ::google::protobuf::MessageLite& from_msg);
3709 
3710   public:
3711   bool IsInitialized() const {
3712     return true;
3713   }
3714   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3715   #if defined(PROTOBUF_CUSTOM_VTABLE)
3716   private:
3717   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3718   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3719       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
3720       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
3721 
3722   public:
3723   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3724   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3725       ::uint8_t* PROTOBUF_NONNULL target,
3726       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
3727     return _InternalSerialize(*this, target, stream);
3728   }
3729   #else   // PROTOBUF_CUSTOM_VTABLE
3730   ::size_t ByteSizeLong() const final;
3731   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3732       ::uint8_t* PROTOBUF_NONNULL target,
3733       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
3734   #endif  // PROTOBUF_CUSTOM_VTABLE
3735   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3736 
3737   private:
3738   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3739   static void SharedDtor(MessageLite& self);
3740   void InternalSwap(TypeProto_Optional* PROTOBUF_NONNULL other);
3741  private:
3742   template <typename T>
3743   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
3744   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Optional"; }
3745 
3746  protected:
3747   explicit TypeProto_Optional(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3748   TypeProto_Optional(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Optional& from);
3749   TypeProto_Optional(
3750       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Optional&& from) noexcept
3751       : TypeProto_Optional(arena) {
3752     *this = ::std::move(from);
3753   }
3754   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
3755   static void* PROTOBUF_NONNULL PlacementNew_(
3756       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
3757       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3758   static constexpr auto InternalNewImpl_();
3759 
3760  public:
3761   static constexpr auto InternalGenerateClassData_();
3762 
3763   ::google::protobuf::Metadata GetMetadata() const;
3764   // nested types ----------------------------------------------------
3765 
3766   // accessors -------------------------------------------------------
3767   enum : int {
3768     kElemTypeFieldNumber = 1,
3769   };
3770   // optional .onnx.TypeProto elem_type = 1;
3771   bool has_elem_type() const;
3772   void clear_elem_type() ;
3773   const ::onnx::TypeProto& elem_type() const;
3774   [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_elem_type();
3775   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_elem_type();
3776   void set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3777   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3778   ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_elem_type();
3779 
3780   private:
3781   const ::onnx::TypeProto& _internal_elem_type() const;
3782   ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_elem_type();
3783 
3784   public:
3785   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional)
3786  private:
3787   class _Internal;
3788   friend class ::google::protobuf::internal::TcParser;
3789   static const ::google::protobuf::internal::TcParseTable<0, 1,
3790                                    1, 0,
3791                                    2>
3792       _table_;
3793 
3794   friend class ::google::protobuf::MessageLite;
3795   friend class ::google::protobuf::Arena;
3796   template <typename T>
3797   friend class ::google::protobuf::Arena::InternalHelper;
3798   using InternalArenaConstructable_ = void;
3799   using DestructorSkippable_ = void;
3800   struct Impl_ {
3801     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
3802     inline explicit Impl_(
3803         ::google::protobuf::internal::InternalVisibility visibility,
3804         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3805     inline explicit Impl_(
3806         ::google::protobuf::internal::InternalVisibility visibility,
3807         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
3808         const TypeProto_Optional& from_msg);
3809     ::google::protobuf::internal::HasBits<1> _has_bits_;
3810     ::google::protobuf::internal::CachedSize _cached_size_;
3811     ::onnx::TypeProto* PROTOBUF_NULLABLE elem_type_;
3812     PROTOBUF_TSAN_DECLARE_MEMBER
3813   };
3814   union { Impl_ _impl_; };
3815   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
3816 };
3817 
3818 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Optional_class_data_;
3819 // -------------------------------------------------------------------
3820 
3821 class ONNX_API TypeProto_Sequence final : public ::google::protobuf::Message
3822 /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
3823  public:
3824   inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {}
3825   ~TypeProto_Sequence() PROTOBUF_FINAL;
3826 
3827 #if defined(PROTOBUF_CUSTOM_VTABLE)
3828   void operator delete(TypeProto_Sequence* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
3829     SharedDtor(*msg);
3830     ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Sequence));
3831   }
3832 #endif
3833 
3834   template <typename = void>
3835   explicit PROTOBUF_CONSTEXPR TypeProto_Sequence(::google::protobuf::internal::ConstantInitialized);
3836 
3837   inline TypeProto_Sequence(const TypeProto_Sequence& from) : TypeProto_Sequence(nullptr, from) {}
3838   inline TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
3839       : TypeProto_Sequence(nullptr, ::std::move(from)) {}
3840   inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
3841     CopyFrom(from);
3842     return *this;
3843   }
3844   inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
3845     if (this == &from) return *this;
3846     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
3847       InternalSwap(&from);
3848     } else {
3849       CopyFrom(from);
3850     }
3851     return *this;
3852   }
3853 
3854   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
3855       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3856     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
3857   }
3858   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
3859       ABSL_ATTRIBUTE_LIFETIME_BOUND {
3860     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
3861   }
3862 
3863   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
3864     return GetDescriptor();
3865   }
3866   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
3867     return default_instance().GetMetadata().descriptor;
3868   }
3869   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
3870     return default_instance().GetMetadata().reflection;
3871   }
3872   static const TypeProto_Sequence& default_instance() {
3873     return *reinterpret_cast<const TypeProto_Sequence*>(
3874         &_TypeProto_Sequence_default_instance_);
3875   }
3876   static constexpr int kIndexInFileMessages = 14;
3877   friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) { a.Swap(&b); }
3878   inline void Swap(TypeProto_Sequence* PROTOBUF_NONNULL other) {
3879     if (other == this) return;
3880     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
3881       InternalSwap(other);
3882     } else {
3883       ::google::protobuf::internal::GenericSwap(this, other);
3884     }
3885   }
3886   void UnsafeArenaSwap(TypeProto_Sequence* PROTOBUF_NONNULL other) {
3887     if (other == this) return;
3888     ABSL_DCHECK(GetArena() == other->GetArena());
3889     InternalSwap(other);
3890   }
3891 
3892   // implements Message ----------------------------------------------
3893 
3894   TypeProto_Sequence* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
3895     return ::google::protobuf::Message::DefaultConstruct<TypeProto_Sequence>(arena);
3896   }
3897   using ::google::protobuf::Message::CopyFrom;
3898   void CopyFrom(const TypeProto_Sequence& from);
3899   using ::google::protobuf::Message::MergeFrom;
3900   void MergeFrom(const TypeProto_Sequence& from) { TypeProto_Sequence::MergeImpl(*this, from); }
3901 
3902   private:
3903   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
3904                         const ::google::protobuf::MessageLite& from_msg);
3905 
3906   public:
3907   bool IsInitialized() const {
3908     return true;
3909   }
3910   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
3911   #if defined(PROTOBUF_CUSTOM_VTABLE)
3912   private:
3913   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
3914   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3915       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
3916       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
3917 
3918   public:
3919   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
3920   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3921       ::uint8_t* PROTOBUF_NONNULL target,
3922       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
3923     return _InternalSerialize(*this, target, stream);
3924   }
3925   #else   // PROTOBUF_CUSTOM_VTABLE
3926   ::size_t ByteSizeLong() const final;
3927   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
3928       ::uint8_t* PROTOBUF_NONNULL target,
3929       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
3930   #endif  // PROTOBUF_CUSTOM_VTABLE
3931   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
3932 
3933   private:
3934   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3935   static void SharedDtor(MessageLite& self);
3936   void InternalSwap(TypeProto_Sequence* PROTOBUF_NONNULL other);
3937  private:
3938   template <typename T>
3939   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
3940   static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Sequence"; }
3941 
3942  protected:
3943   explicit TypeProto_Sequence(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3944   TypeProto_Sequence(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Sequence& from);
3945   TypeProto_Sequence(
3946       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Sequence&& from) noexcept
3947       : TypeProto_Sequence(arena) {
3948     *this = ::std::move(from);
3949   }
3950   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
3951   static void* PROTOBUF_NONNULL PlacementNew_(
3952       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
3953       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
3954   static constexpr auto InternalNewImpl_();
3955 
3956  public:
3957   static constexpr auto InternalGenerateClassData_();
3958 
3959   ::google::protobuf::Metadata GetMetadata() const;
3960   // nested types ----------------------------------------------------
3961 
3962   // accessors -------------------------------------------------------
3963   enum : int {
3964     kElemTypeFieldNumber = 1,
3965   };
3966   // optional .onnx.TypeProto elem_type = 1;
3967   bool has_elem_type() const;
3968   void clear_elem_type() ;
3969   const ::onnx::TypeProto& elem_type() const;
3970   [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_elem_type();
3971   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_elem_type();
3972   void set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3973   void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
3974   ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_elem_type();
3975 
3976   private:
3977   const ::onnx::TypeProto& _internal_elem_type() const;
3978   ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_elem_type();
3979 
3980   public:
3981   // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence)
3982  private:
3983   class _Internal;
3984   friend class ::google::protobuf::internal::TcParser;
3985   static const ::google::protobuf::internal::TcParseTable<0, 1,
3986                                    1, 0,
3987                                    2>
3988       _table_;
3989 
3990   friend class ::google::protobuf::MessageLite;
3991   friend class ::google::protobuf::Arena;
3992   template <typename T>
3993   friend class ::google::protobuf::Arena::InternalHelper;
3994   using InternalArenaConstructable_ = void;
3995   using DestructorSkippable_ = void;
3996   struct Impl_ {
3997     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
3998     inline explicit Impl_(
3999         ::google::protobuf::internal::InternalVisibility visibility,
4000         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4001     inline explicit Impl_(
4002         ::google::protobuf::internal::InternalVisibility visibility,
4003         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
4004         const TypeProto_Sequence& from_msg);
4005     ::google::protobuf::internal::HasBits<1> _has_bits_;
4006     ::google::protobuf::internal::CachedSize _cached_size_;
4007     ::onnx::TypeProto* PROTOBUF_NULLABLE elem_type_;
4008     PROTOBUF_TSAN_DECLARE_MEMBER
4009   };
4010   union { Impl_ _impl_; };
4011   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
4012 };
4013 
4014 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TypeProto_Sequence_class_data_;
4015 // -------------------------------------------------------------------
4016 
4017 class ONNX_API ValueInfoProto final : public ::google::protobuf::Message
4018 /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
4019  public:
4020   inline ValueInfoProto() : ValueInfoProto(nullptr) {}
4021   ~ValueInfoProto() PROTOBUF_FINAL;
4022 
4023 #if defined(PROTOBUF_CUSTOM_VTABLE)
4024   void operator delete(ValueInfoProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
4025     SharedDtor(*msg);
4026     ::google::protobuf::internal::SizedDelete(msg, sizeof(ValueInfoProto));
4027   }
4028 #endif
4029 
4030   template <typename = void>
4031   explicit PROTOBUF_CONSTEXPR ValueInfoProto(::google::protobuf::internal::ConstantInitialized);
4032 
4033   inline ValueInfoProto(const ValueInfoProto& from) : ValueInfoProto(nullptr, from) {}
4034   inline ValueInfoProto(ValueInfoProto&& from) noexcept
4035       : ValueInfoProto(nullptr, ::std::move(from)) {}
4036   inline ValueInfoProto& operator=(const ValueInfoProto& from) {
4037     CopyFrom(from);
4038     return *this;
4039   }
4040   inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
4041     if (this == &from) return *this;
4042     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
4043       InternalSwap(&from);
4044     } else {
4045       CopyFrom(from);
4046     }
4047     return *this;
4048   }
4049 
4050   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
4051       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4052     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
4053   }
4054   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
4055       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4056     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
4057   }
4058 
4059   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
4060     return GetDescriptor();
4061   }
4062   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
4063     return default_instance().GetMetadata().descriptor;
4064   }
4065   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
4066     return default_instance().GetMetadata().reflection;
4067   }
4068   static const ValueInfoProto& default_instance() {
4069     return *reinterpret_cast<const ValueInfoProto*>(
4070         &_ValueInfoProto_default_instance_);
4071   }
4072   static constexpr int kIndexInFileMessages = 1;
4073   friend void swap(ValueInfoProto& a, ValueInfoProto& b) { a.Swap(&b); }
4074   inline void Swap(ValueInfoProto* PROTOBUF_NONNULL other) {
4075     if (other == this) return;
4076     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
4077       InternalSwap(other);
4078     } else {
4079       ::google::protobuf::internal::GenericSwap(this, other);
4080     }
4081   }
4082   void UnsafeArenaSwap(ValueInfoProto* PROTOBUF_NONNULL other) {
4083     if (other == this) return;
4084     ABSL_DCHECK(GetArena() == other->GetArena());
4085     InternalSwap(other);
4086   }
4087 
4088   // implements Message ----------------------------------------------
4089 
4090   ValueInfoProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
4091     return ::google::protobuf::Message::DefaultConstruct<ValueInfoProto>(arena);
4092   }
4093   using ::google::protobuf::Message::CopyFrom;
4094   void CopyFrom(const ValueInfoProto& from);
4095   using ::google::protobuf::Message::MergeFrom;
4096   void MergeFrom(const ValueInfoProto& from) { ValueInfoProto::MergeImpl(*this, from); }
4097 
4098   private:
4099   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
4100                         const ::google::protobuf::MessageLite& from_msg);
4101 
4102   public:
4103   bool IsInitialized() const {
4104     return true;
4105   }
4106   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
4107   #if defined(PROTOBUF_CUSTOM_VTABLE)
4108   private:
4109   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4110   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4111       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
4112       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
4113 
4114   public:
4115   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4116   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4117       ::uint8_t* PROTOBUF_NONNULL target,
4118       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
4119     return _InternalSerialize(*this, target, stream);
4120   }
4121   #else   // PROTOBUF_CUSTOM_VTABLE
4122   ::size_t ByteSizeLong() const final;
4123   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4124       ::uint8_t* PROTOBUF_NONNULL target,
4125       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
4126   #endif  // PROTOBUF_CUSTOM_VTABLE
4127   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4128 
4129   private:
4130   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4131   static void SharedDtor(MessageLite& self);
4132   void InternalSwap(ValueInfoProto* PROTOBUF_NONNULL other);
4133  private:
4134   template <typename T>
4135   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
4136   static ::absl::string_view FullMessageName() { return "onnx.ValueInfoProto"; }
4137 
4138  protected:
4139   explicit ValueInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4140   ValueInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ValueInfoProto& from);
4141   ValueInfoProto(
4142       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ValueInfoProto&& from) noexcept
4143       : ValueInfoProto(arena) {
4144     *this = ::std::move(from);
4145   }
4146   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
4147   static void* PROTOBUF_NONNULL PlacementNew_(
4148       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
4149       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4150   static constexpr auto InternalNewImpl_();
4151 
4152  public:
4153   static constexpr auto InternalGenerateClassData_();
4154 
4155   ::google::protobuf::Metadata GetMetadata() const;
4156   // nested types ----------------------------------------------------
4157 
4158   // accessors -------------------------------------------------------
4159   enum : int {
4160     kMetadataPropsFieldNumber = 4,
4161     kNameFieldNumber = 1,
4162     kDocStringFieldNumber = 3,
4163     kTypeFieldNumber = 2,
4164   };
4165   // repeated .onnx.StringStringEntryProto metadata_props = 4;
4166   int metadata_props_size() const;
4167   private:
4168   int _internal_metadata_props_size() const;
4169 
4170   public:
4171   void clear_metadata_props() ;
4172   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
4173   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
4174 
4175   private:
4176   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
4177   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
4178   public:
4179   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
4180   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
4181   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
4182   // optional string name = 1;
4183   bool has_name() const;
4184   void clear_name() ;
4185   const ::std::string& name() const;
4186   template <typename Arg_ = const ::std::string&, typename... Args_>
4187   void set_name(Arg_&& arg, Args_... args);
4188   ::std::string* PROTOBUF_NONNULL mutable_name();
4189   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
4190   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
4191 
4192   private:
4193   const ::std::string& _internal_name() const;
4194   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
4195   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
4196 
4197   public:
4198   // optional string doc_string = 3;
4199   bool has_doc_string() const;
4200   void clear_doc_string() ;
4201   const ::std::string& doc_string() const;
4202   template <typename Arg_ = const ::std::string&, typename... Args_>
4203   void set_doc_string(Arg_&& arg, Args_... args);
4204   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
4205   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
4206   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
4207 
4208   private:
4209   const ::std::string& _internal_doc_string() const;
4210   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
4211   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
4212 
4213   public:
4214   // optional .onnx.TypeProto type = 2;
4215   bool has_type() const;
4216   void clear_type() ;
4217   const ::onnx::TypeProto& type() const;
4218   [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_type();
4219   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_type();
4220   void set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
4221   void unsafe_arena_set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
4222   ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_type();
4223 
4224   private:
4225   const ::onnx::TypeProto& _internal_type() const;
4226   ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_type();
4227 
4228   public:
4229   // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
4230  private:
4231   class _Internal;
4232   friend class ::google::protobuf::internal::TcParser;
4233   static const ::google::protobuf::internal::TcParseTable<2, 4,
4234                                    2, 42,
4235                                    2>
4236       _table_;
4237 
4238   friend class ::google::protobuf::MessageLite;
4239   friend class ::google::protobuf::Arena;
4240   template <typename T>
4241   friend class ::google::protobuf::Arena::InternalHelper;
4242   using InternalArenaConstructable_ = void;
4243   using DestructorSkippable_ = void;
4244   struct Impl_ {
4245     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
4246     inline explicit Impl_(
4247         ::google::protobuf::internal::InternalVisibility visibility,
4248         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4249     inline explicit Impl_(
4250         ::google::protobuf::internal::InternalVisibility visibility,
4251         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
4252         const ValueInfoProto& from_msg);
4253     ::google::protobuf::internal::HasBits<1> _has_bits_;
4254     ::google::protobuf::internal::CachedSize _cached_size_;
4255     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
4256     ::google::protobuf::internal::ArenaStringPtr name_;
4257     ::google::protobuf::internal::ArenaStringPtr doc_string_;
4258     ::onnx::TypeProto* PROTOBUF_NULLABLE type_;
4259     PROTOBUF_TSAN_DECLARE_MEMBER
4260   };
4261   union { Impl_ _impl_; };
4262   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
4263 };
4264 
4265 ONNX_API extern const ::google::protobuf::internal::ClassDataFull ValueInfoProto_class_data_;
4266 // -------------------------------------------------------------------
4267 
4268 class ONNX_API AttributeProto final : public ::google::protobuf::Message
4269 /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
4270  public:
4271   inline AttributeProto() : AttributeProto(nullptr) {}
4272   ~AttributeProto() PROTOBUF_FINAL;
4273 
4274 #if defined(PROTOBUF_CUSTOM_VTABLE)
4275   void operator delete(AttributeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
4276     SharedDtor(*msg);
4277     ::google::protobuf::internal::SizedDelete(msg, sizeof(AttributeProto));
4278   }
4279 #endif
4280 
4281   template <typename = void>
4282   explicit PROTOBUF_CONSTEXPR AttributeProto(::google::protobuf::internal::ConstantInitialized);
4283 
4284   inline AttributeProto(const AttributeProto& from) : AttributeProto(nullptr, from) {}
4285   inline AttributeProto(AttributeProto&& from) noexcept
4286       : AttributeProto(nullptr, ::std::move(from)) {}
4287   inline AttributeProto& operator=(const AttributeProto& from) {
4288     CopyFrom(from);
4289     return *this;
4290   }
4291   inline AttributeProto& operator=(AttributeProto&& from) noexcept {
4292     if (this == &from) return *this;
4293     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
4294       InternalSwap(&from);
4295     } else {
4296       CopyFrom(from);
4297     }
4298     return *this;
4299   }
4300 
4301   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
4302       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4303     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
4304   }
4305   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
4306       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4307     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
4308   }
4309 
4310   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
4311     return GetDescriptor();
4312   }
4313   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
4314     return default_instance().GetMetadata().descriptor;
4315   }
4316   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
4317     return default_instance().GetMetadata().reflection;
4318   }
4319   static const AttributeProto& default_instance() {
4320     return *reinterpret_cast<const AttributeProto*>(
4321         &_AttributeProto_default_instance_);
4322   }
4323   static constexpr int kIndexInFileMessages = 0;
4324   friend void swap(AttributeProto& a, AttributeProto& b) { a.Swap(&b); }
4325   inline void Swap(AttributeProto* PROTOBUF_NONNULL other) {
4326     if (other == this) return;
4327     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
4328       InternalSwap(other);
4329     } else {
4330       ::google::protobuf::internal::GenericSwap(this, other);
4331     }
4332   }
4333   void UnsafeArenaSwap(AttributeProto* PROTOBUF_NONNULL other) {
4334     if (other == this) return;
4335     ABSL_DCHECK(GetArena() == other->GetArena());
4336     InternalSwap(other);
4337   }
4338 
4339   // implements Message ----------------------------------------------
4340 
4341   AttributeProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
4342     return ::google::protobuf::Message::DefaultConstruct<AttributeProto>(arena);
4343   }
4344   using ::google::protobuf::Message::CopyFrom;
4345   void CopyFrom(const AttributeProto& from);
4346   using ::google::protobuf::Message::MergeFrom;
4347   void MergeFrom(const AttributeProto& from) { AttributeProto::MergeImpl(*this, from); }
4348 
4349   private:
4350   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
4351                         const ::google::protobuf::MessageLite& from_msg);
4352 
4353   public:
4354   bool IsInitialized() const {
4355     return true;
4356   }
4357   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
4358   #if defined(PROTOBUF_CUSTOM_VTABLE)
4359   private:
4360   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4361   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4362       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
4363       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
4364 
4365   public:
4366   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4367   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4368       ::uint8_t* PROTOBUF_NONNULL target,
4369       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
4370     return _InternalSerialize(*this, target, stream);
4371   }
4372   #else   // PROTOBUF_CUSTOM_VTABLE
4373   ::size_t ByteSizeLong() const final;
4374   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4375       ::uint8_t* PROTOBUF_NONNULL target,
4376       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
4377   #endif  // PROTOBUF_CUSTOM_VTABLE
4378   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4379 
4380   private:
4381   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4382   static void SharedDtor(MessageLite& self);
4383   void InternalSwap(AttributeProto* PROTOBUF_NONNULL other);
4384  private:
4385   template <typename T>
4386   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
4387   static ::absl::string_view FullMessageName() { return "onnx.AttributeProto"; }
4388 
4389  protected:
4390   explicit AttributeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4391   AttributeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AttributeProto& from);
4392   AttributeProto(
4393       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AttributeProto&& from) noexcept
4394       : AttributeProto(arena) {
4395     *this = ::std::move(from);
4396   }
4397   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
4398   static void* PROTOBUF_NONNULL PlacementNew_(
4399       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
4400       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4401   static constexpr auto InternalNewImpl_();
4402 
4403  public:
4404   static constexpr auto InternalGenerateClassData_();
4405 
4406   ::google::protobuf::Metadata GetMetadata() const;
4407   // nested types ----------------------------------------------------
4408   using AttributeType = AttributeProto_AttributeType;
4409   static constexpr AttributeType UNDEFINED = AttributeProto_AttributeType_UNDEFINED;
4410   static constexpr AttributeType FLOAT = AttributeProto_AttributeType_FLOAT;
4411   static constexpr AttributeType INT = AttributeProto_AttributeType_INT;
4412   static constexpr AttributeType STRING = AttributeProto_AttributeType_STRING;
4413   static constexpr AttributeType TENSOR = AttributeProto_AttributeType_TENSOR;
4414   static constexpr AttributeType GRAPH = AttributeProto_AttributeType_GRAPH;
4415   static constexpr AttributeType SPARSE_TENSOR = AttributeProto_AttributeType_SPARSE_TENSOR;
4416   static constexpr AttributeType TYPE_PROTO = AttributeProto_AttributeType_TYPE_PROTO;
4417   static constexpr AttributeType FLOATS = AttributeProto_AttributeType_FLOATS;
4418   static constexpr AttributeType INTS = AttributeProto_AttributeType_INTS;
4419   static constexpr AttributeType STRINGS = AttributeProto_AttributeType_STRINGS;
4420   static constexpr AttributeType TENSORS = AttributeProto_AttributeType_TENSORS;
4421   static constexpr AttributeType GRAPHS = AttributeProto_AttributeType_GRAPHS;
4422   static constexpr AttributeType SPARSE_TENSORS = AttributeProto_AttributeType_SPARSE_TENSORS;
4423   static constexpr AttributeType TYPE_PROTOS = AttributeProto_AttributeType_TYPE_PROTOS;
4424   static inline bool AttributeType_IsValid(int value) {
4425     return AttributeProto_AttributeType_IsValid(value);
4426   }
4427   static constexpr AttributeType AttributeType_MIN = AttributeProto_AttributeType_AttributeType_MIN;
4428   static constexpr AttributeType AttributeType_MAX = AttributeProto_AttributeType_AttributeType_MAX;
4429   static constexpr int AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
4430   static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL AttributeType_descriptor() {
4431     return AttributeProto_AttributeType_descriptor();
4432   }
4433   template <typename T>
4434   static inline const ::std::string& AttributeType_Name(T value) {
4435     return AttributeProto_AttributeType_Name(value);
4436   }
4437   static inline bool AttributeType_Parse(
4438       ::absl::string_view name, AttributeType* PROTOBUF_NONNULL value) {
4439     return AttributeProto_AttributeType_Parse(name, value);
4440   }
4441 
4442   // accessors -------------------------------------------------------
4443   enum : int {
4444     kFloatsFieldNumber = 7,
4445     kIntsFieldNumber = 8,
4446     kStringsFieldNumber = 9,
4447     kTensorsFieldNumber = 10,
4448     kGraphsFieldNumber = 11,
4449     kTypeProtosFieldNumber = 15,
4450     kSparseTensorsFieldNumber = 23,
4451     kNameFieldNumber = 1,
4452     kSFieldNumber = 4,
4453     kDocStringFieldNumber = 13,
4454     kRefAttrNameFieldNumber = 21,
4455     kTFieldNumber = 5,
4456     kGFieldNumber = 6,
4457     kTpFieldNumber = 14,
4458     kSparseTensorFieldNumber = 22,
4459     kIFieldNumber = 3,
4460     kFFieldNumber = 2,
4461     kTypeFieldNumber = 20,
4462   };
4463   // repeated float floats = 7;
4464   int floats_size() const;
4465   private:
4466   int _internal_floats_size() const;
4467 
4468   public:
4469   void clear_floats() ;
4470   float floats(int index) const;
4471   void set_floats(int index, float value);
4472   void add_floats(float value);
4473   const ::google::protobuf::RepeatedField<float>& floats() const;
4474   ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL mutable_floats();
4475 
4476   private:
4477   const ::google::protobuf::RepeatedField<float>& _internal_floats() const;
4478   ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL _internal_mutable_floats();
4479 
4480   public:
4481   // repeated int64 ints = 8;
4482   int ints_size() const;
4483   private:
4484   int _internal_ints_size() const;
4485 
4486   public:
4487   void clear_ints() ;
4488   ::int64_t ints(int index) const;
4489   void set_ints(int index, ::int64_t value);
4490   void add_ints(::int64_t value);
4491   const ::google::protobuf::RepeatedField<::int64_t>& ints() const;
4492   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_ints();
4493 
4494   private:
4495   const ::google::protobuf::RepeatedField<::int64_t>& _internal_ints() const;
4496   ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_ints();
4497 
4498   public:
4499   // repeated bytes strings = 9;
4500   int strings_size() const;
4501   private:
4502   int _internal_strings_size() const;
4503 
4504   public:
4505   void clear_strings() ;
4506   const ::std::string& strings(int index) const;
4507   ::std::string* PROTOBUF_NONNULL mutable_strings(int index);
4508   template <typename Arg_ = const ::std::string&, typename... Args_>
4509   void set_strings(int index, Arg_&& value, Args_... args);
4510   ::std::string* PROTOBUF_NONNULL add_strings();
4511   template <typename Arg_ = const ::std::string&, typename... Args_>
4512   void add_strings(Arg_&& value, Args_... args);
4513   const ::google::protobuf::RepeatedPtrField<::std::string>& strings() const;
4514   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_strings();
4515 
4516   private:
4517   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_strings() const;
4518   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_strings();
4519 
4520   public:
4521   // repeated .onnx.TensorProto tensors = 10;
4522   int tensors_size() const;
4523   private:
4524   int _internal_tensors_size() const;
4525 
4526   public:
4527   void clear_tensors() ;
4528   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_tensors(int index);
4529   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL mutable_tensors();
4530 
4531   private:
4532   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensors() const;
4533   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL _internal_mutable_tensors();
4534   public:
4535   const ::onnx::TensorProto& tensors(int index) const;
4536   ::onnx::TensorProto* PROTOBUF_NONNULL add_tensors();
4537   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensors() const;
4538   // repeated .onnx.GraphProto graphs = 11;
4539   int graphs_size() const;
4540   private:
4541   int _internal_graphs_size() const;
4542 
4543   public:
4544   void clear_graphs() ;
4545   ::onnx::GraphProto* PROTOBUF_NONNULL mutable_graphs(int index);
4546   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL mutable_graphs();
4547 
4548   private:
4549   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& _internal_graphs() const;
4550   ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL _internal_mutable_graphs();
4551   public:
4552   const ::onnx::GraphProto& graphs(int index) const;
4553   ::onnx::GraphProto* PROTOBUF_NONNULL add_graphs();
4554   const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& graphs() const;
4555   // repeated .onnx.TypeProto type_protos = 15;
4556   int type_protos_size() const;
4557   private:
4558   int _internal_type_protos_size() const;
4559 
4560   public:
4561   void clear_type_protos() ;
4562   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_type_protos(int index);
4563   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL mutable_type_protos();
4564 
4565   private:
4566   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& _internal_type_protos() const;
4567   ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL _internal_mutable_type_protos();
4568   public:
4569   const ::onnx::TypeProto& type_protos(int index) const;
4570   ::onnx::TypeProto* PROTOBUF_NONNULL add_type_protos();
4571   const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& type_protos() const;
4572   // repeated .onnx.SparseTensorProto sparse_tensors = 23;
4573   int sparse_tensors_size() const;
4574   private:
4575   int _internal_sparse_tensors_size() const;
4576 
4577   public:
4578   void clear_sparse_tensors() ;
4579   ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensors(int index);
4580   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL mutable_sparse_tensors();
4581 
4582   private:
4583   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensors() const;
4584   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL _internal_mutable_sparse_tensors();
4585   public:
4586   const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
4587   ::onnx::SparseTensorProto* PROTOBUF_NONNULL add_sparse_tensors();
4588   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensors() const;
4589   // optional string name = 1;
4590   bool has_name() const;
4591   void clear_name() ;
4592   const ::std::string& name() const;
4593   template <typename Arg_ = const ::std::string&, typename... Args_>
4594   void set_name(Arg_&& arg, Args_... args);
4595   ::std::string* PROTOBUF_NONNULL mutable_name();
4596   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
4597   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
4598 
4599   private:
4600   const ::std::string& _internal_name() const;
4601   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
4602   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
4603 
4604   public:
4605   // optional bytes s = 4;
4606   bool has_s() const;
4607   void clear_s() ;
4608   const ::std::string& s() const;
4609   template <typename Arg_ = const ::std::string&, typename... Args_>
4610   void set_s(Arg_&& arg, Args_... args);
4611   ::std::string* PROTOBUF_NONNULL mutable_s();
4612   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s();
4613   void set_allocated_s(::std::string* PROTOBUF_NULLABLE value);
4614 
4615   private:
4616   const ::std::string& _internal_s() const;
4617   PROTOBUF_ALWAYS_INLINE void _internal_set_s(const ::std::string& value);
4618   ::std::string* PROTOBUF_NONNULL _internal_mutable_s();
4619 
4620   public:
4621   // optional string doc_string = 13;
4622   bool has_doc_string() const;
4623   void clear_doc_string() ;
4624   const ::std::string& doc_string() const;
4625   template <typename Arg_ = const ::std::string&, typename... Args_>
4626   void set_doc_string(Arg_&& arg, Args_... args);
4627   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
4628   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
4629   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
4630 
4631   private:
4632   const ::std::string& _internal_doc_string() const;
4633   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
4634   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
4635 
4636   public:
4637   // optional string ref_attr_name = 21;
4638   bool has_ref_attr_name() const;
4639   void clear_ref_attr_name() ;
4640   const ::std::string& ref_attr_name() const;
4641   template <typename Arg_ = const ::std::string&, typename... Args_>
4642   void set_ref_attr_name(Arg_&& arg, Args_... args);
4643   ::std::string* PROTOBUF_NONNULL mutable_ref_attr_name();
4644   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ref_attr_name();
4645   void set_allocated_ref_attr_name(::std::string* PROTOBUF_NULLABLE value);
4646 
4647   private:
4648   const ::std::string& _internal_ref_attr_name() const;
4649   PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(const ::std::string& value);
4650   ::std::string* PROTOBUF_NONNULL _internal_mutable_ref_attr_name();
4651 
4652   public:
4653   // optional .onnx.TensorProto t = 5;
4654   bool has_t() const;
4655   void clear_t() ;
4656   const ::onnx::TensorProto& t() const;
4657   [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_t();
4658   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_t();
4659   void set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value);
4660   void unsafe_arena_set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value);
4661   ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_t();
4662 
4663   private:
4664   const ::onnx::TensorProto& _internal_t() const;
4665   ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_t();
4666 
4667   public:
4668   // optional .onnx.GraphProto g = 6;
4669   bool has_g() const;
4670   void clear_g() ;
4671   const ::onnx::GraphProto& g() const;
4672   [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_g();
4673   ::onnx::GraphProto* PROTOBUF_NONNULL mutable_g();
4674   void set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value);
4675   void unsafe_arena_set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value);
4676   ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_g();
4677 
4678   private:
4679   const ::onnx::GraphProto& _internal_g() const;
4680   ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_g();
4681 
4682   public:
4683   // optional .onnx.TypeProto tp = 14;
4684   bool has_tp() const;
4685   void clear_tp() ;
4686   const ::onnx::TypeProto& tp() const;
4687   [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_tp();
4688   ::onnx::TypeProto* PROTOBUF_NONNULL mutable_tp();
4689   void set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value);
4690   void unsafe_arena_set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value);
4691   ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_tp();
4692 
4693   private:
4694   const ::onnx::TypeProto& _internal_tp() const;
4695   ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_tp();
4696 
4697   public:
4698   // optional .onnx.SparseTensorProto sparse_tensor = 22;
4699   bool has_sparse_tensor() const;
4700   void clear_sparse_tensor() ;
4701   const ::onnx::SparseTensorProto& sparse_tensor() const;
4702   [[nodiscard]] ::onnx::SparseTensorProto* PROTOBUF_NULLABLE release_sparse_tensor();
4703   ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensor();
4704   void set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
4705   void unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
4706   ::onnx::SparseTensorProto* PROTOBUF_NULLABLE unsafe_arena_release_sparse_tensor();
4707 
4708   private:
4709   const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
4710   ::onnx::SparseTensorProto* PROTOBUF_NONNULL _internal_mutable_sparse_tensor();
4711 
4712   public:
4713   // optional int64 i = 3;
4714   bool has_i() const;
4715   void clear_i() ;
4716   ::int64_t i() const;
4717   void set_i(::int64_t value);
4718 
4719   private:
4720   ::int64_t _internal_i() const;
4721   void _internal_set_i(::int64_t value);
4722 
4723   public:
4724   // optional float f = 2;
4725   bool has_f() const;
4726   void clear_f() ;
4727   float f() const;
4728   void set_f(float value);
4729 
4730   private:
4731   float _internal_f() const;
4732   void _internal_set_f(float value);
4733 
4734   public:
4735   // optional .onnx.AttributeProto.AttributeType type = 20;
4736   bool has_type() const;
4737   void clear_type() ;
4738   ::onnx::AttributeProto_AttributeType type() const;
4739   void set_type(::onnx::AttributeProto_AttributeType value);
4740 
4741   private:
4742   ::onnx::AttributeProto_AttributeType _internal_type() const;
4743   void _internal_set_type(::onnx::AttributeProto_AttributeType value);
4744 
4745   public:
4746   // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
4747  private:
4748   class _Internal;
4749   friend class ::google::protobuf::internal::TcParser;
4750   static const ::google::protobuf::internal::TcParseTable<5, 18,
4751                                    9, 71,
4752                                    2>
4753       _table_;
4754 
4755   friend class ::google::protobuf::MessageLite;
4756   friend class ::google::protobuf::Arena;
4757   template <typename T>
4758   friend class ::google::protobuf::Arena::InternalHelper;
4759   using InternalArenaConstructable_ = void;
4760   using DestructorSkippable_ = void;
4761   struct Impl_ {
4762     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
4763     inline explicit Impl_(
4764         ::google::protobuf::internal::InternalVisibility visibility,
4765         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4766     inline explicit Impl_(
4767         ::google::protobuf::internal::InternalVisibility visibility,
4768         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
4769         const AttributeProto& from_msg);
4770     ::google::protobuf::internal::HasBits<1> _has_bits_;
4771     ::google::protobuf::internal::CachedSize _cached_size_;
4772     ::google::protobuf::RepeatedField<float> floats_;
4773     ::google::protobuf::RepeatedField<::int64_t> ints_;
4774     ::google::protobuf::RepeatedPtrField<::std::string> strings_;
4775     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensors_;
4776     ::google::protobuf::RepeatedPtrField< ::onnx::GraphProto > graphs_;
4777     ::google::protobuf::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
4778     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
4779     ::google::protobuf::internal::ArenaStringPtr name_;
4780     ::google::protobuf::internal::ArenaStringPtr s_;
4781     ::google::protobuf::internal::ArenaStringPtr doc_string_;
4782     ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
4783     ::onnx::TensorProto* PROTOBUF_NULLABLE t_;
4784     ::onnx::GraphProto* PROTOBUF_NULLABLE g_;
4785     ::onnx::TypeProto* PROTOBUF_NULLABLE tp_;
4786     ::onnx::SparseTensorProto* PROTOBUF_NULLABLE sparse_tensor_;
4787     ::int64_t i_;
4788     float f_;
4789     int type_;
4790     PROTOBUF_TSAN_DECLARE_MEMBER
4791   };
4792   union { Impl_ _impl_; };
4793   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
4794 };
4795 
4796 ONNX_API extern const ::google::protobuf::internal::ClassDataFull AttributeProto_class_data_;
4797 // -------------------------------------------------------------------
4798 
4799 class ONNX_API GraphProto final : public ::google::protobuf::Message
4800 /* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
4801  public:
4802   inline GraphProto() : GraphProto(nullptr) {}
4803   ~GraphProto() PROTOBUF_FINAL;
4804 
4805 #if defined(PROTOBUF_CUSTOM_VTABLE)
4806   void operator delete(GraphProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
4807     SharedDtor(*msg);
4808     ::google::protobuf::internal::SizedDelete(msg, sizeof(GraphProto));
4809   }
4810 #endif
4811 
4812   template <typename = void>
4813   explicit PROTOBUF_CONSTEXPR GraphProto(::google::protobuf::internal::ConstantInitialized);
4814 
4815   inline GraphProto(const GraphProto& from) : GraphProto(nullptr, from) {}
4816   inline GraphProto(GraphProto&& from) noexcept
4817       : GraphProto(nullptr, ::std::move(from)) {}
4818   inline GraphProto& operator=(const GraphProto& from) {
4819     CopyFrom(from);
4820     return *this;
4821   }
4822   inline GraphProto& operator=(GraphProto&& from) noexcept {
4823     if (this == &from) return *this;
4824     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
4825       InternalSwap(&from);
4826     } else {
4827       CopyFrom(from);
4828     }
4829     return *this;
4830   }
4831 
4832   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
4833       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4834     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
4835   }
4836   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
4837       ABSL_ATTRIBUTE_LIFETIME_BOUND {
4838     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
4839   }
4840 
4841   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
4842     return GetDescriptor();
4843   }
4844   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
4845     return default_instance().GetMetadata().descriptor;
4846   }
4847   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
4848     return default_instance().GetMetadata().reflection;
4849   }
4850   static const GraphProto& default_instance() {
4851     return *reinterpret_cast<const GraphProto*>(
4852         &_GraphProto_default_instance_);
4853   }
4854   static constexpr int kIndexInFileMessages = 7;
4855   friend void swap(GraphProto& a, GraphProto& b) { a.Swap(&b); }
4856   inline void Swap(GraphProto* PROTOBUF_NONNULL other) {
4857     if (other == this) return;
4858     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
4859       InternalSwap(other);
4860     } else {
4861       ::google::protobuf::internal::GenericSwap(this, other);
4862     }
4863   }
4864   void UnsafeArenaSwap(GraphProto* PROTOBUF_NONNULL other) {
4865     if (other == this) return;
4866     ABSL_DCHECK(GetArena() == other->GetArena());
4867     InternalSwap(other);
4868   }
4869 
4870   // implements Message ----------------------------------------------
4871 
4872   GraphProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
4873     return ::google::protobuf::Message::DefaultConstruct<GraphProto>(arena);
4874   }
4875   using ::google::protobuf::Message::CopyFrom;
4876   void CopyFrom(const GraphProto& from);
4877   using ::google::protobuf::Message::MergeFrom;
4878   void MergeFrom(const GraphProto& from) { GraphProto::MergeImpl(*this, from); }
4879 
4880   private:
4881   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
4882                         const ::google::protobuf::MessageLite& from_msg);
4883 
4884   public:
4885   bool IsInitialized() const {
4886     return true;
4887   }
4888   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
4889   #if defined(PROTOBUF_CUSTOM_VTABLE)
4890   private:
4891   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
4892   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4893       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
4894       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
4895 
4896   public:
4897   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
4898   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4899       ::uint8_t* PROTOBUF_NONNULL target,
4900       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
4901     return _InternalSerialize(*this, target, stream);
4902   }
4903   #else   // PROTOBUF_CUSTOM_VTABLE
4904   ::size_t ByteSizeLong() const final;
4905   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
4906       ::uint8_t* PROTOBUF_NONNULL target,
4907       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
4908   #endif  // PROTOBUF_CUSTOM_VTABLE
4909   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
4910 
4911   private:
4912   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4913   static void SharedDtor(MessageLite& self);
4914   void InternalSwap(GraphProto* PROTOBUF_NONNULL other);
4915  private:
4916   template <typename T>
4917   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
4918   static ::absl::string_view FullMessageName() { return "onnx.GraphProto"; }
4919 
4920  protected:
4921   explicit GraphProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4922   GraphProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GraphProto& from);
4923   GraphProto(
4924       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GraphProto&& from) noexcept
4925       : GraphProto(arena) {
4926     *this = ::std::move(from);
4927   }
4928   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
4929   static void* PROTOBUF_NONNULL PlacementNew_(
4930       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
4931       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
4932   static constexpr auto InternalNewImpl_();
4933 
4934  public:
4935   static constexpr auto InternalGenerateClassData_();
4936 
4937   ::google::protobuf::Metadata GetMetadata() const;
4938   // nested types ----------------------------------------------------
4939 
4940   // accessors -------------------------------------------------------
4941   enum : int {
4942     kNodeFieldNumber = 1,
4943     kInitializerFieldNumber = 5,
4944     kInputFieldNumber = 11,
4945     kOutputFieldNumber = 12,
4946     kValueInfoFieldNumber = 13,
4947     kQuantizationAnnotationFieldNumber = 14,
4948     kSparseInitializerFieldNumber = 15,
4949     kMetadataPropsFieldNumber = 16,
4950     kNameFieldNumber = 2,
4951     kDocStringFieldNumber = 10,
4952   };
4953   // repeated .onnx.NodeProto node = 1;
4954   int node_size() const;
4955   private:
4956   int _internal_node_size() const;
4957 
4958   public:
4959   void clear_node() ;
4960   ::onnx::NodeProto* PROTOBUF_NONNULL mutable_node(int index);
4961   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL mutable_node();
4962 
4963   private:
4964   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
4965   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL _internal_mutable_node();
4966   public:
4967   const ::onnx::NodeProto& node(int index) const;
4968   ::onnx::NodeProto* PROTOBUF_NONNULL add_node();
4969   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
4970   // repeated .onnx.TensorProto initializer = 5;
4971   int initializer_size() const;
4972   private:
4973   int _internal_initializer_size() const;
4974 
4975   public:
4976   void clear_initializer() ;
4977   ::onnx::TensorProto* PROTOBUF_NONNULL mutable_initializer(int index);
4978   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL mutable_initializer();
4979 
4980   private:
4981   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_initializer() const;
4982   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL _internal_mutable_initializer();
4983   public:
4984   const ::onnx::TensorProto& initializer(int index) const;
4985   ::onnx::TensorProto* PROTOBUF_NONNULL add_initializer();
4986   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& initializer() const;
4987   // repeated .onnx.ValueInfoProto input = 11;
4988   int input_size() const;
4989   private:
4990   int _internal_input_size() const;
4991 
4992   public:
4993   void clear_input() ;
4994   ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_input(int index);
4995   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL mutable_input();
4996 
4997   private:
4998   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_input() const;
4999   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_input();
5000   public:
5001   const ::onnx::ValueInfoProto& input(int index) const;
5002   ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_input();
5003   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& input() const;
5004   // repeated .onnx.ValueInfoProto output = 12;
5005   int output_size() const;
5006   private:
5007   int _internal_output_size() const;
5008 
5009   public:
5010   void clear_output() ;
5011   ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_output(int index);
5012   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL mutable_output();
5013 
5014   private:
5015   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_output() const;
5016   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_output();
5017   public:
5018   const ::onnx::ValueInfoProto& output(int index) const;
5019   ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_output();
5020   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& output() const;
5021   // repeated .onnx.ValueInfoProto value_info = 13;
5022   int value_info_size() const;
5023   private:
5024   int _internal_value_info_size() const;
5025 
5026   public:
5027   void clear_value_info() ;
5028   ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_value_info(int index);
5029   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL mutable_value_info();
5030 
5031   private:
5032   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
5033   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_value_info();
5034   public:
5035   const ::onnx::ValueInfoProto& value_info(int index) const;
5036   ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_value_info();
5037   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info() const;
5038   // repeated .onnx.TensorAnnotation quantization_annotation = 14;
5039   int quantization_annotation_size() const;
5040   private:
5041   int _internal_quantization_annotation_size() const;
5042 
5043   public:
5044   void clear_quantization_annotation() ;
5045   ::onnx::TensorAnnotation* PROTOBUF_NONNULL mutable_quantization_annotation(int index);
5046   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL mutable_quantization_annotation();
5047 
5048   private:
5049   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& _internal_quantization_annotation() const;
5050   ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL _internal_mutable_quantization_annotation();
5051   public:
5052   const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
5053   ::onnx::TensorAnnotation* PROTOBUF_NONNULL add_quantization_annotation();
5054   const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& quantization_annotation() const;
5055   // repeated .onnx.SparseTensorProto sparse_initializer = 15;
5056   int sparse_initializer_size() const;
5057   private:
5058   int _internal_sparse_initializer_size() const;
5059 
5060   public:
5061   void clear_sparse_initializer() ;
5062   ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_initializer(int index);
5063   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL mutable_sparse_initializer();
5064 
5065   private:
5066   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_initializer() const;
5067   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL _internal_mutable_sparse_initializer();
5068   public:
5069   const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
5070   ::onnx::SparseTensorProto* PROTOBUF_NONNULL add_sparse_initializer();
5071   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_initializer() const;
5072   // repeated .onnx.StringStringEntryProto metadata_props = 16;
5073   int metadata_props_size() const;
5074   private:
5075   int _internal_metadata_props_size() const;
5076 
5077   public:
5078   void clear_metadata_props() ;
5079   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
5080   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
5081 
5082   private:
5083   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
5084   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
5085   public:
5086   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
5087   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
5088   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
5089   // optional string name = 2;
5090   bool has_name() const;
5091   void clear_name() ;
5092   const ::std::string& name() const;
5093   template <typename Arg_ = const ::std::string&, typename... Args_>
5094   void set_name(Arg_&& arg, Args_... args);
5095   ::std::string* PROTOBUF_NONNULL mutable_name();
5096   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
5097   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
5098 
5099   private:
5100   const ::std::string& _internal_name() const;
5101   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
5102   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
5103 
5104   public:
5105   // optional string doc_string = 10;
5106   bool has_doc_string() const;
5107   void clear_doc_string() ;
5108   const ::std::string& doc_string() const;
5109   template <typename Arg_ = const ::std::string&, typename... Args_>
5110   void set_doc_string(Arg_&& arg, Args_... args);
5111   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
5112   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
5113   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
5114 
5115   private:
5116   const ::std::string& _internal_doc_string() const;
5117   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
5118   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
5119 
5120   public:
5121   // @@protoc_insertion_point(class_scope:onnx.GraphProto)
5122  private:
5123   class _Internal;
5124   friend class ::google::protobuf::internal::TcParser;
5125   static const ::google::protobuf::internal::TcParseTable<4, 10,
5126                                    8, 46,
5127                                    2>
5128       _table_;
5129 
5130   friend class ::google::protobuf::MessageLite;
5131   friend class ::google::protobuf::Arena;
5132   template <typename T>
5133   friend class ::google::protobuf::Arena::InternalHelper;
5134   using InternalArenaConstructable_ = void;
5135   using DestructorSkippable_ = void;
5136   struct Impl_ {
5137     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
5138     inline explicit Impl_(
5139         ::google::protobuf::internal::InternalVisibility visibility,
5140         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5141     inline explicit Impl_(
5142         ::google::protobuf::internal::InternalVisibility visibility,
5143         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
5144         const GraphProto& from_msg);
5145     ::google::protobuf::internal::HasBits<1> _has_bits_;
5146     ::google::protobuf::internal::CachedSize _cached_size_;
5147     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
5148     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > initializer_;
5149     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
5150     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
5151     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
5152     ::google::protobuf::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
5153     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
5154     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
5155     ::google::protobuf::internal::ArenaStringPtr name_;
5156     ::google::protobuf::internal::ArenaStringPtr doc_string_;
5157     PROTOBUF_TSAN_DECLARE_MEMBER
5158   };
5159   union { Impl_ _impl_; };
5160   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5161 };
5162 
5163 ONNX_API extern const ::google::protobuf::internal::ClassDataFull GraphProto_class_data_;
5164 // -------------------------------------------------------------------
5165 
5166 class ONNX_API NodeProto final : public ::google::protobuf::Message
5167 /* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
5168  public:
5169   inline NodeProto() : NodeProto(nullptr) {}
5170   ~NodeProto() PROTOBUF_FINAL;
5171 
5172 #if defined(PROTOBUF_CUSTOM_VTABLE)
5173   void operator delete(NodeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
5174     SharedDtor(*msg);
5175     ::google::protobuf::internal::SizedDelete(msg, sizeof(NodeProto));
5176   }
5177 #endif
5178 
5179   template <typename = void>
5180   explicit PROTOBUF_CONSTEXPR NodeProto(::google::protobuf::internal::ConstantInitialized);
5181 
5182   inline NodeProto(const NodeProto& from) : NodeProto(nullptr, from) {}
5183   inline NodeProto(NodeProto&& from) noexcept
5184       : NodeProto(nullptr, ::std::move(from)) {}
5185   inline NodeProto& operator=(const NodeProto& from) {
5186     CopyFrom(from);
5187     return *this;
5188   }
5189   inline NodeProto& operator=(NodeProto&& from) noexcept {
5190     if (this == &from) return *this;
5191     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
5192       InternalSwap(&from);
5193     } else {
5194       CopyFrom(from);
5195     }
5196     return *this;
5197   }
5198 
5199   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5200       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5201     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5202   }
5203   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
5204       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5205     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5206   }
5207 
5208   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
5209     return GetDescriptor();
5210   }
5211   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
5212     return default_instance().GetMetadata().descriptor;
5213   }
5214   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
5215     return default_instance().GetMetadata().reflection;
5216   }
5217   static const NodeProto& default_instance() {
5218     return *reinterpret_cast<const NodeProto*>(
5219         &_NodeProto_default_instance_);
5220   }
5221   static constexpr int kIndexInFileMessages = 2;
5222   friend void swap(NodeProto& a, NodeProto& b) { a.Swap(&b); }
5223   inline void Swap(NodeProto* PROTOBUF_NONNULL other) {
5224     if (other == this) return;
5225     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
5226       InternalSwap(other);
5227     } else {
5228       ::google::protobuf::internal::GenericSwap(this, other);
5229     }
5230   }
5231   void UnsafeArenaSwap(NodeProto* PROTOBUF_NONNULL other) {
5232     if (other == this) return;
5233     ABSL_DCHECK(GetArena() == other->GetArena());
5234     InternalSwap(other);
5235   }
5236 
5237   // implements Message ----------------------------------------------
5238 
5239   NodeProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
5240     return ::google::protobuf::Message::DefaultConstruct<NodeProto>(arena);
5241   }
5242   using ::google::protobuf::Message::CopyFrom;
5243   void CopyFrom(const NodeProto& from);
5244   using ::google::protobuf::Message::MergeFrom;
5245   void MergeFrom(const NodeProto& from) { NodeProto::MergeImpl(*this, from); }
5246 
5247   private:
5248   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
5249                         const ::google::protobuf::MessageLite& from_msg);
5250 
5251   public:
5252   bool IsInitialized() const {
5253     return true;
5254   }
5255   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5256   #if defined(PROTOBUF_CUSTOM_VTABLE)
5257   private:
5258   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5259   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5260       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
5261       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
5262 
5263   public:
5264   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5265   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5266       ::uint8_t* PROTOBUF_NONNULL target,
5267       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
5268     return _InternalSerialize(*this, target, stream);
5269   }
5270   #else   // PROTOBUF_CUSTOM_VTABLE
5271   ::size_t ByteSizeLong() const final;
5272   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5273       ::uint8_t* PROTOBUF_NONNULL target,
5274       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
5275   #endif  // PROTOBUF_CUSTOM_VTABLE
5276   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5277 
5278   private:
5279   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5280   static void SharedDtor(MessageLite& self);
5281   void InternalSwap(NodeProto* PROTOBUF_NONNULL other);
5282  private:
5283   template <typename T>
5284   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
5285   static ::absl::string_view FullMessageName() { return "onnx.NodeProto"; }
5286 
5287  protected:
5288   explicit NodeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5289   NodeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeProto& from);
5290   NodeProto(
5291       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NodeProto&& from) noexcept
5292       : NodeProto(arena) {
5293     *this = ::std::move(from);
5294   }
5295   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
5296   static void* PROTOBUF_NONNULL PlacementNew_(
5297       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
5298       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5299   static constexpr auto InternalNewImpl_();
5300 
5301  public:
5302   static constexpr auto InternalGenerateClassData_();
5303 
5304   ::google::protobuf::Metadata GetMetadata() const;
5305   // nested types ----------------------------------------------------
5306 
5307   // accessors -------------------------------------------------------
5308   enum : int {
5309     kInputFieldNumber = 1,
5310     kOutputFieldNumber = 2,
5311     kAttributeFieldNumber = 5,
5312     kMetadataPropsFieldNumber = 9,
5313     kNameFieldNumber = 3,
5314     kOpTypeFieldNumber = 4,
5315     kDocStringFieldNumber = 6,
5316     kDomainFieldNumber = 7,
5317     kOverloadFieldNumber = 8,
5318   };
5319   // repeated string input = 1;
5320   int input_size() const;
5321   private:
5322   int _internal_input_size() const;
5323 
5324   public:
5325   void clear_input() ;
5326   const ::std::string& input(int index) const;
5327   ::std::string* PROTOBUF_NONNULL mutable_input(int index);
5328   template <typename Arg_ = const ::std::string&, typename... Args_>
5329   void set_input(int index, Arg_&& value, Args_... args);
5330   ::std::string* PROTOBUF_NONNULL add_input();
5331   template <typename Arg_ = const ::std::string&, typename... Args_>
5332   void add_input(Arg_&& value, Args_... args);
5333   const ::google::protobuf::RepeatedPtrField<::std::string>& input() const;
5334   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_input();
5335 
5336   private:
5337   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_input() const;
5338   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_input();
5339 
5340   public:
5341   // repeated string output = 2;
5342   int output_size() const;
5343   private:
5344   int _internal_output_size() const;
5345 
5346   public:
5347   void clear_output() ;
5348   const ::std::string& output(int index) const;
5349   ::std::string* PROTOBUF_NONNULL mutable_output(int index);
5350   template <typename Arg_ = const ::std::string&, typename... Args_>
5351   void set_output(int index, Arg_&& value, Args_... args);
5352   ::std::string* PROTOBUF_NONNULL add_output();
5353   template <typename Arg_ = const ::std::string&, typename... Args_>
5354   void add_output(Arg_&& value, Args_... args);
5355   const ::google::protobuf::RepeatedPtrField<::std::string>& output() const;
5356   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_output();
5357 
5358   private:
5359   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_output() const;
5360   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_output();
5361 
5362   public:
5363   // repeated .onnx.AttributeProto attribute = 5;
5364   int attribute_size() const;
5365   private:
5366   int _internal_attribute_size() const;
5367 
5368   public:
5369   void clear_attribute() ;
5370   ::onnx::AttributeProto* PROTOBUF_NONNULL mutable_attribute(int index);
5371   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL mutable_attribute();
5372 
5373   private:
5374   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute() const;
5375   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL _internal_mutable_attribute();
5376   public:
5377   const ::onnx::AttributeProto& attribute(int index) const;
5378   ::onnx::AttributeProto* PROTOBUF_NONNULL add_attribute();
5379   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute() const;
5380   // repeated .onnx.StringStringEntryProto metadata_props = 9;
5381   int metadata_props_size() const;
5382   private:
5383   int _internal_metadata_props_size() const;
5384 
5385   public:
5386   void clear_metadata_props() ;
5387   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
5388   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
5389 
5390   private:
5391   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
5392   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
5393   public:
5394   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
5395   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
5396   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
5397   // optional string name = 3;
5398   bool has_name() const;
5399   void clear_name() ;
5400   const ::std::string& name() const;
5401   template <typename Arg_ = const ::std::string&, typename... Args_>
5402   void set_name(Arg_&& arg, Args_... args);
5403   ::std::string* PROTOBUF_NONNULL mutable_name();
5404   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
5405   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
5406 
5407   private:
5408   const ::std::string& _internal_name() const;
5409   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
5410   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
5411 
5412   public:
5413   // optional string op_type = 4;
5414   bool has_op_type() const;
5415   void clear_op_type() ;
5416   const ::std::string& op_type() const;
5417   template <typename Arg_ = const ::std::string&, typename... Args_>
5418   void set_op_type(Arg_&& arg, Args_... args);
5419   ::std::string* PROTOBUF_NONNULL mutable_op_type();
5420   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_op_type();
5421   void set_allocated_op_type(::std::string* PROTOBUF_NULLABLE value);
5422 
5423   private:
5424   const ::std::string& _internal_op_type() const;
5425   PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(const ::std::string& value);
5426   ::std::string* PROTOBUF_NONNULL _internal_mutable_op_type();
5427 
5428   public:
5429   // optional string doc_string = 6;
5430   bool has_doc_string() const;
5431   void clear_doc_string() ;
5432   const ::std::string& doc_string() const;
5433   template <typename Arg_ = const ::std::string&, typename... Args_>
5434   void set_doc_string(Arg_&& arg, Args_... args);
5435   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
5436   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
5437   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
5438 
5439   private:
5440   const ::std::string& _internal_doc_string() const;
5441   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
5442   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
5443 
5444   public:
5445   // optional string domain = 7;
5446   bool has_domain() const;
5447   void clear_domain() ;
5448   const ::std::string& domain() const;
5449   template <typename Arg_ = const ::std::string&, typename... Args_>
5450   void set_domain(Arg_&& arg, Args_... args);
5451   ::std::string* PROTOBUF_NONNULL mutable_domain();
5452   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
5453   void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);
5454 
5455   private:
5456   const ::std::string& _internal_domain() const;
5457   PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
5458   ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();
5459 
5460   public:
5461   // optional string overload = 8;
5462   bool has_overload() const;
5463   void clear_overload() ;
5464   const ::std::string& overload() const;
5465   template <typename Arg_ = const ::std::string&, typename... Args_>
5466   void set_overload(Arg_&& arg, Args_... args);
5467   ::std::string* PROTOBUF_NONNULL mutable_overload();
5468   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_overload();
5469   void set_allocated_overload(::std::string* PROTOBUF_NULLABLE value);
5470 
5471   private:
5472   const ::std::string& _internal_overload() const;
5473   PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const ::std::string& value);
5474   ::std::string* PROTOBUF_NONNULL _internal_mutable_overload();
5475 
5476   public:
5477   // @@protoc_insertion_point(class_scope:onnx.NodeProto)
5478  private:
5479   class _Internal;
5480   friend class ::google::protobuf::internal::TcParser;
5481   static const ::google::protobuf::internal::TcParseTable<4, 9,
5482                                    2, 77,
5483                                    2>
5484       _table_;
5485 
5486   friend class ::google::protobuf::MessageLite;
5487   friend class ::google::protobuf::Arena;
5488   template <typename T>
5489   friend class ::google::protobuf::Arena::InternalHelper;
5490   using InternalArenaConstructable_ = void;
5491   using DestructorSkippable_ = void;
5492   struct Impl_ {
5493     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
5494     inline explicit Impl_(
5495         ::google::protobuf::internal::InternalVisibility visibility,
5496         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5497     inline explicit Impl_(
5498         ::google::protobuf::internal::InternalVisibility visibility,
5499         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
5500         const NodeProto& from_msg);
5501     ::google::protobuf::internal::HasBits<1> _has_bits_;
5502     ::google::protobuf::internal::CachedSize _cached_size_;
5503     ::google::protobuf::RepeatedPtrField<::std::string> input_;
5504     ::google::protobuf::RepeatedPtrField<::std::string> output_;
5505     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
5506     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
5507     ::google::protobuf::internal::ArenaStringPtr name_;
5508     ::google::protobuf::internal::ArenaStringPtr op_type_;
5509     ::google::protobuf::internal::ArenaStringPtr doc_string_;
5510     ::google::protobuf::internal::ArenaStringPtr domain_;
5511     ::google::protobuf::internal::ArenaStringPtr overload_;
5512     PROTOBUF_TSAN_DECLARE_MEMBER
5513   };
5514   union { Impl_ _impl_; };
5515   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5516 };
5517 
5518 ONNX_API extern const ::google::protobuf::internal::ClassDataFull NodeProto_class_data_;
5519 // -------------------------------------------------------------------
5520 
5521 class ONNX_API TrainingInfoProto final : public ::google::protobuf::Message
5522 /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
5523  public:
5524   inline TrainingInfoProto() : TrainingInfoProto(nullptr) {}
5525   ~TrainingInfoProto() PROTOBUF_FINAL;
5526 
5527 #if defined(PROTOBUF_CUSTOM_VTABLE)
5528   void operator delete(TrainingInfoProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
5529     SharedDtor(*msg);
5530     ::google::protobuf::internal::SizedDelete(msg, sizeof(TrainingInfoProto));
5531   }
5532 #endif
5533 
5534   template <typename = void>
5535   explicit PROTOBUF_CONSTEXPR TrainingInfoProto(::google::protobuf::internal::ConstantInitialized);
5536 
5537   inline TrainingInfoProto(const TrainingInfoProto& from) : TrainingInfoProto(nullptr, from) {}
5538   inline TrainingInfoProto(TrainingInfoProto&& from) noexcept
5539       : TrainingInfoProto(nullptr, ::std::move(from)) {}
5540   inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
5541     CopyFrom(from);
5542     return *this;
5543   }
5544   inline TrainingInfoProto& operator=(TrainingInfoProto&& from) noexcept {
5545     if (this == &from) return *this;
5546     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
5547       InternalSwap(&from);
5548     } else {
5549       CopyFrom(from);
5550     }
5551     return *this;
5552   }
5553 
5554   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5555       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5556     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5557   }
5558   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
5559       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5560     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5561   }
5562 
5563   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
5564     return GetDescriptor();
5565   }
5566   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
5567     return default_instance().GetMetadata().descriptor;
5568   }
5569   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
5570     return default_instance().GetMetadata().reflection;
5571   }
5572   static const TrainingInfoProto& default_instance() {
5573     return *reinterpret_cast<const TrainingInfoProto*>(
5574         &_TrainingInfoProto_default_instance_);
5575   }
5576   static constexpr int kIndexInFileMessages = 3;
5577   friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) { a.Swap(&b); }
5578   inline void Swap(TrainingInfoProto* PROTOBUF_NONNULL other) {
5579     if (other == this) return;
5580     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
5581       InternalSwap(other);
5582     } else {
5583       ::google::protobuf::internal::GenericSwap(this, other);
5584     }
5585   }
5586   void UnsafeArenaSwap(TrainingInfoProto* PROTOBUF_NONNULL other) {
5587     if (other == this) return;
5588     ABSL_DCHECK(GetArena() == other->GetArena());
5589     InternalSwap(other);
5590   }
5591 
5592   // implements Message ----------------------------------------------
5593 
5594   TrainingInfoProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
5595     return ::google::protobuf::Message::DefaultConstruct<TrainingInfoProto>(arena);
5596   }
5597   using ::google::protobuf::Message::CopyFrom;
5598   void CopyFrom(const TrainingInfoProto& from);
5599   using ::google::protobuf::Message::MergeFrom;
5600   void MergeFrom(const TrainingInfoProto& from) { TrainingInfoProto::MergeImpl(*this, from); }
5601 
5602   private:
5603   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
5604                         const ::google::protobuf::MessageLite& from_msg);
5605 
5606   public:
5607   bool IsInitialized() const {
5608     return true;
5609   }
5610   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5611   #if defined(PROTOBUF_CUSTOM_VTABLE)
5612   private:
5613   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5614   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5615       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
5616       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
5617 
5618   public:
5619   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5620   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5621       ::uint8_t* PROTOBUF_NONNULL target,
5622       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
5623     return _InternalSerialize(*this, target, stream);
5624   }
5625   #else   // PROTOBUF_CUSTOM_VTABLE
5626   ::size_t ByteSizeLong() const final;
5627   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5628       ::uint8_t* PROTOBUF_NONNULL target,
5629       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
5630   #endif  // PROTOBUF_CUSTOM_VTABLE
5631   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5632 
5633   private:
5634   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5635   static void SharedDtor(MessageLite& self);
5636   void InternalSwap(TrainingInfoProto* PROTOBUF_NONNULL other);
5637  private:
5638   template <typename T>
5639   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
5640   static ::absl::string_view FullMessageName() { return "onnx.TrainingInfoProto"; }
5641 
5642  protected:
5643   explicit TrainingInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5644   TrainingInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TrainingInfoProto& from);
5645   TrainingInfoProto(
5646       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TrainingInfoProto&& from) noexcept
5647       : TrainingInfoProto(arena) {
5648     *this = ::std::move(from);
5649   }
5650   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
5651   static void* PROTOBUF_NONNULL PlacementNew_(
5652       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
5653       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5654   static constexpr auto InternalNewImpl_();
5655 
5656  public:
5657   static constexpr auto InternalGenerateClassData_();
5658 
5659   ::google::protobuf::Metadata GetMetadata() const;
5660   // nested types ----------------------------------------------------
5661 
5662   // accessors -------------------------------------------------------
5663   enum : int {
5664     kInitializationBindingFieldNumber = 3,
5665     kUpdateBindingFieldNumber = 4,
5666     kInitializationFieldNumber = 1,
5667     kAlgorithmFieldNumber = 2,
5668   };
5669   // repeated .onnx.StringStringEntryProto initialization_binding = 3;
5670   int initialization_binding_size() const;
5671   private:
5672   int _internal_initialization_binding_size() const;
5673 
5674   public:
5675   void clear_initialization_binding() ;
5676   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_initialization_binding(int index);
5677   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_initialization_binding();
5678 
5679   private:
5680   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_initialization_binding() const;
5681   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_initialization_binding();
5682   public:
5683   const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
5684   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_initialization_binding();
5685   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& initialization_binding() const;
5686   // repeated .onnx.StringStringEntryProto update_binding = 4;
5687   int update_binding_size() const;
5688   private:
5689   int _internal_update_binding_size() const;
5690 
5691   public:
5692   void clear_update_binding() ;
5693   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_update_binding(int index);
5694   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_update_binding();
5695 
5696   private:
5697   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_update_binding() const;
5698   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_update_binding();
5699   public:
5700   const ::onnx::StringStringEntryProto& update_binding(int index) const;
5701   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_update_binding();
5702   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& update_binding() const;
5703   // optional .onnx.GraphProto initialization = 1;
5704   bool has_initialization() const;
5705   void clear_initialization() ;
5706   const ::onnx::GraphProto& initialization() const;
5707   [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_initialization();
5708   ::onnx::GraphProto* PROTOBUF_NONNULL mutable_initialization();
5709   void set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value);
5710   void unsafe_arena_set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value);
5711   ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_initialization();
5712 
5713   private:
5714   const ::onnx::GraphProto& _internal_initialization() const;
5715   ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_initialization();
5716 
5717   public:
5718   // optional .onnx.GraphProto algorithm = 2;
5719   bool has_algorithm() const;
5720   void clear_algorithm() ;
5721   const ::onnx::GraphProto& algorithm() const;
5722   [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_algorithm();
5723   ::onnx::GraphProto* PROTOBUF_NONNULL mutable_algorithm();
5724   void set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value);
5725   void unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value);
5726   ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_algorithm();
5727 
5728   private:
5729   const ::onnx::GraphProto& _internal_algorithm() const;
5730   ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_algorithm();
5731 
5732   public:
5733   // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
5734  private:
5735   class _Internal;
5736   friend class ::google::protobuf::internal::TcParser;
5737   static const ::google::protobuf::internal::TcParseTable<2, 4,
5738                                    4, 0,
5739                                    2>
5740       _table_;
5741 
5742   friend class ::google::protobuf::MessageLite;
5743   friend class ::google::protobuf::Arena;
5744   template <typename T>
5745   friend class ::google::protobuf::Arena::InternalHelper;
5746   using InternalArenaConstructable_ = void;
5747   using DestructorSkippable_ = void;
5748   struct Impl_ {
5749     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
5750     inline explicit Impl_(
5751         ::google::protobuf::internal::InternalVisibility visibility,
5752         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5753     inline explicit Impl_(
5754         ::google::protobuf::internal::InternalVisibility visibility,
5755         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
5756         const TrainingInfoProto& from_msg);
5757     ::google::protobuf::internal::HasBits<1> _has_bits_;
5758     ::google::protobuf::internal::CachedSize _cached_size_;
5759     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
5760     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
5761     ::onnx::GraphProto* PROTOBUF_NULLABLE initialization_;
5762     ::onnx::GraphProto* PROTOBUF_NULLABLE algorithm_;
5763     PROTOBUF_TSAN_DECLARE_MEMBER
5764   };
5765   union { Impl_ _impl_; };
5766   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
5767 };
5768 
5769 ONNX_API extern const ::google::protobuf::internal::ClassDataFull TrainingInfoProto_class_data_;
5770 // -------------------------------------------------------------------
5771 
5772 class ONNX_API FunctionProto final : public ::google::protobuf::Message
5773 /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
5774  public:
5775   inline FunctionProto() : FunctionProto(nullptr) {}
5776   ~FunctionProto() PROTOBUF_FINAL;
5777 
5778 #if defined(PROTOBUF_CUSTOM_VTABLE)
5779   void operator delete(FunctionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
5780     SharedDtor(*msg);
5781     ::google::protobuf::internal::SizedDelete(msg, sizeof(FunctionProto));
5782   }
5783 #endif
5784 
5785   template <typename = void>
5786   explicit PROTOBUF_CONSTEXPR FunctionProto(::google::protobuf::internal::ConstantInitialized);
5787 
5788   inline FunctionProto(const FunctionProto& from) : FunctionProto(nullptr, from) {}
5789   inline FunctionProto(FunctionProto&& from) noexcept
5790       : FunctionProto(nullptr, ::std::move(from)) {}
5791   inline FunctionProto& operator=(const FunctionProto& from) {
5792     CopyFrom(from);
5793     return *this;
5794   }
5795   inline FunctionProto& operator=(FunctionProto&& from) noexcept {
5796     if (this == &from) return *this;
5797     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
5798       InternalSwap(&from);
5799     } else {
5800       CopyFrom(from);
5801     }
5802     return *this;
5803   }
5804 
5805   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
5806       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5807     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
5808   }
5809   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
5810       ABSL_ATTRIBUTE_LIFETIME_BOUND {
5811     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
5812   }
5813 
5814   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
5815     return GetDescriptor();
5816   }
5817   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
5818     return default_instance().GetMetadata().descriptor;
5819   }
5820   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
5821     return default_instance().GetMetadata().reflection;
5822   }
5823   static const FunctionProto& default_instance() {
5824     return *reinterpret_cast<const FunctionProto*>(
5825         &_FunctionProto_default_instance_);
5826   }
5827   static constexpr int kIndexInFileMessages = 21;
5828   friend void swap(FunctionProto& a, FunctionProto& b) { a.Swap(&b); }
5829   inline void Swap(FunctionProto* PROTOBUF_NONNULL other) {
5830     if (other == this) return;
5831     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
5832       InternalSwap(other);
5833     } else {
5834       ::google::protobuf::internal::GenericSwap(this, other);
5835     }
5836   }
5837   void UnsafeArenaSwap(FunctionProto* PROTOBUF_NONNULL other) {
5838     if (other == this) return;
5839     ABSL_DCHECK(GetArena() == other->GetArena());
5840     InternalSwap(other);
5841   }
5842 
5843   // implements Message ----------------------------------------------
5844 
5845   FunctionProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
5846     return ::google::protobuf::Message::DefaultConstruct<FunctionProto>(arena);
5847   }
5848   using ::google::protobuf::Message::CopyFrom;
5849   void CopyFrom(const FunctionProto& from);
5850   using ::google::protobuf::Message::MergeFrom;
5851   void MergeFrom(const FunctionProto& from) { FunctionProto::MergeImpl(*this, from); }
5852 
5853   private:
5854   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
5855                         const ::google::protobuf::MessageLite& from_msg);
5856 
5857   public:
5858   bool IsInitialized() const {
5859     return true;
5860   }
5861   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
5862   #if defined(PROTOBUF_CUSTOM_VTABLE)
5863   private:
5864   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
5865   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5866       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
5867       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
5868 
5869   public:
5870   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
5871   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5872       ::uint8_t* PROTOBUF_NONNULL target,
5873       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
5874     return _InternalSerialize(*this, target, stream);
5875   }
5876   #else   // PROTOBUF_CUSTOM_VTABLE
5877   ::size_t ByteSizeLong() const final;
5878   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
5879       ::uint8_t* PROTOBUF_NONNULL target,
5880       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
5881   #endif  // PROTOBUF_CUSTOM_VTABLE
5882   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
5883 
5884   private:
5885   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5886   static void SharedDtor(MessageLite& self);
5887   void InternalSwap(FunctionProto* PROTOBUF_NONNULL other);
5888  private:
5889   template <typename T>
5890   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
5891   static ::absl::string_view FullMessageName() { return "onnx.FunctionProto"; }
5892 
5893  protected:
5894   explicit FunctionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5895   FunctionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FunctionProto& from);
5896   FunctionProto(
5897       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FunctionProto&& from) noexcept
5898       : FunctionProto(arena) {
5899     *this = ::std::move(from);
5900   }
5901   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
5902   static void* PROTOBUF_NONNULL PlacementNew_(
5903       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
5904       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
5905   static constexpr auto InternalNewImpl_();
5906 
5907  public:
5908   static constexpr auto InternalGenerateClassData_();
5909 
5910   ::google::protobuf::Metadata GetMetadata() const;
5911   // nested types ----------------------------------------------------
5912 
5913   // accessors -------------------------------------------------------
5914   enum : int {
5915     kInputFieldNumber = 4,
5916     kOutputFieldNumber = 5,
5917     kAttributeFieldNumber = 6,
5918     kNodeFieldNumber = 7,
5919     kOpsetImportFieldNumber = 9,
5920     kAttributeProtoFieldNumber = 11,
5921     kValueInfoFieldNumber = 12,
5922     kMetadataPropsFieldNumber = 14,
5923     kNameFieldNumber = 1,
5924     kDocStringFieldNumber = 8,
5925     kDomainFieldNumber = 10,
5926     kOverloadFieldNumber = 13,
5927   };
5928   // repeated string input = 4;
5929   int input_size() const;
5930   private:
5931   int _internal_input_size() const;
5932 
5933   public:
5934   void clear_input() ;
5935   const ::std::string& input(int index) const;
5936   ::std::string* PROTOBUF_NONNULL mutable_input(int index);
5937   template <typename Arg_ = const ::std::string&, typename... Args_>
5938   void set_input(int index, Arg_&& value, Args_... args);
5939   ::std::string* PROTOBUF_NONNULL add_input();
5940   template <typename Arg_ = const ::std::string&, typename... Args_>
5941   void add_input(Arg_&& value, Args_... args);
5942   const ::google::protobuf::RepeatedPtrField<::std::string>& input() const;
5943   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_input();
5944 
5945   private:
5946   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_input() const;
5947   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_input();
5948 
5949   public:
5950   // repeated string output = 5;
5951   int output_size() const;
5952   private:
5953   int _internal_output_size() const;
5954 
5955   public:
5956   void clear_output() ;
5957   const ::std::string& output(int index) const;
5958   ::std::string* PROTOBUF_NONNULL mutable_output(int index);
5959   template <typename Arg_ = const ::std::string&, typename... Args_>
5960   void set_output(int index, Arg_&& value, Args_... args);
5961   ::std::string* PROTOBUF_NONNULL add_output();
5962   template <typename Arg_ = const ::std::string&, typename... Args_>
5963   void add_output(Arg_&& value, Args_... args);
5964   const ::google::protobuf::RepeatedPtrField<::std::string>& output() const;
5965   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_output();
5966 
5967   private:
5968   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_output() const;
5969   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_output();
5970 
5971   public:
5972   // repeated string attribute = 6;
5973   int attribute_size() const;
5974   private:
5975   int _internal_attribute_size() const;
5976 
5977   public:
5978   void clear_attribute() ;
5979   const ::std::string& attribute(int index) const;
5980   ::std::string* PROTOBUF_NONNULL mutable_attribute(int index);
5981   template <typename Arg_ = const ::std::string&, typename... Args_>
5982   void set_attribute(int index, Arg_&& value, Args_... args);
5983   ::std::string* PROTOBUF_NONNULL add_attribute();
5984   template <typename Arg_ = const ::std::string&, typename... Args_>
5985   void add_attribute(Arg_&& value, Args_... args);
5986   const ::google::protobuf::RepeatedPtrField<::std::string>& attribute() const;
5987   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_attribute();
5988 
5989   private:
5990   const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_attribute() const;
5991   ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_attribute();
5992 
5993   public:
5994   // repeated .onnx.NodeProto node = 7;
5995   int node_size() const;
5996   private:
5997   int _internal_node_size() const;
5998 
5999   public:
6000   void clear_node() ;
6001   ::onnx::NodeProto* PROTOBUF_NONNULL mutable_node(int index);
6002   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL mutable_node();
6003 
6004   private:
6005   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
6006   ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL _internal_mutable_node();
6007   public:
6008   const ::onnx::NodeProto& node(int index) const;
6009   ::onnx::NodeProto* PROTOBUF_NONNULL add_node();
6010   const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node() const;
6011   // repeated .onnx.OperatorSetIdProto opset_import = 9;
6012   int opset_import_size() const;
6013   private:
6014   int _internal_opset_import_size() const;
6015 
6016   public:
6017   void clear_opset_import() ;
6018   ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL mutable_opset_import(int index);
6019   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL mutable_opset_import();
6020 
6021   private:
6022   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
6023   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL _internal_mutable_opset_import();
6024   public:
6025   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
6026   ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL add_opset_import();
6027   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
6028   // repeated .onnx.AttributeProto attribute_proto = 11;
6029   int attribute_proto_size() const;
6030   private:
6031   int _internal_attribute_proto_size() const;
6032 
6033   public:
6034   void clear_attribute_proto() ;
6035   ::onnx::AttributeProto* PROTOBUF_NONNULL mutable_attribute_proto(int index);
6036   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL mutable_attribute_proto();
6037 
6038   private:
6039   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute_proto() const;
6040   ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL _internal_mutable_attribute_proto();
6041   public:
6042   const ::onnx::AttributeProto& attribute_proto(int index) const;
6043   ::onnx::AttributeProto* PROTOBUF_NONNULL add_attribute_proto();
6044   const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute_proto() const;
6045   // repeated .onnx.ValueInfoProto value_info = 12;
6046   int value_info_size() const;
6047   private:
6048   int _internal_value_info_size() const;
6049 
6050   public:
6051   void clear_value_info() ;
6052   ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_value_info(int index);
6053   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL mutable_value_info();
6054 
6055   private:
6056   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
6057   ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_value_info();
6058   public:
6059   const ::onnx::ValueInfoProto& value_info(int index) const;
6060   ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_value_info();
6061   const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info() const;
6062   // repeated .onnx.StringStringEntryProto metadata_props = 14;
6063   int metadata_props_size() const;
6064   private:
6065   int _internal_metadata_props_size() const;
6066 
6067   public:
6068   void clear_metadata_props() ;
6069   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
6070   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
6071 
6072   private:
6073   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
6074   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
6075   public:
6076   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
6077   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
6078   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
6079   // optional string name = 1;
6080   bool has_name() const;
6081   void clear_name() ;
6082   const ::std::string& name() const;
6083   template <typename Arg_ = const ::std::string&, typename... Args_>
6084   void set_name(Arg_&& arg, Args_... args);
6085   ::std::string* PROTOBUF_NONNULL mutable_name();
6086   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
6087   void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
6088 
6089   private:
6090   const ::std::string& _internal_name() const;
6091   PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
6092   ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
6093 
6094   public:
6095   // optional string doc_string = 8;
6096   bool has_doc_string() const;
6097   void clear_doc_string() ;
6098   const ::std::string& doc_string() const;
6099   template <typename Arg_ = const ::std::string&, typename... Args_>
6100   void set_doc_string(Arg_&& arg, Args_... args);
6101   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
6102   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
6103   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
6104 
6105   private:
6106   const ::std::string& _internal_doc_string() const;
6107   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
6108   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
6109 
6110   public:
6111   // optional string domain = 10;
6112   bool has_domain() const;
6113   void clear_domain() ;
6114   const ::std::string& domain() const;
6115   template <typename Arg_ = const ::std::string&, typename... Args_>
6116   void set_domain(Arg_&& arg, Args_... args);
6117   ::std::string* PROTOBUF_NONNULL mutable_domain();
6118   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
6119   void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);
6120 
6121   private:
6122   const ::std::string& _internal_domain() const;
6123   PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
6124   ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();
6125 
6126   public:
6127   // optional string overload = 13;
6128   bool has_overload() const;
6129   void clear_overload() ;
6130   const ::std::string& overload() const;
6131   template <typename Arg_ = const ::std::string&, typename... Args_>
6132   void set_overload(Arg_&& arg, Args_... args);
6133   ::std::string* PROTOBUF_NONNULL mutable_overload();
6134   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_overload();
6135   void set_allocated_overload(::std::string* PROTOBUF_NULLABLE value);
6136 
6137   private:
6138   const ::std::string& _internal_overload() const;
6139   PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const ::std::string& value);
6140   ::std::string* PROTOBUF_NONNULL _internal_mutable_overload();
6141 
6142   public:
6143   // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
6144  private:
6145   class _Internal;
6146   friend class ::google::protobuf::internal::TcParser;
6147   static const ::google::protobuf::internal::TcParseTable<4, 12,
6148                                    5, 83,
6149                                    2>
6150       _table_;
6151 
6152   friend class ::google::protobuf::MessageLite;
6153   friend class ::google::protobuf::Arena;
6154   template <typename T>
6155   friend class ::google::protobuf::Arena::InternalHelper;
6156   using InternalArenaConstructable_ = void;
6157   using DestructorSkippable_ = void;
6158   struct Impl_ {
6159     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
6160     inline explicit Impl_(
6161         ::google::protobuf::internal::InternalVisibility visibility,
6162         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
6163     inline explicit Impl_(
6164         ::google::protobuf::internal::InternalVisibility visibility,
6165         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
6166         const FunctionProto& from_msg);
6167     ::google::protobuf::internal::HasBits<1> _has_bits_;
6168     ::google::protobuf::internal::CachedSize _cached_size_;
6169     ::google::protobuf::RepeatedPtrField<::std::string> input_;
6170     ::google::protobuf::RepeatedPtrField<::std::string> output_;
6171     ::google::protobuf::RepeatedPtrField<::std::string> attribute_;
6172     ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
6173     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
6174     ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
6175     ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
6176     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
6177     ::google::protobuf::internal::ArenaStringPtr name_;
6178     ::google::protobuf::internal::ArenaStringPtr doc_string_;
6179     ::google::protobuf::internal::ArenaStringPtr domain_;
6180     ::google::protobuf::internal::ArenaStringPtr overload_;
6181     PROTOBUF_TSAN_DECLARE_MEMBER
6182   };
6183   union { Impl_ _impl_; };
6184   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
6185 };
6186 
6187 ONNX_API extern const ::google::protobuf::internal::ClassDataFull FunctionProto_class_data_;
6188 // -------------------------------------------------------------------
6189 
6190 class ONNX_API ModelProto final : public ::google::protobuf::Message
6191 /* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
6192  public:
6193   inline ModelProto() : ModelProto(nullptr) {}
6194   ~ModelProto() PROTOBUF_FINAL;
6195 
6196 #if defined(PROTOBUF_CUSTOM_VTABLE)
6197   void operator delete(ModelProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
6198     SharedDtor(*msg);
6199     ::google::protobuf::internal::SizedDelete(msg, sizeof(ModelProto));
6200   }
6201 #endif
6202 
6203   template <typename = void>
6204   explicit PROTOBUF_CONSTEXPR ModelProto(::google::protobuf::internal::ConstantInitialized);
6205 
6206   inline ModelProto(const ModelProto& from) : ModelProto(nullptr, from) {}
6207   inline ModelProto(ModelProto&& from) noexcept
6208       : ModelProto(nullptr, ::std::move(from)) {}
6209   inline ModelProto& operator=(const ModelProto& from) {
6210     CopyFrom(from);
6211     return *this;
6212   }
6213   inline ModelProto& operator=(ModelProto&& from) noexcept {
6214     if (this == &from) return *this;
6215     if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
6216       InternalSwap(&from);
6217     } else {
6218       CopyFrom(from);
6219     }
6220     return *this;
6221   }
6222 
6223   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
6224       ABSL_ATTRIBUTE_LIFETIME_BOUND {
6225     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
6226   }
6227   inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
6228       ABSL_ATTRIBUTE_LIFETIME_BOUND {
6229     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
6230   }
6231 
6232   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
6233     return GetDescriptor();
6234   }
6235   static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
6236     return default_instance().GetMetadata().descriptor;
6237   }
6238   static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
6239     return default_instance().GetMetadata().reflection;
6240   }
6241   static const ModelProto& default_instance() {
6242     return *reinterpret_cast<const ModelProto*>(
6243         &_ModelProto_default_instance_);
6244   }
6245   static constexpr int kIndexInFileMessages = 4;
6246   friend void swap(ModelProto& a, ModelProto& b) { a.Swap(&b); }
6247   inline void Swap(ModelProto* PROTOBUF_NONNULL other) {
6248     if (other == this) return;
6249     if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
6250       InternalSwap(other);
6251     } else {
6252       ::google::protobuf::internal::GenericSwap(this, other);
6253     }
6254   }
6255   void UnsafeArenaSwap(ModelProto* PROTOBUF_NONNULL other) {
6256     if (other == this) return;
6257     ABSL_DCHECK(GetArena() == other->GetArena());
6258     InternalSwap(other);
6259   }
6260 
6261   // implements Message ----------------------------------------------
6262 
6263   ModelProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
6264     return ::google::protobuf::Message::DefaultConstruct<ModelProto>(arena);
6265   }
6266   using ::google::protobuf::Message::CopyFrom;
6267   void CopyFrom(const ModelProto& from);
6268   using ::google::protobuf::Message::MergeFrom;
6269   void MergeFrom(const ModelProto& from) { ModelProto::MergeImpl(*this, from); }
6270 
6271   private:
6272   static void MergeImpl(::google::protobuf::MessageLite& to_msg,
6273                         const ::google::protobuf::MessageLite& from_msg);
6274 
6275   public:
6276   bool IsInitialized() const {
6277     return true;
6278   }
6279   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
6280   #if defined(PROTOBUF_CUSTOM_VTABLE)
6281   private:
6282   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
6283   static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
6284       const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
6285       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
6286 
6287   public:
6288   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
6289   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
6290       ::uint8_t* PROTOBUF_NONNULL target,
6291       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
6292     return _InternalSerialize(*this, target, stream);
6293   }
6294   #else   // PROTOBUF_CUSTOM_VTABLE
6295   ::size_t ByteSizeLong() const final;
6296   ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
6297       ::uint8_t* PROTOBUF_NONNULL target,
6298       ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
6299   #endif  // PROTOBUF_CUSTOM_VTABLE
6300   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
6301 
6302   private:
6303   void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
6304   static void SharedDtor(MessageLite& self);
6305   void InternalSwap(ModelProto* PROTOBUF_NONNULL other);
6306  private:
6307   template <typename T>
6308   friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
6309   static ::absl::string_view FullMessageName() { return "onnx.ModelProto"; }
6310 
6311  protected:
6312   explicit ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
6313   ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ModelProto& from);
6314   ModelProto(
6315       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ModelProto&& from) noexcept
6316       : ModelProto(arena) {
6317     *this = ::std::move(from);
6318   }
6319   const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
6320   static void* PROTOBUF_NONNULL PlacementNew_(
6321       const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
6322       ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
6323   static constexpr auto InternalNewImpl_();
6324 
6325  public:
6326   static constexpr auto InternalGenerateClassData_();
6327 
6328   ::google::protobuf::Metadata GetMetadata() const;
6329   // nested types ----------------------------------------------------
6330 
6331   // accessors -------------------------------------------------------
6332   enum : int {
6333     kOpsetImportFieldNumber = 8,
6334     kMetadataPropsFieldNumber = 14,
6335     kTrainingInfoFieldNumber = 20,
6336     kFunctionsFieldNumber = 25,
6337     kProducerNameFieldNumber = 2,
6338     kProducerVersionFieldNumber = 3,
6339     kDomainFieldNumber = 4,
6340     kDocStringFieldNumber = 6,
6341     kGraphFieldNumber = 7,
6342     kIrVersionFieldNumber = 1,
6343     kModelVersionFieldNumber = 5,
6344   };
6345   // repeated .onnx.OperatorSetIdProto opset_import = 8;
6346   int opset_import_size() const;
6347   private:
6348   int _internal_opset_import_size() const;
6349 
6350   public:
6351   void clear_opset_import() ;
6352   ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL mutable_opset_import(int index);
6353   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL mutable_opset_import();
6354 
6355   private:
6356   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
6357   ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL _internal_mutable_opset_import();
6358   public:
6359   const ::onnx::OperatorSetIdProto& opset_import(int index) const;
6360   ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL add_opset_import();
6361   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import() const;
6362   // repeated .onnx.StringStringEntryProto metadata_props = 14;
6363   int metadata_props_size() const;
6364   private:
6365   int _internal_metadata_props_size() const;
6366 
6367   public:
6368   void clear_metadata_props() ;
6369   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
6370   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL mutable_metadata_props();
6371 
6372   private:
6373   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
6374   ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
6375   public:
6376   const ::onnx::StringStringEntryProto& metadata_props(int index) const;
6377   ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
6378   const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props() const;
6379   // repeated .onnx.TrainingInfoProto training_info = 20;
6380   int training_info_size() const;
6381   private:
6382   int _internal_training_info_size() const;
6383 
6384   public:
6385   void clear_training_info() ;
6386   ::onnx::TrainingInfoProto* PROTOBUF_NONNULL mutable_training_info(int index);
6387   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL mutable_training_info();
6388 
6389   private:
6390   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& _internal_training_info() const;
6391   ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL _internal_mutable_training_info();
6392   public:
6393   const ::onnx::TrainingInfoProto& training_info(int index) const;
6394   ::onnx::TrainingInfoProto* PROTOBUF_NONNULL add_training_info();
6395   const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& training_info() const;
6396   // repeated .onnx.FunctionProto functions = 25;
6397   int functions_size() const;
6398   private:
6399   int _internal_functions_size() const;
6400 
6401   public:
6402   void clear_functions() ;
6403   ::onnx::FunctionProto* PROTOBUF_NONNULL mutable_functions(int index);
6404   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL mutable_functions();
6405 
6406   private:
6407   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& _internal_functions() const;
6408   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL _internal_mutable_functions();
6409   public:
6410   const ::onnx::FunctionProto& functions(int index) const;
6411   ::onnx::FunctionProto* PROTOBUF_NONNULL add_functions();
6412   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& functions() const;
6413   // optional string producer_name = 2;
6414   bool has_producer_name() const;
6415   void clear_producer_name() ;
6416   const ::std::string& producer_name() const;
6417   template <typename Arg_ = const ::std::string&, typename... Args_>
6418   void set_producer_name(Arg_&& arg, Args_... args);
6419   ::std::string* PROTOBUF_NONNULL mutable_producer_name();
6420   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_producer_name();
6421   void set_allocated_producer_name(::std::string* PROTOBUF_NULLABLE value);
6422 
6423   private:
6424   const ::std::string& _internal_producer_name() const;
6425   PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(const ::std::string& value);
6426   ::std::string* PROTOBUF_NONNULL _internal_mutable_producer_name();
6427 
6428   public:
6429   // optional string producer_version = 3;
6430   bool has_producer_version() const;
6431   void clear_producer_version() ;
6432   const ::std::string& producer_version() const;
6433   template <typename Arg_ = const ::std::string&, typename... Args_>
6434   void set_producer_version(Arg_&& arg, Args_... args);
6435   ::std::string* PROTOBUF_NONNULL mutable_producer_version();
6436   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_producer_version();
6437   void set_allocated_producer_version(::std::string* PROTOBUF_NULLABLE value);
6438 
6439   private:
6440   const ::std::string& _internal_producer_version() const;
6441   PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(const ::std::string& value);
6442   ::std::string* PROTOBUF_NONNULL _internal_mutable_producer_version();
6443 
6444   public:
6445   // optional string domain = 4;
6446   bool has_domain() const;
6447   void clear_domain() ;
6448   const ::std::string& domain() const;
6449   template <typename Arg_ = const ::std::string&, typename... Args_>
6450   void set_domain(Arg_&& arg, Args_... args);
6451   ::std::string* PROTOBUF_NONNULL mutable_domain();
6452   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
6453   void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);
6454 
6455   private:
6456   const ::std::string& _internal_domain() const;
6457   PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
6458   ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();
6459 
6460   public:
6461   // optional string doc_string = 6;
6462   bool has_doc_string() const;
6463   void clear_doc_string() ;
6464   const ::std::string& doc_string() const;
6465   template <typename Arg_ = const ::std::string&, typename... Args_>
6466   void set_doc_string(Arg_&& arg, Args_... args);
6467   ::std::string* PROTOBUF_NONNULL mutable_doc_string();
6468   [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
6469   void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);
6470 
6471   private:
6472   const ::std::string& _internal_doc_string() const;
6473   PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
6474   ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();
6475 
6476   public:
6477   // optional .onnx.GraphProto graph = 7;
6478   bool has_graph() const;
6479   void clear_graph() ;
6480   const ::onnx::GraphProto& graph() const;
6481   [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_graph();
6482   ::onnx::GraphProto* PROTOBUF_NONNULL mutable_graph();
6483   void set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value);
6484   void unsafe_arena_set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value);
6485   ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_graph();
6486 
6487   private:
6488   const ::onnx::GraphProto& _internal_graph() const;
6489   ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_graph();
6490 
6491   public:
6492   // optional int64 ir_version = 1;
6493   bool has_ir_version() const;
6494   void clear_ir_version() ;
6495   ::int64_t ir_version() const;
6496   void set_ir_version(::int64_t value);
6497 
6498   private:
6499   ::int64_t _internal_ir_version() const;
6500   void _internal_set_ir_version(::int64_t value);
6501 
6502   public:
6503   // optional int64 model_version = 5;
6504   bool has_model_version() const;
6505   void clear_model_version() ;
6506   ::int64_t model_version() const;
6507   void set_model_version(::int64_t value);
6508 
6509   private:
6510   ::int64_t _internal_model_version() const;
6511   void _internal_set_model_version(::int64_t value);
6512 
6513   public:
6514   // @@protoc_insertion_point(class_scope:onnx.ModelProto)
6515  private:
6516   class _Internal;
6517   friend class ::google::protobuf::internal::TcParser;
6518   static const ::google::protobuf::internal::TcParseTable<4, 11,
6519                                    5, 77,
6520                                    2>
6521       _table_;
6522 
6523   friend class ::google::protobuf::MessageLite;
6524   friend class ::google::protobuf::Arena;
6525   template <typename T>
6526   friend class ::google::protobuf::Arena::InternalHelper;
6527   using InternalArenaConstructable_ = void;
6528   using DestructorSkippable_ = void;
6529   struct Impl_ {
6530     inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
6531     inline explicit Impl_(
6532         ::google::protobuf::internal::InternalVisibility visibility,
6533         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
6534     inline explicit Impl_(
6535         ::google::protobuf::internal::InternalVisibility visibility,
6536         ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
6537         const ModelProto& from_msg);
6538     ::google::protobuf::internal::HasBits<1> _has_bits_;
6539     ::google::protobuf::internal::CachedSize _cached_size_;
6540     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
6541     ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
6542     ::google::protobuf::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
6543     ::google::protobuf::RepeatedPtrField< ::onnx::FunctionProto > functions_;
6544     ::google::protobuf::internal::ArenaStringPtr producer_name_;
6545     ::google::protobuf::internal::ArenaStringPtr producer_version_;
6546     ::google::protobuf::internal::ArenaStringPtr domain_;
6547     ::google::protobuf::internal::ArenaStringPtr doc_string_;
6548     ::onnx::GraphProto* PROTOBUF_NULLABLE graph_;
6549     ::int64_t ir_version_;
6550     ::int64_t model_version_;
6551     PROTOBUF_TSAN_DECLARE_MEMBER
6552   };
6553   union { Impl_ _impl_; };
6554   friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
6555 };
6556 
6557 ONNX_API extern const ::google::protobuf::internal::ClassDataFull ModelProto_class_data_;
6558 
6559 // ===================================================================
6560 
6561 
6562 
6563 
6564 // ===================================================================
6565 
6566 
6567 #ifdef __GNUC__
6568 #pragma GCC diagnostic push
6569 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
6570 #endif  // __GNUC__
6571 // -------------------------------------------------------------------
6572 
6573 // AttributeProto
6574 
6575 // optional string name = 1;
6576 inline bool AttributeProto::has_name() const {
6577   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
6578   return value;
6579 }
6580 inline void AttributeProto::clear_name() {
6581   ::google::protobuf::internal::TSanWrite(&_impl_);
6582   _impl_.name_.ClearToEmpty();
6583   _impl_._has_bits_[0] &= ~0x00000001U;
6584 }
6585 inline const ::std::string& AttributeProto::name() const
6586     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6587   // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
6588   return _internal_name();
6589 }
6590 template <typename Arg_, typename... Args_>
6591 PROTOBUF_ALWAYS_INLINE void AttributeProto::set_name(Arg_&& arg, Args_... args) {
6592   ::google::protobuf::internal::TSanWrite(&_impl_);
6593   _impl_._has_bits_[0] |= 0x00000001U;
6594   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6595   // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
6596 }
6597 inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_name()
6598     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6599   ::std::string* _s = _internal_mutable_name();
6600   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
6601   return _s;
6602 }
6603 inline const ::std::string& AttributeProto::_internal_name() const {
6604   ::google::protobuf::internal::TSanRead(&_impl_);
6605   return _impl_.name_.Get();
6606 }
6607 inline void AttributeProto::_internal_set_name(const ::std::string& value) {
6608   ::google::protobuf::internal::TSanWrite(&_impl_);
6609   _impl_._has_bits_[0] |= 0x00000001U;
6610   _impl_.name_.Set(value, GetArena());
6611 }
6612 inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_name() {
6613   ::google::protobuf::internal::TSanWrite(&_impl_);
6614   _impl_._has_bits_[0] |= 0x00000001U;
6615   return _impl_.name_.Mutable( GetArena());
6616 }
6617 inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_name() {
6618   ::google::protobuf::internal::TSanWrite(&_impl_);
6619   // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
6620   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
6621     return nullptr;
6622   }
6623   _impl_._has_bits_[0] &= ~0x00000001U;
6624   auto* released = _impl_.name_.Release();
6625   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
6626     _impl_.name_.Set("", GetArena());
6627   }
6628   return released;
6629 }
6630 inline void AttributeProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
6631   ::google::protobuf::internal::TSanWrite(&_impl_);
6632   if (value != nullptr) {
6633     _impl_._has_bits_[0] |= 0x00000001U;
6634   } else {
6635     _impl_._has_bits_[0] &= ~0x00000001U;
6636   }
6637   _impl_.name_.SetAllocated(value, GetArena());
6638   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
6639     _impl_.name_.Set("", GetArena());
6640   }
6641   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
6642 }
6643 
6644 // optional string ref_attr_name = 21;
6645 inline bool AttributeProto::has_ref_attr_name() const {
6646   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
6647   return value;
6648 }
6649 inline void AttributeProto::clear_ref_attr_name() {
6650   ::google::protobuf::internal::TSanWrite(&_impl_);
6651   _impl_.ref_attr_name_.ClearToEmpty();
6652   _impl_._has_bits_[0] &= ~0x00000008U;
6653 }
6654 inline const ::std::string& AttributeProto::ref_attr_name() const
6655     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6656   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
6657   return _internal_ref_attr_name();
6658 }
6659 template <typename Arg_, typename... Args_>
6660 PROTOBUF_ALWAYS_INLINE void AttributeProto::set_ref_attr_name(Arg_&& arg, Args_... args) {
6661   ::google::protobuf::internal::TSanWrite(&_impl_);
6662   _impl_._has_bits_[0] |= 0x00000008U;
6663   _impl_.ref_attr_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6664   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
6665 }
6666 inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_ref_attr_name()
6667     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6668   ::std::string* _s = _internal_mutable_ref_attr_name();
6669   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
6670   return _s;
6671 }
6672 inline const ::std::string& AttributeProto::_internal_ref_attr_name() const {
6673   ::google::protobuf::internal::TSanRead(&_impl_);
6674   return _impl_.ref_attr_name_.Get();
6675 }
6676 inline void AttributeProto::_internal_set_ref_attr_name(const ::std::string& value) {
6677   ::google::protobuf::internal::TSanWrite(&_impl_);
6678   _impl_._has_bits_[0] |= 0x00000008U;
6679   _impl_.ref_attr_name_.Set(value, GetArena());
6680 }
6681 inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_ref_attr_name() {
6682   ::google::protobuf::internal::TSanWrite(&_impl_);
6683   _impl_._has_bits_[0] |= 0x00000008U;
6684   return _impl_.ref_attr_name_.Mutable( GetArena());
6685 }
6686 inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_ref_attr_name() {
6687   ::google::protobuf::internal::TSanWrite(&_impl_);
6688   // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
6689   if ((_impl_._has_bits_[0] & 0x00000008U) == 0) {
6690     return nullptr;
6691   }
6692   _impl_._has_bits_[0] &= ~0x00000008U;
6693   auto* released = _impl_.ref_attr_name_.Release();
6694   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
6695     _impl_.ref_attr_name_.Set("", GetArena());
6696   }
6697   return released;
6698 }
6699 inline void AttributeProto::set_allocated_ref_attr_name(::std::string* PROTOBUF_NULLABLE value) {
6700   ::google::protobuf::internal::TSanWrite(&_impl_);
6701   if (value != nullptr) {
6702     _impl_._has_bits_[0] |= 0x00000008U;
6703   } else {
6704     _impl_._has_bits_[0] &= ~0x00000008U;
6705   }
6706   _impl_.ref_attr_name_.SetAllocated(value, GetArena());
6707   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.ref_attr_name_.IsDefault()) {
6708     _impl_.ref_attr_name_.Set("", GetArena());
6709   }
6710   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
6711 }
6712 
6713 // optional string doc_string = 13;
6714 inline bool AttributeProto::has_doc_string() const {
6715   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
6716   return value;
6717 }
6718 inline void AttributeProto::clear_doc_string() {
6719   ::google::protobuf::internal::TSanWrite(&_impl_);
6720   _impl_.doc_string_.ClearToEmpty();
6721   _impl_._has_bits_[0] &= ~0x00000004U;
6722 }
6723 inline const ::std::string& AttributeProto::doc_string() const
6724     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6725   // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
6726   return _internal_doc_string();
6727 }
6728 template <typename Arg_, typename... Args_>
6729 PROTOBUF_ALWAYS_INLINE void AttributeProto::set_doc_string(Arg_&& arg, Args_... args) {
6730   ::google::protobuf::internal::TSanWrite(&_impl_);
6731   _impl_._has_bits_[0] |= 0x00000004U;
6732   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
6733   // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
6734 }
6735 inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_doc_string()
6736     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6737   ::std::string* _s = _internal_mutable_doc_string();
6738   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
6739   return _s;
6740 }
6741 inline const ::std::string& AttributeProto::_internal_doc_string() const {
6742   ::google::protobuf::internal::TSanRead(&_impl_);
6743   return _impl_.doc_string_.Get();
6744 }
6745 inline void AttributeProto::_internal_set_doc_string(const ::std::string& value) {
6746   ::google::protobuf::internal::TSanWrite(&_impl_);
6747   _impl_._has_bits_[0] |= 0x00000004U;
6748   _impl_.doc_string_.Set(value, GetArena());
6749 }
6750 inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_doc_string() {
6751   ::google::protobuf::internal::TSanWrite(&_impl_);
6752   _impl_._has_bits_[0] |= 0x00000004U;
6753   return _impl_.doc_string_.Mutable( GetArena());
6754 }
6755 inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_doc_string() {
6756   ::google::protobuf::internal::TSanWrite(&_impl_);
6757   // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
6758   if ((_impl_._has_bits_[0] & 0x00000004U) == 0) {
6759     return nullptr;
6760   }
6761   _impl_._has_bits_[0] &= ~0x00000004U;
6762   auto* released = _impl_.doc_string_.Release();
6763   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
6764     _impl_.doc_string_.Set("", GetArena());
6765   }
6766   return released;
6767 }
6768 inline void AttributeProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
6769   ::google::protobuf::internal::TSanWrite(&_impl_);
6770   if (value != nullptr) {
6771     _impl_._has_bits_[0] |= 0x00000004U;
6772   } else {
6773     _impl_._has_bits_[0] &= ~0x00000004U;
6774   }
6775   _impl_.doc_string_.SetAllocated(value, GetArena());
6776   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
6777     _impl_.doc_string_.Set("", GetArena());
6778   }
6779   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
6780 }
6781 
6782 // optional .onnx.AttributeProto.AttributeType type = 20;
6783 inline bool AttributeProto::has_type() const {
6784   bool value = (_impl_._has_bits_[0] & 0x00000400U) != 0;
6785   return value;
6786 }
6787 inline void AttributeProto::clear_type() {
6788   ::google::protobuf::internal::TSanWrite(&_impl_);
6789   _impl_.type_ = 0;
6790   _impl_._has_bits_[0] &= ~0x00000400U;
6791 }
6792 inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
6793   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
6794   return _internal_type();
6795 }
6796 inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
6797   _internal_set_type(value);
6798   _impl_._has_bits_[0] |= 0x00000400U;
6799   // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
6800 }
6801 inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
6802   ::google::protobuf::internal::TSanRead(&_impl_);
6803   return static_cast<::onnx::AttributeProto_AttributeType>(_impl_.type_);
6804 }
6805 inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
6806   ::google::protobuf::internal::TSanWrite(&_impl_);
6807 
6808                                           assert(::google::protobuf::internal::ValidateEnum(
6809                                               value, ::onnx::AttributeProto_AttributeType_internal_data_));
6810                                           _impl_.type_ = value;
6811 }
6812 
6813 // optional float f = 2;
6814 inline bool AttributeProto::has_f() const {
6815   bool value = (_impl_._has_bits_[0] & 0x00000200U) != 0;
6816   return value;
6817 }
6818 inline void AttributeProto::clear_f() {
6819   ::google::protobuf::internal::TSanWrite(&_impl_);
6820   _impl_.f_ = 0;
6821   _impl_._has_bits_[0] &= ~0x00000200U;
6822 }
6823 inline float AttributeProto::f() const {
6824   // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
6825   return _internal_f();
6826 }
6827 inline void AttributeProto::set_f(float value) {
6828   _internal_set_f(value);
6829   _impl_._has_bits_[0] |= 0x00000200U;
6830   // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
6831 }
6832 inline float AttributeProto::_internal_f() const {
6833   ::google::protobuf::internal::TSanRead(&_impl_);
6834   return _impl_.f_;
6835 }
6836 inline void AttributeProto::_internal_set_f(float value) {
6837   ::google::protobuf::internal::TSanWrite(&_impl_);
6838   _impl_.f_ = value;
6839 }
6840 
6841 // optional int64 i = 3;
6842 inline bool AttributeProto::has_i() const {
6843   bool value = (_impl_._has_bits_[0] & 0x00000100U) != 0;
6844   return value;
6845 }
6846 inline void AttributeProto::clear_i() {
6847   ::google::protobuf::internal::TSanWrite(&_impl_);
6848   _impl_.i_ = ::int64_t{0};
6849   _impl_._has_bits_[0] &= ~0x00000100U;
6850 }
6851 inline ::int64_t AttributeProto::i() const {
6852   // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
6853   return _internal_i();
6854 }
6855 inline void AttributeProto::set_i(::int64_t value) {
6856   _internal_set_i(value);
6857   _impl_._has_bits_[0] |= 0x00000100U;
6858   // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
6859 }
6860 inline ::int64_t AttributeProto::_internal_i() const {
6861   ::google::protobuf::internal::TSanRead(&_impl_);
6862   return _impl_.i_;
6863 }
6864 inline void AttributeProto::_internal_set_i(::int64_t value) {
6865   ::google::protobuf::internal::TSanWrite(&_impl_);
6866   _impl_.i_ = value;
6867 }
6868 
6869 // optional bytes s = 4;
6870 inline bool AttributeProto::has_s() const {
6871   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
6872   return value;
6873 }
6874 inline void AttributeProto::clear_s() {
6875   ::google::protobuf::internal::TSanWrite(&_impl_);
6876   _impl_.s_.ClearToEmpty();
6877   _impl_._has_bits_[0] &= ~0x00000002U;
6878 }
6879 inline const ::std::string& AttributeProto::s() const
6880     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6881   // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
6882   return _internal_s();
6883 }
6884 template <typename Arg_, typename... Args_>
6885 PROTOBUF_ALWAYS_INLINE void AttributeProto::set_s(Arg_&& arg, Args_... args) {
6886   ::google::protobuf::internal::TSanWrite(&_impl_);
6887   _impl_._has_bits_[0] |= 0x00000002U;
6888   _impl_.s_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
6889   // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
6890 }
6891 inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_s()
6892     ABSL_ATTRIBUTE_LIFETIME_BOUND {
6893   ::std::string* _s = _internal_mutable_s();
6894   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
6895   return _s;
6896 }
6897 inline const ::std::string& AttributeProto::_internal_s() const {
6898   ::google::protobuf::internal::TSanRead(&_impl_);
6899   return _impl_.s_.Get();
6900 }
6901 inline void AttributeProto::_internal_set_s(const ::std::string& value) {
6902   ::google::protobuf::internal::TSanWrite(&_impl_);
6903   _impl_._has_bits_[0] |= 0x00000002U;
6904   _impl_.s_.Set(value, GetArena());
6905 }
6906 inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_s() {
6907   ::google::protobuf::internal::TSanWrite(&_impl_);
6908   _impl_._has_bits_[0] |= 0x00000002U;
6909   return _impl_.s_.Mutable( GetArena());
6910 }
6911 inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_s() {
6912   ::google::protobuf::internal::TSanWrite(&_impl_);
6913   // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
6914   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
6915     return nullptr;
6916   }
6917   _impl_._has_bits_[0] &= ~0x00000002U;
6918   auto* released = _impl_.s_.Release();
6919   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
6920     _impl_.s_.Set("", GetArena());
6921   }
6922   return released;
6923 }
6924 inline void AttributeProto::set_allocated_s(::std::string* PROTOBUF_NULLABLE value) {
6925   ::google::protobuf::internal::TSanWrite(&_impl_);
6926   if (value != nullptr) {
6927     _impl_._has_bits_[0] |= 0x00000002U;
6928   } else {
6929     _impl_._has_bits_[0] &= ~0x00000002U;
6930   }
6931   _impl_.s_.SetAllocated(value, GetArena());
6932   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s_.IsDefault()) {
6933     _impl_.s_.Set("", GetArena());
6934   }
6935   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
6936 }
6937 
6938 // optional .onnx.TensorProto t = 5;
6939 inline bool AttributeProto::has_t() const {
6940   bool value = (_impl_._has_bits_[0] & 0x00000010U) != 0;
6941   PROTOBUF_ASSUME(!value || _impl_.t_ != nullptr);
6942   return value;
6943 }
6944 inline void AttributeProto::clear_t() {
6945   ::google::protobuf::internal::TSanWrite(&_impl_);
6946   if (_impl_.t_ != nullptr) _impl_.t_->Clear();
6947   _impl_._has_bits_[0] &= ~0x00000010U;
6948 }
6949 inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
6950   ::google::protobuf::internal::TSanRead(&_impl_);
6951   const ::onnx::TensorProto* p = _impl_.t_;
6952   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
6953 }
6954 inline const ::onnx::TensorProto& AttributeProto::t() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
6955   // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
6956   return _internal_t();
6957 }
6958 inline void AttributeProto::unsafe_arena_set_allocated_t(
6959     ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
6960   ::google::protobuf::internal::TSanWrite(&_impl_);
6961   if (GetArena() == nullptr) {
6962     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
6963   }
6964   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
6965   if (value != nullptr) {
6966     _impl_._has_bits_[0] |= 0x00000010U;
6967   } else {
6968     _impl_._has_bits_[0] &= ~0x00000010U;
6969   }
6970   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
6971 }
6972 inline ::onnx::TensorProto* PROTOBUF_NULLABLE AttributeProto::release_t() {
6973   ::google::protobuf::internal::TSanWrite(&_impl_);
6974 
6975   _impl_._has_bits_[0] &= ~0x00000010U;
6976   ::onnx::TensorProto* released = _impl_.t_;
6977   _impl_.t_ = nullptr;
6978   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
6979     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
6980     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6981     if (GetArena() == nullptr) {
6982       delete old;
6983     }
6984   } else {
6985     if (GetArena() != nullptr) {
6986       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
6987     }
6988   }
6989   return released;
6990 }
6991 inline ::onnx::TensorProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_t() {
6992   ::google::protobuf::internal::TSanWrite(&_impl_);
6993   // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)
6994 
6995   _impl_._has_bits_[0] &= ~0x00000010U;
6996   ::onnx::TensorProto* temp = _impl_.t_;
6997   _impl_.t_ = nullptr;
6998   return temp;
6999 }
7000 inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_t() {
7001   ::google::protobuf::internal::TSanWrite(&_impl_);
7002   if (_impl_.t_ == nullptr) {
7003     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
7004     _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(p);
7005   }
7006   return _impl_.t_;
7007 }
7008 inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::mutable_t()
7009     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7010   _impl_._has_bits_[0] |= 0x00000010U;
7011   ::onnx::TensorProto* _msg = _internal_mutable_t();
7012   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
7013   return _msg;
7014 }
7015 inline void AttributeProto::set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
7016   ::google::protobuf::Arena* message_arena = GetArena();
7017   ::google::protobuf::internal::TSanWrite(&_impl_);
7018   if (message_arena == nullptr) {
7019     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
7020   }
7021 
7022   if (value != nullptr) {
7023     ::google::protobuf::Arena* submessage_arena = value->GetArena();
7024     if (message_arena != submessage_arena) {
7025       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7026     }
7027     _impl_._has_bits_[0] |= 0x00000010U;
7028   } else {
7029     _impl_._has_bits_[0] &= ~0x00000010U;
7030   }
7031 
7032   _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
7033   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
7034 }
7035 
7036 // optional .onnx.GraphProto g = 6;
7037 inline bool AttributeProto::has_g() const {
7038   bool value = (_impl_._has_bits_[0] & 0x00000020U) != 0;
7039   PROTOBUF_ASSUME(!value || _impl_.g_ != nullptr);
7040   return value;
7041 }
7042 inline void AttributeProto::clear_g() {
7043   ::google::protobuf::internal::TSanWrite(&_impl_);
7044   if (_impl_.g_ != nullptr) _impl_.g_->Clear();
7045   _impl_._has_bits_[0] &= ~0x00000020U;
7046 }
7047 inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
7048   ::google::protobuf::internal::TSanRead(&_impl_);
7049   const ::onnx::GraphProto* p = _impl_.g_;
7050   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
7051 }
7052 inline const ::onnx::GraphProto& AttributeProto::g() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7053   // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
7054   return _internal_g();
7055 }
7056 inline void AttributeProto::unsafe_arena_set_allocated_g(
7057     ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
7058   ::google::protobuf::internal::TSanWrite(&_impl_);
7059   if (GetArena() == nullptr) {
7060     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
7061   }
7062   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
7063   if (value != nullptr) {
7064     _impl_._has_bits_[0] |= 0x00000020U;
7065   } else {
7066     _impl_._has_bits_[0] &= ~0x00000020U;
7067   }
7068   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
7069 }
7070 inline ::onnx::GraphProto* PROTOBUF_NULLABLE AttributeProto::release_g() {
7071   ::google::protobuf::internal::TSanWrite(&_impl_);
7072 
7073   _impl_._has_bits_[0] &= ~0x00000020U;
7074   ::onnx::GraphProto* released = _impl_.g_;
7075   _impl_.g_ = nullptr;
7076   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
7077     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7078     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7079     if (GetArena() == nullptr) {
7080       delete old;
7081     }
7082   } else {
7083     if (GetArena() != nullptr) {
7084       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7085     }
7086   }
7087   return released;
7088 }
7089 inline ::onnx::GraphProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_g() {
7090   ::google::protobuf::internal::TSanWrite(&_impl_);
7091   // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)
7092 
7093   _impl_._has_bits_[0] &= ~0x00000020U;
7094   ::onnx::GraphProto* temp = _impl_.g_;
7095   _impl_.g_ = nullptr;
7096   return temp;
7097 }
7098 inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_g() {
7099   ::google::protobuf::internal::TSanWrite(&_impl_);
7100   if (_impl_.g_ == nullptr) {
7101     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
7102     _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(p);
7103   }
7104   return _impl_.g_;
7105 }
7106 inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::mutable_g()
7107     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7108   _impl_._has_bits_[0] |= 0x00000020U;
7109   ::onnx::GraphProto* _msg = _internal_mutable_g();
7110   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
7111   return _msg;
7112 }
7113 inline void AttributeProto::set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
7114   ::google::protobuf::Arena* message_arena = GetArena();
7115   ::google::protobuf::internal::TSanWrite(&_impl_);
7116   if (message_arena == nullptr) {
7117     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
7118   }
7119 
7120   if (value != nullptr) {
7121     ::google::protobuf::Arena* submessage_arena = value->GetArena();
7122     if (message_arena != submessage_arena) {
7123       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7124     }
7125     _impl_._has_bits_[0] |= 0x00000020U;
7126   } else {
7127     _impl_._has_bits_[0] &= ~0x00000020U;
7128   }
7129 
7130   _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
7131   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
7132 }
7133 
7134 // optional .onnx.SparseTensorProto sparse_tensor = 22;
7135 inline bool AttributeProto::has_sparse_tensor() const {
7136   bool value = (_impl_._has_bits_[0] & 0x00000080U) != 0;
7137   PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_ != nullptr);
7138   return value;
7139 }
7140 inline void AttributeProto::clear_sparse_tensor() {
7141   ::google::protobuf::internal::TSanWrite(&_impl_);
7142   if (_impl_.sparse_tensor_ != nullptr) _impl_.sparse_tensor_->Clear();
7143   _impl_._has_bits_[0] &= ~0x00000080U;
7144 }
7145 inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
7146   ::google::protobuf::internal::TSanRead(&_impl_);
7147   const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_;
7148   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
7149 }
7150 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7151   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
7152   return _internal_sparse_tensor();
7153 }
7154 inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(
7155     ::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
7156   ::google::protobuf::internal::TSanWrite(&_impl_);
7157   if (GetArena() == nullptr) {
7158     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
7159   }
7160   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
7161   if (value != nullptr) {
7162     _impl_._has_bits_[0] |= 0x00000080U;
7163   } else {
7164     _impl_._has_bits_[0] &= ~0x00000080U;
7165   }
7166   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
7167 }
7168 inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE AttributeProto::release_sparse_tensor() {
7169   ::google::protobuf::internal::TSanWrite(&_impl_);
7170 
7171   _impl_._has_bits_[0] &= ~0x00000080U;
7172   ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_;
7173   _impl_.sparse_tensor_ = nullptr;
7174   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
7175     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7176     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7177     if (GetArena() == nullptr) {
7178       delete old;
7179     }
7180   } else {
7181     if (GetArena() != nullptr) {
7182       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7183     }
7184   }
7185   return released;
7186 }
7187 inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_sparse_tensor() {
7188   ::google::protobuf::internal::TSanWrite(&_impl_);
7189   // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)
7190 
7191   _impl_._has_bits_[0] &= ~0x00000080U;
7192   ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_;
7193   _impl_.sparse_tensor_ = nullptr;
7194   return temp;
7195 }
7196 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_sparse_tensor() {
7197   ::google::protobuf::internal::TSanWrite(&_impl_);
7198   if (_impl_.sparse_tensor_ == nullptr) {
7199     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
7200     _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
7201   }
7202   return _impl_.sparse_tensor_;
7203 }
7204 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensor()
7205     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7206   _impl_._has_bits_[0] |= 0x00000080U;
7207   ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor();
7208   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
7209   return _msg;
7210 }
7211 inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
7212   ::google::protobuf::Arena* message_arena = GetArena();
7213   ::google::protobuf::internal::TSanWrite(&_impl_);
7214   if (message_arena == nullptr) {
7215     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
7216   }
7217 
7218   if (value != nullptr) {
7219     ::google::protobuf::Arena* submessage_arena = value->GetArena();
7220     if (message_arena != submessage_arena) {
7221       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7222     }
7223     _impl_._has_bits_[0] |= 0x00000080U;
7224   } else {
7225     _impl_._has_bits_[0] &= ~0x00000080U;
7226   }
7227 
7228   _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
7229   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
7230 }
7231 
7232 // optional .onnx.TypeProto tp = 14;
7233 inline bool AttributeProto::has_tp() const {
7234   bool value = (_impl_._has_bits_[0] & 0x00000040U) != 0;
7235   PROTOBUF_ASSUME(!value || _impl_.tp_ != nullptr);
7236   return value;
7237 }
7238 inline void AttributeProto::clear_tp() {
7239   ::google::protobuf::internal::TSanWrite(&_impl_);
7240   if (_impl_.tp_ != nullptr) _impl_.tp_->Clear();
7241   _impl_._has_bits_[0] &= ~0x00000040U;
7242 }
7243 inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
7244   ::google::protobuf::internal::TSanRead(&_impl_);
7245   const ::onnx::TypeProto* p = _impl_.tp_;
7246   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
7247 }
7248 inline const ::onnx::TypeProto& AttributeProto::tp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7249   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
7250   return _internal_tp();
7251 }
7252 inline void AttributeProto::unsafe_arena_set_allocated_tp(
7253     ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
7254   ::google::protobuf::internal::TSanWrite(&_impl_);
7255   if (GetArena() == nullptr) {
7256     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
7257   }
7258   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
7259   if (value != nullptr) {
7260     _impl_._has_bits_[0] |= 0x00000040U;
7261   } else {
7262     _impl_._has_bits_[0] &= ~0x00000040U;
7263   }
7264   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
7265 }
7266 inline ::onnx::TypeProto* PROTOBUF_NULLABLE AttributeProto::release_tp() {
7267   ::google::protobuf::internal::TSanWrite(&_impl_);
7268 
7269   _impl_._has_bits_[0] &= ~0x00000040U;
7270   ::onnx::TypeProto* released = _impl_.tp_;
7271   _impl_.tp_ = nullptr;
7272   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
7273     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7274     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7275     if (GetArena() == nullptr) {
7276       delete old;
7277     }
7278   } else {
7279     if (GetArena() != nullptr) {
7280       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7281     }
7282   }
7283   return released;
7284 }
7285 inline ::onnx::TypeProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_tp() {
7286   ::google::protobuf::internal::TSanWrite(&_impl_);
7287   // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)
7288 
7289   _impl_._has_bits_[0] &= ~0x00000040U;
7290   ::onnx::TypeProto* temp = _impl_.tp_;
7291   _impl_.tp_ = nullptr;
7292   return temp;
7293 }
7294 inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_tp() {
7295   ::google::protobuf::internal::TSanWrite(&_impl_);
7296   if (_impl_.tp_ == nullptr) {
7297     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
7298     _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(p);
7299   }
7300   return _impl_.tp_;
7301 }
7302 inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::mutable_tp()
7303     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7304   _impl_._has_bits_[0] |= 0x00000040U;
7305   ::onnx::TypeProto* _msg = _internal_mutable_tp();
7306   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
7307   return _msg;
7308 }
7309 inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
7310   ::google::protobuf::Arena* message_arena = GetArena();
7311   ::google::protobuf::internal::TSanWrite(&_impl_);
7312   if (message_arena == nullptr) {
7313     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
7314   }
7315 
7316   if (value != nullptr) {
7317     ::google::protobuf::Arena* submessage_arena = value->GetArena();
7318     if (message_arena != submessage_arena) {
7319       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7320     }
7321     _impl_._has_bits_[0] |= 0x00000040U;
7322   } else {
7323     _impl_._has_bits_[0] &= ~0x00000040U;
7324   }
7325 
7326   _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
7327   // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
7328 }
7329 
7330 // repeated float floats = 7;
7331 inline int AttributeProto::_internal_floats_size() const {
7332   return _internal_floats().size();
7333 }
7334 inline int AttributeProto::floats_size() const {
7335   return _internal_floats_size();
7336 }
7337 inline void AttributeProto::clear_floats() {
7338   ::google::protobuf::internal::TSanWrite(&_impl_);
7339   _impl_.floats_.Clear();
7340 }
7341 inline float AttributeProto::floats(int index) const {
7342   // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
7343   return _internal_floats().Get(index);
7344 }
7345 inline void AttributeProto::set_floats(int index, float value) {
7346   _internal_mutable_floats()->Set(index, value);
7347   // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
7348 }
7349 inline void AttributeProto::add_floats(float value) {
7350   ::google::protobuf::internal::TSanWrite(&_impl_);
7351   _internal_mutable_floats()->Add(value);
7352   // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
7353 }
7354 inline const ::google::protobuf::RepeatedField<float>& AttributeProto::floats() const
7355     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7356   // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
7357   return _internal_floats();
7358 }
7359 inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL AttributeProto::mutable_floats()
7360     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7361   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
7362   ::google::protobuf::internal::TSanWrite(&_impl_);
7363   return _internal_mutable_floats();
7364 }
7365 inline const ::google::protobuf::RepeatedField<float>&
7366 AttributeProto::_internal_floats() const {
7367   ::google::protobuf::internal::TSanRead(&_impl_);
7368   return _impl_.floats_;
7369 }
7370 inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL
7371 AttributeProto::_internal_mutable_floats() {
7372   ::google::protobuf::internal::TSanRead(&_impl_);
7373   return &_impl_.floats_;
7374 }
7375 
7376 // repeated int64 ints = 8;
7377 inline int AttributeProto::_internal_ints_size() const {
7378   return _internal_ints().size();
7379 }
7380 inline int AttributeProto::ints_size() const {
7381   return _internal_ints_size();
7382 }
7383 inline void AttributeProto::clear_ints() {
7384   ::google::protobuf::internal::TSanWrite(&_impl_);
7385   _impl_.ints_.Clear();
7386 }
7387 inline ::int64_t AttributeProto::ints(int index) const {
7388   // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
7389   return _internal_ints().Get(index);
7390 }
7391 inline void AttributeProto::set_ints(int index, ::int64_t value) {
7392   _internal_mutable_ints()->Set(index, value);
7393   // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
7394 }
7395 inline void AttributeProto::add_ints(::int64_t value) {
7396   ::google::protobuf::internal::TSanWrite(&_impl_);
7397   _internal_mutable_ints()->Add(value);
7398   // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
7399 }
7400 inline const ::google::protobuf::RepeatedField<::int64_t>& AttributeProto::ints() const
7401     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7402   // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
7403   return _internal_ints();
7404 }
7405 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL AttributeProto::mutable_ints()
7406     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7407   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
7408   ::google::protobuf::internal::TSanWrite(&_impl_);
7409   return _internal_mutable_ints();
7410 }
7411 inline const ::google::protobuf::RepeatedField<::int64_t>&
7412 AttributeProto::_internal_ints() const {
7413   ::google::protobuf::internal::TSanRead(&_impl_);
7414   return _impl_.ints_;
7415 }
7416 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
7417 AttributeProto::_internal_mutable_ints() {
7418   ::google::protobuf::internal::TSanRead(&_impl_);
7419   return &_impl_.ints_;
7420 }
7421 
7422 // repeated bytes strings = 9;
7423 inline int AttributeProto::_internal_strings_size() const {
7424   return _internal_strings().size();
7425 }
7426 inline int AttributeProto::strings_size() const {
7427   return _internal_strings_size();
7428 }
7429 inline void AttributeProto::clear_strings() {
7430   ::google::protobuf::internal::TSanWrite(&_impl_);
7431   _impl_.strings_.Clear();
7432 }
7433 inline ::std::string* PROTOBUF_NONNULL AttributeProto::add_strings()
7434     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7435   ::google::protobuf::internal::TSanWrite(&_impl_);
7436   ::std::string* _s = _internal_mutable_strings()->Add();
7437   // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
7438   return _s;
7439 }
7440 inline const ::std::string& AttributeProto::strings(int index) const
7441     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7442   // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
7443   return _internal_strings().Get(index);
7444 }
7445 inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_strings(int index)
7446     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7447   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
7448   return _internal_mutable_strings()->Mutable(index);
7449 }
7450 template <typename Arg_, typename... Args_>
7451 inline void AttributeProto::set_strings(int index, Arg_&& value, Args_... args) {
7452   ::google::protobuf::internal::AssignToString(*_internal_mutable_strings()->Mutable(index), ::std::forward<Arg_>(value),
7453                         args... , ::google::protobuf::internal::BytesTag{});
7454   // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
7455 }
7456 template <typename Arg_, typename... Args_>
7457 inline void AttributeProto::add_strings(Arg_&& value, Args_... args) {
7458   ::google::protobuf::internal::TSanWrite(&_impl_);
7459   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_strings(),
7460                                ::std::forward<Arg_>(value),
7461                                args... , ::google::protobuf::internal::BytesTag{});
7462   // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
7463 }
7464 inline const ::google::protobuf::RepeatedPtrField<::std::string>& AttributeProto::strings()
7465     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7466   // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
7467   return _internal_strings();
7468 }
7469 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
7470 AttributeProto::mutable_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
7471   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
7472   ::google::protobuf::internal::TSanWrite(&_impl_);
7473   return _internal_mutable_strings();
7474 }
7475 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
7476 AttributeProto::_internal_strings() const {
7477   ::google::protobuf::internal::TSanRead(&_impl_);
7478   return _impl_.strings_;
7479 }
7480 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
7481 AttributeProto::_internal_mutable_strings() {
7482   ::google::protobuf::internal::TSanRead(&_impl_);
7483   return &_impl_.strings_;
7484 }
7485 
7486 // repeated .onnx.TensorProto tensors = 10;
7487 inline int AttributeProto::_internal_tensors_size() const {
7488   return _internal_tensors().size();
7489 }
7490 inline int AttributeProto::tensors_size() const {
7491   return _internal_tensors_size();
7492 }
7493 inline void AttributeProto::clear_tensors() {
7494   ::google::protobuf::internal::TSanWrite(&_impl_);
7495   _impl_.tensors_.Clear();
7496 }
7497 inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::mutable_tensors(int index)
7498     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7499   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
7500   return _internal_mutable_tensors()->Mutable(index);
7501 }
7502 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL AttributeProto::mutable_tensors()
7503     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7504   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
7505   ::google::protobuf::internal::TSanWrite(&_impl_);
7506   return _internal_mutable_tensors();
7507 }
7508 inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const
7509     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7510   // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
7511   return _internal_tensors().Get(index);
7512 }
7513 inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::add_tensors()
7514     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7515   ::google::protobuf::internal::TSanWrite(&_impl_);
7516   ::onnx::TensorProto* _add = _internal_mutable_tensors()->Add();
7517   // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
7518   return _add;
7519 }
7520 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& AttributeProto::tensors() const
7521     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7522   // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
7523   return _internal_tensors();
7524 }
7525 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
7526 AttributeProto::_internal_tensors() const {
7527   ::google::protobuf::internal::TSanRead(&_impl_);
7528   return _impl_.tensors_;
7529 }
7530 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
7531 AttributeProto::_internal_mutable_tensors() {
7532   ::google::protobuf::internal::TSanRead(&_impl_);
7533   return &_impl_.tensors_;
7534 }
7535 
7536 // repeated .onnx.GraphProto graphs = 11;
7537 inline int AttributeProto::_internal_graphs_size() const {
7538   return _internal_graphs().size();
7539 }
7540 inline int AttributeProto::graphs_size() const {
7541   return _internal_graphs_size();
7542 }
7543 inline void AttributeProto::clear_graphs() {
7544   ::google::protobuf::internal::TSanWrite(&_impl_);
7545   _impl_.graphs_.Clear();
7546 }
7547 inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::mutable_graphs(int index)
7548     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7549   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
7550   return _internal_mutable_graphs()->Mutable(index);
7551 }
7552 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL AttributeProto::mutable_graphs()
7553     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7554   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
7555   ::google::protobuf::internal::TSanWrite(&_impl_);
7556   return _internal_mutable_graphs();
7557 }
7558 inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const
7559     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7560   // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
7561   return _internal_graphs().Get(index);
7562 }
7563 inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::add_graphs()
7564     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7565   ::google::protobuf::internal::TSanWrite(&_impl_);
7566   ::onnx::GraphProto* _add = _internal_mutable_graphs()->Add();
7567   // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
7568   return _add;
7569 }
7570 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& AttributeProto::graphs() const
7571     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7572   // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
7573   return _internal_graphs();
7574 }
7575 inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>&
7576 AttributeProto::_internal_graphs() const {
7577   ::google::protobuf::internal::TSanRead(&_impl_);
7578   return _impl_.graphs_;
7579 }
7580 inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL
7581 AttributeProto::_internal_mutable_graphs() {
7582   ::google::protobuf::internal::TSanRead(&_impl_);
7583   return &_impl_.graphs_;
7584 }
7585 
7586 // repeated .onnx.SparseTensorProto sparse_tensors = 23;
7587 inline int AttributeProto::_internal_sparse_tensors_size() const {
7588   return _internal_sparse_tensors().size();
7589 }
7590 inline int AttributeProto::sparse_tensors_size() const {
7591   return _internal_sparse_tensors_size();
7592 }
7593 inline void AttributeProto::clear_sparse_tensors() {
7594   ::google::protobuf::internal::TSanWrite(&_impl_);
7595   _impl_.sparse_tensors_.Clear();
7596 }
7597 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensors(int index)
7598     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7599   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
7600   return _internal_mutable_sparse_tensors()->Mutable(index);
7601 }
7602 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensors()
7603     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7604   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
7605   ::google::protobuf::internal::TSanWrite(&_impl_);
7606   return _internal_mutable_sparse_tensors();
7607 }
7608 inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const
7609     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7610   // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
7611   return _internal_sparse_tensors().Get(index);
7612 }
7613 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::add_sparse_tensors()
7614     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7615   ::google::protobuf::internal::TSanWrite(&_impl_);
7616   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_tensors()->Add();
7617   // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
7618   return _add;
7619 }
7620 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& AttributeProto::sparse_tensors() const
7621     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7622   // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
7623   return _internal_sparse_tensors();
7624 }
7625 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
7626 AttributeProto::_internal_sparse_tensors() const {
7627   ::google::protobuf::internal::TSanRead(&_impl_);
7628   return _impl_.sparse_tensors_;
7629 }
7630 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
7631 AttributeProto::_internal_mutable_sparse_tensors() {
7632   ::google::protobuf::internal::TSanRead(&_impl_);
7633   return &_impl_.sparse_tensors_;
7634 }
7635 
7636 // repeated .onnx.TypeProto type_protos = 15;
7637 inline int AttributeProto::_internal_type_protos_size() const {
7638   return _internal_type_protos().size();
7639 }
7640 inline int AttributeProto::type_protos_size() const {
7641   return _internal_type_protos_size();
7642 }
7643 inline void AttributeProto::clear_type_protos() {
7644   ::google::protobuf::internal::TSanWrite(&_impl_);
7645   _impl_.type_protos_.Clear();
7646 }
7647 inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::mutable_type_protos(int index)
7648     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7649   // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
7650   return _internal_mutable_type_protos()->Mutable(index);
7651 }
7652 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL AttributeProto::mutable_type_protos()
7653     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7654   // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
7655   ::google::protobuf::internal::TSanWrite(&_impl_);
7656   return _internal_mutable_type_protos();
7657 }
7658 inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const
7659     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7660   // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
7661   return _internal_type_protos().Get(index);
7662 }
7663 inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::add_type_protos()
7664     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7665   ::google::protobuf::internal::TSanWrite(&_impl_);
7666   ::onnx::TypeProto* _add = _internal_mutable_type_protos()->Add();
7667   // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
7668   return _add;
7669 }
7670 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& AttributeProto::type_protos() const
7671     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7672   // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
7673   return _internal_type_protos();
7674 }
7675 inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>&
7676 AttributeProto::_internal_type_protos() const {
7677   ::google::protobuf::internal::TSanRead(&_impl_);
7678   return _impl_.type_protos_;
7679 }
7680 inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL
7681 AttributeProto::_internal_mutable_type_protos() {
7682   ::google::protobuf::internal::TSanRead(&_impl_);
7683   return &_impl_.type_protos_;
7684 }
7685 
7686 // -------------------------------------------------------------------
7687 
7688 // ValueInfoProto
7689 
7690 // optional string name = 1;
7691 inline bool ValueInfoProto::has_name() const {
7692   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
7693   return value;
7694 }
7695 inline void ValueInfoProto::clear_name() {
7696   ::google::protobuf::internal::TSanWrite(&_impl_);
7697   _impl_.name_.ClearToEmpty();
7698   _impl_._has_bits_[0] &= ~0x00000001U;
7699 }
7700 inline const ::std::string& ValueInfoProto::name() const
7701     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7702   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
7703   return _internal_name();
7704 }
7705 template <typename Arg_, typename... Args_>
7706 PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_name(Arg_&& arg, Args_... args) {
7707   ::google::protobuf::internal::TSanWrite(&_impl_);
7708   _impl_._has_bits_[0] |= 0x00000001U;
7709   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
7710   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
7711 }
7712 inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::mutable_name()
7713     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7714   ::std::string* _s = _internal_mutable_name();
7715   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
7716   return _s;
7717 }
7718 inline const ::std::string& ValueInfoProto::_internal_name() const {
7719   ::google::protobuf::internal::TSanRead(&_impl_);
7720   return _impl_.name_.Get();
7721 }
7722 inline void ValueInfoProto::_internal_set_name(const ::std::string& value) {
7723   ::google::protobuf::internal::TSanWrite(&_impl_);
7724   _impl_._has_bits_[0] |= 0x00000001U;
7725   _impl_.name_.Set(value, GetArena());
7726 }
7727 inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_name() {
7728   ::google::protobuf::internal::TSanWrite(&_impl_);
7729   _impl_._has_bits_[0] |= 0x00000001U;
7730   return _impl_.name_.Mutable( GetArena());
7731 }
7732 inline ::std::string* PROTOBUF_NULLABLE ValueInfoProto::release_name() {
7733   ::google::protobuf::internal::TSanWrite(&_impl_);
7734   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
7735   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
7736     return nullptr;
7737   }
7738   _impl_._has_bits_[0] &= ~0x00000001U;
7739   auto* released = _impl_.name_.Release();
7740   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
7741     _impl_.name_.Set("", GetArena());
7742   }
7743   return released;
7744 }
7745 inline void ValueInfoProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
7746   ::google::protobuf::internal::TSanWrite(&_impl_);
7747   if (value != nullptr) {
7748     _impl_._has_bits_[0] |= 0x00000001U;
7749   } else {
7750     _impl_._has_bits_[0] &= ~0x00000001U;
7751   }
7752   _impl_.name_.SetAllocated(value, GetArena());
7753   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
7754     _impl_.name_.Set("", GetArena());
7755   }
7756   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
7757 }
7758 
7759 // optional .onnx.TypeProto type = 2;
7760 inline bool ValueInfoProto::has_type() const {
7761   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
7762   PROTOBUF_ASSUME(!value || _impl_.type_ != nullptr);
7763   return value;
7764 }
7765 inline void ValueInfoProto::clear_type() {
7766   ::google::protobuf::internal::TSanWrite(&_impl_);
7767   if (_impl_.type_ != nullptr) _impl_.type_->Clear();
7768   _impl_._has_bits_[0] &= ~0x00000004U;
7769 }
7770 inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
7771   ::google::protobuf::internal::TSanRead(&_impl_);
7772   const ::onnx::TypeProto* p = _impl_.type_;
7773   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
7774 }
7775 inline const ::onnx::TypeProto& ValueInfoProto::type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
7776   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
7777   return _internal_type();
7778 }
7779 inline void ValueInfoProto::unsafe_arena_set_allocated_type(
7780     ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
7781   ::google::protobuf::internal::TSanWrite(&_impl_);
7782   if (GetArena() == nullptr) {
7783     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
7784   }
7785   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
7786   if (value != nullptr) {
7787     _impl_._has_bits_[0] |= 0x00000004U;
7788   } else {
7789     _impl_._has_bits_[0] &= ~0x00000004U;
7790   }
7791   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
7792 }
7793 inline ::onnx::TypeProto* PROTOBUF_NULLABLE ValueInfoProto::release_type() {
7794   ::google::protobuf::internal::TSanWrite(&_impl_);
7795 
7796   _impl_._has_bits_[0] &= ~0x00000004U;
7797   ::onnx::TypeProto* released = _impl_.type_;
7798   _impl_.type_ = nullptr;
7799   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
7800     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
7801     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7802     if (GetArena() == nullptr) {
7803       delete old;
7804     }
7805   } else {
7806     if (GetArena() != nullptr) {
7807       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
7808     }
7809   }
7810   return released;
7811 }
7812 inline ::onnx::TypeProto* PROTOBUF_NULLABLE ValueInfoProto::unsafe_arena_release_type() {
7813   ::google::protobuf::internal::TSanWrite(&_impl_);
7814   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)
7815 
7816   _impl_._has_bits_[0] &= ~0x00000004U;
7817   ::onnx::TypeProto* temp = _impl_.type_;
7818   _impl_.type_ = nullptr;
7819   return temp;
7820 }
7821 inline ::onnx::TypeProto* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_type() {
7822   ::google::protobuf::internal::TSanWrite(&_impl_);
7823   if (_impl_.type_ == nullptr) {
7824     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
7825     _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(p);
7826   }
7827   return _impl_.type_;
7828 }
7829 inline ::onnx::TypeProto* PROTOBUF_NONNULL ValueInfoProto::mutable_type()
7830     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7831   _impl_._has_bits_[0] |= 0x00000004U;
7832   ::onnx::TypeProto* _msg = _internal_mutable_type();
7833   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
7834   return _msg;
7835 }
7836 inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
7837   ::google::protobuf::Arena* message_arena = GetArena();
7838   ::google::protobuf::internal::TSanWrite(&_impl_);
7839   if (message_arena == nullptr) {
7840     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
7841   }
7842 
7843   if (value != nullptr) {
7844     ::google::protobuf::Arena* submessage_arena = value->GetArena();
7845     if (message_arena != submessage_arena) {
7846       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
7847     }
7848     _impl_._has_bits_[0] |= 0x00000004U;
7849   } else {
7850     _impl_._has_bits_[0] &= ~0x00000004U;
7851   }
7852 
7853   _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
7854   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
7855 }
7856 
7857 // optional string doc_string = 3;
7858 inline bool ValueInfoProto::has_doc_string() const {
7859   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
7860   return value;
7861 }
7862 inline void ValueInfoProto::clear_doc_string() {
7863   ::google::protobuf::internal::TSanWrite(&_impl_);
7864   _impl_.doc_string_.ClearToEmpty();
7865   _impl_._has_bits_[0] &= ~0x00000002U;
7866 }
7867 inline const ::std::string& ValueInfoProto::doc_string() const
7868     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7869   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
7870   return _internal_doc_string();
7871 }
7872 template <typename Arg_, typename... Args_>
7873 PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_doc_string(Arg_&& arg, Args_... args) {
7874   ::google::protobuf::internal::TSanWrite(&_impl_);
7875   _impl_._has_bits_[0] |= 0x00000002U;
7876   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
7877   // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
7878 }
7879 inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::mutable_doc_string()
7880     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7881   ::std::string* _s = _internal_mutable_doc_string();
7882   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
7883   return _s;
7884 }
7885 inline const ::std::string& ValueInfoProto::_internal_doc_string() const {
7886   ::google::protobuf::internal::TSanRead(&_impl_);
7887   return _impl_.doc_string_.Get();
7888 }
7889 inline void ValueInfoProto::_internal_set_doc_string(const ::std::string& value) {
7890   ::google::protobuf::internal::TSanWrite(&_impl_);
7891   _impl_._has_bits_[0] |= 0x00000002U;
7892   _impl_.doc_string_.Set(value, GetArena());
7893 }
7894 inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_doc_string() {
7895   ::google::protobuf::internal::TSanWrite(&_impl_);
7896   _impl_._has_bits_[0] |= 0x00000002U;
7897   return _impl_.doc_string_.Mutable( GetArena());
7898 }
7899 inline ::std::string* PROTOBUF_NULLABLE ValueInfoProto::release_doc_string() {
7900   ::google::protobuf::internal::TSanWrite(&_impl_);
7901   // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
7902   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
7903     return nullptr;
7904   }
7905   _impl_._has_bits_[0] &= ~0x00000002U;
7906   auto* released = _impl_.doc_string_.Release();
7907   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
7908     _impl_.doc_string_.Set("", GetArena());
7909   }
7910   return released;
7911 }
7912 inline void ValueInfoProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
7913   ::google::protobuf::internal::TSanWrite(&_impl_);
7914   if (value != nullptr) {
7915     _impl_._has_bits_[0] |= 0x00000002U;
7916   } else {
7917     _impl_._has_bits_[0] &= ~0x00000002U;
7918   }
7919   _impl_.doc_string_.SetAllocated(value, GetArena());
7920   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
7921     _impl_.doc_string_.Set("", GetArena());
7922   }
7923   // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
7924 }
7925 
7926 // repeated .onnx.StringStringEntryProto metadata_props = 4;
7927 inline int ValueInfoProto::_internal_metadata_props_size() const {
7928   return _internal_metadata_props().size();
7929 }
7930 inline int ValueInfoProto::metadata_props_size() const {
7931   return _internal_metadata_props_size();
7932 }
7933 inline void ValueInfoProto::clear_metadata_props() {
7934   ::google::protobuf::internal::TSanWrite(&_impl_);
7935   _impl_.metadata_props_.Clear();
7936 }
7937 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ValueInfoProto::mutable_metadata_props(int index)
7938     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7939   // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props)
7940   return _internal_mutable_metadata_props()->Mutable(index);
7941 }
7942 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL ValueInfoProto::mutable_metadata_props()
7943     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7944   // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props)
7945   ::google::protobuf::internal::TSanWrite(&_impl_);
7946   return _internal_mutable_metadata_props();
7947 }
7948 inline const ::onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const
7949     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7950   // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props)
7951   return _internal_metadata_props().Get(index);
7952 }
7953 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ValueInfoProto::add_metadata_props()
7954     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7955   ::google::protobuf::internal::TSanWrite(&_impl_);
7956   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
7957   // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props)
7958   return _add;
7959 }
7960 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ValueInfoProto::metadata_props() const
7961     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7962   // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props)
7963   return _internal_metadata_props();
7964 }
7965 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
7966 ValueInfoProto::_internal_metadata_props() const {
7967   ::google::protobuf::internal::TSanRead(&_impl_);
7968   return _impl_.metadata_props_;
7969 }
7970 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
7971 ValueInfoProto::_internal_mutable_metadata_props() {
7972   ::google::protobuf::internal::TSanRead(&_impl_);
7973   return &_impl_.metadata_props_;
7974 }
7975 
7976 // -------------------------------------------------------------------
7977 
7978 // NodeProto
7979 
7980 // repeated string input = 1;
7981 inline int NodeProto::_internal_input_size() const {
7982   return _internal_input().size();
7983 }
7984 inline int NodeProto::input_size() const {
7985   return _internal_input_size();
7986 }
7987 inline void NodeProto::clear_input() {
7988   ::google::protobuf::internal::TSanWrite(&_impl_);
7989   _impl_.input_.Clear();
7990 }
7991 inline ::std::string* PROTOBUF_NONNULL NodeProto::add_input()
7992     ABSL_ATTRIBUTE_LIFETIME_BOUND {
7993   ::google::protobuf::internal::TSanWrite(&_impl_);
7994   ::std::string* _s = _internal_mutable_input()->Add();
7995   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
7996   return _s;
7997 }
7998 inline const ::std::string& NodeProto::input(int index) const
7999     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8000   // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
8001   return _internal_input().Get(index);
8002 }
8003 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_input(int index)
8004     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8005   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
8006   return _internal_mutable_input()->Mutable(index);
8007 }
8008 template <typename Arg_, typename... Args_>
8009 inline void NodeProto::set_input(int index, Arg_&& value, Args_... args) {
8010   ::google::protobuf::internal::AssignToString(*_internal_mutable_input()->Mutable(index), ::std::forward<Arg_>(value),
8011                         args... );
8012   // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
8013 }
8014 template <typename Arg_, typename... Args_>
8015 inline void NodeProto::add_input(Arg_&& value, Args_... args) {
8016   ::google::protobuf::internal::TSanWrite(&_impl_);
8017   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
8018                                ::std::forward<Arg_>(value),
8019                                args... );
8020   // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
8021 }
8022 inline const ::google::protobuf::RepeatedPtrField<::std::string>& NodeProto::input()
8023     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8024   // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
8025   return _internal_input();
8026 }
8027 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
8028 NodeProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8029   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
8030   ::google::protobuf::internal::TSanWrite(&_impl_);
8031   return _internal_mutable_input();
8032 }
8033 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
8034 NodeProto::_internal_input() const {
8035   ::google::protobuf::internal::TSanRead(&_impl_);
8036   return _impl_.input_;
8037 }
8038 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
8039 NodeProto::_internal_mutable_input() {
8040   ::google::protobuf::internal::TSanRead(&_impl_);
8041   return &_impl_.input_;
8042 }
8043 
8044 // repeated string output = 2;
8045 inline int NodeProto::_internal_output_size() const {
8046   return _internal_output().size();
8047 }
8048 inline int NodeProto::output_size() const {
8049   return _internal_output_size();
8050 }
8051 inline void NodeProto::clear_output() {
8052   ::google::protobuf::internal::TSanWrite(&_impl_);
8053   _impl_.output_.Clear();
8054 }
8055 inline ::std::string* PROTOBUF_NONNULL NodeProto::add_output()
8056     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8057   ::google::protobuf::internal::TSanWrite(&_impl_);
8058   ::std::string* _s = _internal_mutable_output()->Add();
8059   // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
8060   return _s;
8061 }
8062 inline const ::std::string& NodeProto::output(int index) const
8063     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8064   // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
8065   return _internal_output().Get(index);
8066 }
8067 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_output(int index)
8068     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8069   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
8070   return _internal_mutable_output()->Mutable(index);
8071 }
8072 template <typename Arg_, typename... Args_>
8073 inline void NodeProto::set_output(int index, Arg_&& value, Args_... args) {
8074   ::google::protobuf::internal::AssignToString(*_internal_mutable_output()->Mutable(index), ::std::forward<Arg_>(value),
8075                         args... );
8076   // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
8077 }
8078 template <typename Arg_, typename... Args_>
8079 inline void NodeProto::add_output(Arg_&& value, Args_... args) {
8080   ::google::protobuf::internal::TSanWrite(&_impl_);
8081   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
8082                                ::std::forward<Arg_>(value),
8083                                args... );
8084   // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
8085 }
8086 inline const ::google::protobuf::RepeatedPtrField<::std::string>& NodeProto::output()
8087     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8088   // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
8089   return _internal_output();
8090 }
8091 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
8092 NodeProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
8093   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
8094   ::google::protobuf::internal::TSanWrite(&_impl_);
8095   return _internal_mutable_output();
8096 }
8097 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
8098 NodeProto::_internal_output() const {
8099   ::google::protobuf::internal::TSanRead(&_impl_);
8100   return _impl_.output_;
8101 }
8102 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
8103 NodeProto::_internal_mutable_output() {
8104   ::google::protobuf::internal::TSanRead(&_impl_);
8105   return &_impl_.output_;
8106 }
8107 
8108 // optional string name = 3;
8109 inline bool NodeProto::has_name() const {
8110   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
8111   return value;
8112 }
8113 inline void NodeProto::clear_name() {
8114   ::google::protobuf::internal::TSanWrite(&_impl_);
8115   _impl_.name_.ClearToEmpty();
8116   _impl_._has_bits_[0] &= ~0x00000001U;
8117 }
8118 inline const ::std::string& NodeProto::name() const
8119     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8120   // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
8121   return _internal_name();
8122 }
8123 template <typename Arg_, typename... Args_>
8124 PROTOBUF_ALWAYS_INLINE void NodeProto::set_name(Arg_&& arg, Args_... args) {
8125   ::google::protobuf::internal::TSanWrite(&_impl_);
8126   _impl_._has_bits_[0] |= 0x00000001U;
8127   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8128   // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
8129 }
8130 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_name()
8131     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8132   ::std::string* _s = _internal_mutable_name();
8133   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
8134   return _s;
8135 }
8136 inline const ::std::string& NodeProto::_internal_name() const {
8137   ::google::protobuf::internal::TSanRead(&_impl_);
8138   return _impl_.name_.Get();
8139 }
8140 inline void NodeProto::_internal_set_name(const ::std::string& value) {
8141   ::google::protobuf::internal::TSanWrite(&_impl_);
8142   _impl_._has_bits_[0] |= 0x00000001U;
8143   _impl_.name_.Set(value, GetArena());
8144 }
8145 inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_name() {
8146   ::google::protobuf::internal::TSanWrite(&_impl_);
8147   _impl_._has_bits_[0] |= 0x00000001U;
8148   return _impl_.name_.Mutable( GetArena());
8149 }
8150 inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_name() {
8151   ::google::protobuf::internal::TSanWrite(&_impl_);
8152   // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
8153   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
8154     return nullptr;
8155   }
8156   _impl_._has_bits_[0] &= ~0x00000001U;
8157   auto* released = _impl_.name_.Release();
8158   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8159     _impl_.name_.Set("", GetArena());
8160   }
8161   return released;
8162 }
8163 inline void NodeProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
8164   ::google::protobuf::internal::TSanWrite(&_impl_);
8165   if (value != nullptr) {
8166     _impl_._has_bits_[0] |= 0x00000001U;
8167   } else {
8168     _impl_._has_bits_[0] &= ~0x00000001U;
8169   }
8170   _impl_.name_.SetAllocated(value, GetArena());
8171   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
8172     _impl_.name_.Set("", GetArena());
8173   }
8174   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
8175 }
8176 
8177 // optional string op_type = 4;
8178 inline bool NodeProto::has_op_type() const {
8179   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
8180   return value;
8181 }
8182 inline void NodeProto::clear_op_type() {
8183   ::google::protobuf::internal::TSanWrite(&_impl_);
8184   _impl_.op_type_.ClearToEmpty();
8185   _impl_._has_bits_[0] &= ~0x00000002U;
8186 }
8187 inline const ::std::string& NodeProto::op_type() const
8188     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8189   // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
8190   return _internal_op_type();
8191 }
8192 template <typename Arg_, typename... Args_>
8193 PROTOBUF_ALWAYS_INLINE void NodeProto::set_op_type(Arg_&& arg, Args_... args) {
8194   ::google::protobuf::internal::TSanWrite(&_impl_);
8195   _impl_._has_bits_[0] |= 0x00000002U;
8196   _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8197   // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
8198 }
8199 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_op_type()
8200     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8201   ::std::string* _s = _internal_mutable_op_type();
8202   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
8203   return _s;
8204 }
8205 inline const ::std::string& NodeProto::_internal_op_type() const {
8206   ::google::protobuf::internal::TSanRead(&_impl_);
8207   return _impl_.op_type_.Get();
8208 }
8209 inline void NodeProto::_internal_set_op_type(const ::std::string& value) {
8210   ::google::protobuf::internal::TSanWrite(&_impl_);
8211   _impl_._has_bits_[0] |= 0x00000002U;
8212   _impl_.op_type_.Set(value, GetArena());
8213 }
8214 inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_op_type() {
8215   ::google::protobuf::internal::TSanWrite(&_impl_);
8216   _impl_._has_bits_[0] |= 0x00000002U;
8217   return _impl_.op_type_.Mutable( GetArena());
8218 }
8219 inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_op_type() {
8220   ::google::protobuf::internal::TSanWrite(&_impl_);
8221   // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
8222   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
8223     return nullptr;
8224   }
8225   _impl_._has_bits_[0] &= ~0x00000002U;
8226   auto* released = _impl_.op_type_.Release();
8227   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8228     _impl_.op_type_.Set("", GetArena());
8229   }
8230   return released;
8231 }
8232 inline void NodeProto::set_allocated_op_type(::std::string* PROTOBUF_NULLABLE value) {
8233   ::google::protobuf::internal::TSanWrite(&_impl_);
8234   if (value != nullptr) {
8235     _impl_._has_bits_[0] |= 0x00000002U;
8236   } else {
8237     _impl_._has_bits_[0] &= ~0x00000002U;
8238   }
8239   _impl_.op_type_.SetAllocated(value, GetArena());
8240   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.op_type_.IsDefault()) {
8241     _impl_.op_type_.Set("", GetArena());
8242   }
8243   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type)
8244 }
8245 
8246 // optional string domain = 7;
8247 inline bool NodeProto::has_domain() const {
8248   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
8249   return value;
8250 }
8251 inline void NodeProto::clear_domain() {
8252   ::google::protobuf::internal::TSanWrite(&_impl_);
8253   _impl_.domain_.ClearToEmpty();
8254   _impl_._has_bits_[0] &= ~0x00000008U;
8255 }
8256 inline const ::std::string& NodeProto::domain() const
8257     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8258   // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
8259   return _internal_domain();
8260 }
8261 template <typename Arg_, typename... Args_>
8262 PROTOBUF_ALWAYS_INLINE void NodeProto::set_domain(Arg_&& arg, Args_... args) {
8263   ::google::protobuf::internal::TSanWrite(&_impl_);
8264   _impl_._has_bits_[0] |= 0x00000008U;
8265   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8266   // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
8267 }
8268 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_domain()
8269     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8270   ::std::string* _s = _internal_mutable_domain();
8271   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
8272   return _s;
8273 }
8274 inline const ::std::string& NodeProto::_internal_domain() const {
8275   ::google::protobuf::internal::TSanRead(&_impl_);
8276   return _impl_.domain_.Get();
8277 }
8278 inline void NodeProto::_internal_set_domain(const ::std::string& value) {
8279   ::google::protobuf::internal::TSanWrite(&_impl_);
8280   _impl_._has_bits_[0] |= 0x00000008U;
8281   _impl_.domain_.Set(value, GetArena());
8282 }
8283 inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_domain() {
8284   ::google::protobuf::internal::TSanWrite(&_impl_);
8285   _impl_._has_bits_[0] |= 0x00000008U;
8286   return _impl_.domain_.Mutable( GetArena());
8287 }
8288 inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_domain() {
8289   ::google::protobuf::internal::TSanWrite(&_impl_);
8290   // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
8291   if ((_impl_._has_bits_[0] & 0x00000008U) == 0) {
8292     return nullptr;
8293   }
8294   _impl_._has_bits_[0] &= ~0x00000008U;
8295   auto* released = _impl_.domain_.Release();
8296   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8297     _impl_.domain_.Set("", GetArena());
8298   }
8299   return released;
8300 }
8301 inline void NodeProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
8302   ::google::protobuf::internal::TSanWrite(&_impl_);
8303   if (value != nullptr) {
8304     _impl_._has_bits_[0] |= 0x00000008U;
8305   } else {
8306     _impl_._has_bits_[0] &= ~0x00000008U;
8307   }
8308   _impl_.domain_.SetAllocated(value, GetArena());
8309   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
8310     _impl_.domain_.Set("", GetArena());
8311   }
8312   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
8313 }
8314 
8315 // optional string overload = 8;
8316 inline bool NodeProto::has_overload() const {
8317   bool value = (_impl_._has_bits_[0] & 0x00000010U) != 0;
8318   return value;
8319 }
8320 inline void NodeProto::clear_overload() {
8321   ::google::protobuf::internal::TSanWrite(&_impl_);
8322   _impl_.overload_.ClearToEmpty();
8323   _impl_._has_bits_[0] &= ~0x00000010U;
8324 }
8325 inline const ::std::string& NodeProto::overload() const
8326     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8327   // @@protoc_insertion_point(field_get:onnx.NodeProto.overload)
8328   return _internal_overload();
8329 }
8330 template <typename Arg_, typename... Args_>
8331 PROTOBUF_ALWAYS_INLINE void NodeProto::set_overload(Arg_&& arg, Args_... args) {
8332   ::google::protobuf::internal::TSanWrite(&_impl_);
8333   _impl_._has_bits_[0] |= 0x00000010U;
8334   _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8335   // @@protoc_insertion_point(field_set:onnx.NodeProto.overload)
8336 }
8337 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_overload()
8338     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8339   ::std::string* _s = _internal_mutable_overload();
8340   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload)
8341   return _s;
8342 }
8343 inline const ::std::string& NodeProto::_internal_overload() const {
8344   ::google::protobuf::internal::TSanRead(&_impl_);
8345   return _impl_.overload_.Get();
8346 }
8347 inline void NodeProto::_internal_set_overload(const ::std::string& value) {
8348   ::google::protobuf::internal::TSanWrite(&_impl_);
8349   _impl_._has_bits_[0] |= 0x00000010U;
8350   _impl_.overload_.Set(value, GetArena());
8351 }
8352 inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_overload() {
8353   ::google::protobuf::internal::TSanWrite(&_impl_);
8354   _impl_._has_bits_[0] |= 0x00000010U;
8355   return _impl_.overload_.Mutable( GetArena());
8356 }
8357 inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_overload() {
8358   ::google::protobuf::internal::TSanWrite(&_impl_);
8359   // @@protoc_insertion_point(field_release:onnx.NodeProto.overload)
8360   if ((_impl_._has_bits_[0] & 0x00000010U) == 0) {
8361     return nullptr;
8362   }
8363   _impl_._has_bits_[0] &= ~0x00000010U;
8364   auto* released = _impl_.overload_.Release();
8365   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8366     _impl_.overload_.Set("", GetArena());
8367   }
8368   return released;
8369 }
8370 inline void NodeProto::set_allocated_overload(::std::string* PROTOBUF_NULLABLE value) {
8371   ::google::protobuf::internal::TSanWrite(&_impl_);
8372   if (value != nullptr) {
8373     _impl_._has_bits_[0] |= 0x00000010U;
8374   } else {
8375     _impl_._has_bits_[0] &= ~0x00000010U;
8376   }
8377   _impl_.overload_.SetAllocated(value, GetArena());
8378   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.overload_.IsDefault()) {
8379     _impl_.overload_.Set("", GetArena());
8380   }
8381   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload)
8382 }
8383 
8384 // repeated .onnx.AttributeProto attribute = 5;
8385 inline int NodeProto::_internal_attribute_size() const {
8386   return _internal_attribute().size();
8387 }
8388 inline int NodeProto::attribute_size() const {
8389   return _internal_attribute_size();
8390 }
8391 inline void NodeProto::clear_attribute() {
8392   ::google::protobuf::internal::TSanWrite(&_impl_);
8393   _impl_.attribute_.Clear();
8394 }
8395 inline ::onnx::AttributeProto* PROTOBUF_NONNULL NodeProto::mutable_attribute(int index)
8396     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8397   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
8398   return _internal_mutable_attribute()->Mutable(index);
8399 }
8400 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL NodeProto::mutable_attribute()
8401     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8402   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
8403   ::google::protobuf::internal::TSanWrite(&_impl_);
8404   return _internal_mutable_attribute();
8405 }
8406 inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const
8407     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8408   // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
8409   return _internal_attribute().Get(index);
8410 }
8411 inline ::onnx::AttributeProto* PROTOBUF_NONNULL NodeProto::add_attribute()
8412     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8413   ::google::protobuf::internal::TSanWrite(&_impl_);
8414   ::onnx::AttributeProto* _add = _internal_mutable_attribute()->Add();
8415   // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
8416   return _add;
8417 }
8418 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& NodeProto::attribute() const
8419     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8420   // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
8421   return _internal_attribute();
8422 }
8423 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
8424 NodeProto::_internal_attribute() const {
8425   ::google::protobuf::internal::TSanRead(&_impl_);
8426   return _impl_.attribute_;
8427 }
8428 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
8429 NodeProto::_internal_mutable_attribute() {
8430   ::google::protobuf::internal::TSanRead(&_impl_);
8431   return &_impl_.attribute_;
8432 }
8433 
8434 // optional string doc_string = 6;
8435 inline bool NodeProto::has_doc_string() const {
8436   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
8437   return value;
8438 }
8439 inline void NodeProto::clear_doc_string() {
8440   ::google::protobuf::internal::TSanWrite(&_impl_);
8441   _impl_.doc_string_.ClearToEmpty();
8442   _impl_._has_bits_[0] &= ~0x00000004U;
8443 }
8444 inline const ::std::string& NodeProto::doc_string() const
8445     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8446   // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
8447   return _internal_doc_string();
8448 }
8449 template <typename Arg_, typename... Args_>
8450 PROTOBUF_ALWAYS_INLINE void NodeProto::set_doc_string(Arg_&& arg, Args_... args) {
8451   ::google::protobuf::internal::TSanWrite(&_impl_);
8452   _impl_._has_bits_[0] |= 0x00000004U;
8453   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8454   // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
8455 }
8456 inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_doc_string()
8457     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8458   ::std::string* _s = _internal_mutable_doc_string();
8459   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
8460   return _s;
8461 }
8462 inline const ::std::string& NodeProto::_internal_doc_string() const {
8463   ::google::protobuf::internal::TSanRead(&_impl_);
8464   return _impl_.doc_string_.Get();
8465 }
8466 inline void NodeProto::_internal_set_doc_string(const ::std::string& value) {
8467   ::google::protobuf::internal::TSanWrite(&_impl_);
8468   _impl_._has_bits_[0] |= 0x00000004U;
8469   _impl_.doc_string_.Set(value, GetArena());
8470 }
8471 inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_doc_string() {
8472   ::google::protobuf::internal::TSanWrite(&_impl_);
8473   _impl_._has_bits_[0] |= 0x00000004U;
8474   return _impl_.doc_string_.Mutable( GetArena());
8475 }
8476 inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_doc_string() {
8477   ::google::protobuf::internal::TSanWrite(&_impl_);
8478   // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
8479   if ((_impl_._has_bits_[0] & 0x00000004U) == 0) {
8480     return nullptr;
8481   }
8482   _impl_._has_bits_[0] &= ~0x00000004U;
8483   auto* released = _impl_.doc_string_.Release();
8484   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8485     _impl_.doc_string_.Set("", GetArena());
8486   }
8487   return released;
8488 }
8489 inline void NodeProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
8490   ::google::protobuf::internal::TSanWrite(&_impl_);
8491   if (value != nullptr) {
8492     _impl_._has_bits_[0] |= 0x00000004U;
8493   } else {
8494     _impl_._has_bits_[0] &= ~0x00000004U;
8495   }
8496   _impl_.doc_string_.SetAllocated(value, GetArena());
8497   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
8498     _impl_.doc_string_.Set("", GetArena());
8499   }
8500   // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
8501 }
8502 
8503 // repeated .onnx.StringStringEntryProto metadata_props = 9;
8504 inline int NodeProto::_internal_metadata_props_size() const {
8505   return _internal_metadata_props().size();
8506 }
8507 inline int NodeProto::metadata_props_size() const {
8508   return _internal_metadata_props_size();
8509 }
8510 inline void NodeProto::clear_metadata_props() {
8511   ::google::protobuf::internal::TSanWrite(&_impl_);
8512   _impl_.metadata_props_.Clear();
8513 }
8514 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL NodeProto::mutable_metadata_props(int index)
8515     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8516   // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props)
8517   return _internal_mutable_metadata_props()->Mutable(index);
8518 }
8519 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL NodeProto::mutable_metadata_props()
8520     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8521   // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props)
8522   ::google::protobuf::internal::TSanWrite(&_impl_);
8523   return _internal_mutable_metadata_props();
8524 }
8525 inline const ::onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const
8526     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8527   // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props)
8528   return _internal_metadata_props().Get(index);
8529 }
8530 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL NodeProto::add_metadata_props()
8531     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8532   ::google::protobuf::internal::TSanWrite(&_impl_);
8533   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
8534   // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props)
8535   return _add;
8536 }
8537 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& NodeProto::metadata_props() const
8538     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8539   // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props)
8540   return _internal_metadata_props();
8541 }
8542 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8543 NodeProto::_internal_metadata_props() const {
8544   ::google::protobuf::internal::TSanRead(&_impl_);
8545   return _impl_.metadata_props_;
8546 }
8547 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
8548 NodeProto::_internal_mutable_metadata_props() {
8549   ::google::protobuf::internal::TSanRead(&_impl_);
8550   return &_impl_.metadata_props_;
8551 }
8552 
8553 // -------------------------------------------------------------------
8554 
8555 // TrainingInfoProto
8556 
8557 // optional .onnx.GraphProto initialization = 1;
8558 inline bool TrainingInfoProto::has_initialization() const {
8559   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
8560   PROTOBUF_ASSUME(!value || _impl_.initialization_ != nullptr);
8561   return value;
8562 }
8563 inline void TrainingInfoProto::clear_initialization() {
8564   ::google::protobuf::internal::TSanWrite(&_impl_);
8565   if (_impl_.initialization_ != nullptr) _impl_.initialization_->Clear();
8566   _impl_._has_bits_[0] &= ~0x00000001U;
8567 }
8568 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
8569   ::google::protobuf::internal::TSanRead(&_impl_);
8570   const ::onnx::GraphProto* p = _impl_.initialization_;
8571   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
8572 }
8573 inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8574   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
8575   return _internal_initialization();
8576 }
8577 inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(
8578     ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
8579   ::google::protobuf::internal::TSanWrite(&_impl_);
8580   if (GetArena() == nullptr) {
8581     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
8582   }
8583   _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
8584   if (value != nullptr) {
8585     _impl_._has_bits_[0] |= 0x00000001U;
8586   } else {
8587     _impl_._has_bits_[0] &= ~0x00000001U;
8588   }
8589   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
8590 }
8591 inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::release_initialization() {
8592   ::google::protobuf::internal::TSanWrite(&_impl_);
8593 
8594   _impl_._has_bits_[0] &= ~0x00000001U;
8595   ::onnx::GraphProto* released = _impl_.initialization_;
8596   _impl_.initialization_ = nullptr;
8597   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
8598     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
8599     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8600     if (GetArena() == nullptr) {
8601       delete old;
8602     }
8603   } else {
8604     if (GetArena() != nullptr) {
8605       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8606     }
8607   }
8608   return released;
8609 }
8610 inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::unsafe_arena_release_initialization() {
8611   ::google::protobuf::internal::TSanWrite(&_impl_);
8612   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)
8613 
8614   _impl_._has_bits_[0] &= ~0x00000001U;
8615   ::onnx::GraphProto* temp = _impl_.initialization_;
8616   _impl_.initialization_ = nullptr;
8617   return temp;
8618 }
8619 inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::_internal_mutable_initialization() {
8620   ::google::protobuf::internal::TSanWrite(&_impl_);
8621   if (_impl_.initialization_ == nullptr) {
8622     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
8623     _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(p);
8624   }
8625   return _impl_.initialization_;
8626 }
8627 inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization()
8628     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8629   _impl_._has_bits_[0] |= 0x00000001U;
8630   ::onnx::GraphProto* _msg = _internal_mutable_initialization();
8631   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
8632   return _msg;
8633 }
8634 inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
8635   ::google::protobuf::Arena* message_arena = GetArena();
8636   ::google::protobuf::internal::TSanWrite(&_impl_);
8637   if (message_arena == nullptr) {
8638     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
8639   }
8640 
8641   if (value != nullptr) {
8642     ::google::protobuf::Arena* submessage_arena = value->GetArena();
8643     if (message_arena != submessage_arena) {
8644       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
8645     }
8646     _impl_._has_bits_[0] |= 0x00000001U;
8647   } else {
8648     _impl_._has_bits_[0] &= ~0x00000001U;
8649   }
8650 
8651   _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
8652   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
8653 }
8654 
8655 // optional .onnx.GraphProto algorithm = 2;
8656 inline bool TrainingInfoProto::has_algorithm() const {
8657   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
8658   PROTOBUF_ASSUME(!value || _impl_.algorithm_ != nullptr);
8659   return value;
8660 }
8661 inline void TrainingInfoProto::clear_algorithm() {
8662   ::google::protobuf::internal::TSanWrite(&_impl_);
8663   if (_impl_.algorithm_ != nullptr) _impl_.algorithm_->Clear();
8664   _impl_._has_bits_[0] &= ~0x00000002U;
8665 }
8666 inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
8667   ::google::protobuf::internal::TSanRead(&_impl_);
8668   const ::onnx::GraphProto* p = _impl_.algorithm_;
8669   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
8670 }
8671 inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
8672   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
8673   return _internal_algorithm();
8674 }
8675 inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(
8676     ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
8677   ::google::protobuf::internal::TSanWrite(&_impl_);
8678   if (GetArena() == nullptr) {
8679     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
8680   }
8681   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
8682   if (value != nullptr) {
8683     _impl_._has_bits_[0] |= 0x00000002U;
8684   } else {
8685     _impl_._has_bits_[0] &= ~0x00000002U;
8686   }
8687   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
8688 }
8689 inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::release_algorithm() {
8690   ::google::protobuf::internal::TSanWrite(&_impl_);
8691 
8692   _impl_._has_bits_[0] &= ~0x00000002U;
8693   ::onnx::GraphProto* released = _impl_.algorithm_;
8694   _impl_.algorithm_ = nullptr;
8695   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
8696     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
8697     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8698     if (GetArena() == nullptr) {
8699       delete old;
8700     }
8701   } else {
8702     if (GetArena() != nullptr) {
8703       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
8704     }
8705   }
8706   return released;
8707 }
8708 inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::unsafe_arena_release_algorithm() {
8709   ::google::protobuf::internal::TSanWrite(&_impl_);
8710   // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)
8711 
8712   _impl_._has_bits_[0] &= ~0x00000002U;
8713   ::onnx::GraphProto* temp = _impl_.algorithm_;
8714   _impl_.algorithm_ = nullptr;
8715   return temp;
8716 }
8717 inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::_internal_mutable_algorithm() {
8718   ::google::protobuf::internal::TSanWrite(&_impl_);
8719   if (_impl_.algorithm_ == nullptr) {
8720     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
8721     _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(p);
8722   }
8723   return _impl_.algorithm_;
8724 }
8725 inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_algorithm()
8726     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8727   _impl_._has_bits_[0] |= 0x00000002U;
8728   ::onnx::GraphProto* _msg = _internal_mutable_algorithm();
8729   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
8730   return _msg;
8731 }
8732 inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
8733   ::google::protobuf::Arena* message_arena = GetArena();
8734   ::google::protobuf::internal::TSanWrite(&_impl_);
8735   if (message_arena == nullptr) {
8736     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
8737   }
8738 
8739   if (value != nullptr) {
8740     ::google::protobuf::Arena* submessage_arena = value->GetArena();
8741     if (message_arena != submessage_arena) {
8742       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
8743     }
8744     _impl_._has_bits_[0] |= 0x00000002U;
8745   } else {
8746     _impl_._has_bits_[0] &= ~0x00000002U;
8747   }
8748 
8749   _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
8750   // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
8751 }
8752 
8753 // repeated .onnx.StringStringEntryProto initialization_binding = 3;
8754 inline int TrainingInfoProto::_internal_initialization_binding_size() const {
8755   return _internal_initialization_binding().size();
8756 }
8757 inline int TrainingInfoProto::initialization_binding_size() const {
8758   return _internal_initialization_binding_size();
8759 }
8760 inline void TrainingInfoProto::clear_initialization_binding() {
8761   ::google::protobuf::internal::TSanWrite(&_impl_);
8762   _impl_.initialization_binding_.Clear();
8763 }
8764 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization_binding(int index)
8765     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8766   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
8767   return _internal_mutable_initialization_binding()->Mutable(index);
8768 }
8769 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization_binding()
8770     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8771   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
8772   ::google::protobuf::internal::TSanWrite(&_impl_);
8773   return _internal_mutable_initialization_binding();
8774 }
8775 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const
8776     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8777   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
8778   return _internal_initialization_binding().Get(index);
8779 }
8780 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::add_initialization_binding()
8781     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8782   ::google::protobuf::internal::TSanWrite(&_impl_);
8783   ::onnx::StringStringEntryProto* _add = _internal_mutable_initialization_binding()->Add();
8784   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
8785   return _add;
8786 }
8787 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::initialization_binding() const
8788     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8789   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
8790   return _internal_initialization_binding();
8791 }
8792 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8793 TrainingInfoProto::_internal_initialization_binding() const {
8794   ::google::protobuf::internal::TSanRead(&_impl_);
8795   return _impl_.initialization_binding_;
8796 }
8797 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
8798 TrainingInfoProto::_internal_mutable_initialization_binding() {
8799   ::google::protobuf::internal::TSanRead(&_impl_);
8800   return &_impl_.initialization_binding_;
8801 }
8802 
8803 // repeated .onnx.StringStringEntryProto update_binding = 4;
8804 inline int TrainingInfoProto::_internal_update_binding_size() const {
8805   return _internal_update_binding().size();
8806 }
8807 inline int TrainingInfoProto::update_binding_size() const {
8808   return _internal_update_binding_size();
8809 }
8810 inline void TrainingInfoProto::clear_update_binding() {
8811   ::google::protobuf::internal::TSanWrite(&_impl_);
8812   _impl_.update_binding_.Clear();
8813 }
8814 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_update_binding(int index)
8815     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8816   // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
8817   return _internal_mutable_update_binding()->Mutable(index);
8818 }
8819 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TrainingInfoProto::mutable_update_binding()
8820     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8821   // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
8822   ::google::protobuf::internal::TSanWrite(&_impl_);
8823   return _internal_mutable_update_binding();
8824 }
8825 inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const
8826     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8827   // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
8828   return _internal_update_binding().Get(index);
8829 }
8830 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::add_update_binding()
8831     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8832   ::google::protobuf::internal::TSanWrite(&_impl_);
8833   ::onnx::StringStringEntryProto* _add = _internal_mutable_update_binding()->Add();
8834   // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
8835   return _add;
8836 }
8837 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::update_binding() const
8838     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8839   // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
8840   return _internal_update_binding();
8841 }
8842 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
8843 TrainingInfoProto::_internal_update_binding() const {
8844   ::google::protobuf::internal::TSanRead(&_impl_);
8845   return _impl_.update_binding_;
8846 }
8847 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
8848 TrainingInfoProto::_internal_mutable_update_binding() {
8849   ::google::protobuf::internal::TSanRead(&_impl_);
8850   return &_impl_.update_binding_;
8851 }
8852 
8853 // -------------------------------------------------------------------
8854 
8855 // ModelProto
8856 
8857 // optional int64 ir_version = 1;
8858 inline bool ModelProto::has_ir_version() const {
8859   bool value = (_impl_._has_bits_[0] & 0x00000020U) != 0;
8860   return value;
8861 }
8862 inline void ModelProto::clear_ir_version() {
8863   ::google::protobuf::internal::TSanWrite(&_impl_);
8864   _impl_.ir_version_ = ::int64_t{0};
8865   _impl_._has_bits_[0] &= ~0x00000020U;
8866 }
8867 inline ::int64_t ModelProto::ir_version() const {
8868   // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
8869   return _internal_ir_version();
8870 }
8871 inline void ModelProto::set_ir_version(::int64_t value) {
8872   _internal_set_ir_version(value);
8873   _impl_._has_bits_[0] |= 0x00000020U;
8874   // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
8875 }
8876 inline ::int64_t ModelProto::_internal_ir_version() const {
8877   ::google::protobuf::internal::TSanRead(&_impl_);
8878   return _impl_.ir_version_;
8879 }
8880 inline void ModelProto::_internal_set_ir_version(::int64_t value) {
8881   ::google::protobuf::internal::TSanWrite(&_impl_);
8882   _impl_.ir_version_ = value;
8883 }
8884 
8885 // repeated .onnx.OperatorSetIdProto opset_import = 8;
8886 inline int ModelProto::_internal_opset_import_size() const {
8887   return _internal_opset_import().size();
8888 }
8889 inline int ModelProto::opset_import_size() const {
8890   return _internal_opset_import_size();
8891 }
8892 inline void ModelProto::clear_opset_import() {
8893   ::google::protobuf::internal::TSanWrite(&_impl_);
8894   _impl_.opset_import_.Clear();
8895 }
8896 inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL ModelProto::mutable_opset_import(int index)
8897     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8898   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
8899   return _internal_mutable_opset_import()->Mutable(index);
8900 }
8901 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL ModelProto::mutable_opset_import()
8902     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8903   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
8904   ::google::protobuf::internal::TSanWrite(&_impl_);
8905   return _internal_mutable_opset_import();
8906 }
8907 inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const
8908     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8909   // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
8910   return _internal_opset_import().Get(index);
8911 }
8912 inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL ModelProto::add_opset_import()
8913     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8914   ::google::protobuf::internal::TSanWrite(&_impl_);
8915   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
8916   // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
8917   return _add;
8918 }
8919 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& ModelProto::opset_import() const
8920     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8921   // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
8922   return _internal_opset_import();
8923 }
8924 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
8925 ModelProto::_internal_opset_import() const {
8926   ::google::protobuf::internal::TSanRead(&_impl_);
8927   return _impl_.opset_import_;
8928 }
8929 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
8930 ModelProto::_internal_mutable_opset_import() {
8931   ::google::protobuf::internal::TSanRead(&_impl_);
8932   return &_impl_.opset_import_;
8933 }
8934 
8935 // optional string producer_name = 2;
8936 inline bool ModelProto::has_producer_name() const {
8937   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
8938   return value;
8939 }
8940 inline void ModelProto::clear_producer_name() {
8941   ::google::protobuf::internal::TSanWrite(&_impl_);
8942   _impl_.producer_name_.ClearToEmpty();
8943   _impl_._has_bits_[0] &= ~0x00000001U;
8944 }
8945 inline const ::std::string& ModelProto::producer_name() const
8946     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8947   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
8948   return _internal_producer_name();
8949 }
8950 template <typename Arg_, typename... Args_>
8951 PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_name(Arg_&& arg, Args_... args) {
8952   ::google::protobuf::internal::TSanWrite(&_impl_);
8953   _impl_._has_bits_[0] |= 0x00000001U;
8954   _impl_.producer_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
8955   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
8956 }
8957 inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_producer_name()
8958     ABSL_ATTRIBUTE_LIFETIME_BOUND {
8959   ::std::string* _s = _internal_mutable_producer_name();
8960   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
8961   return _s;
8962 }
8963 inline const ::std::string& ModelProto::_internal_producer_name() const {
8964   ::google::protobuf::internal::TSanRead(&_impl_);
8965   return _impl_.producer_name_.Get();
8966 }
8967 inline void ModelProto::_internal_set_producer_name(const ::std::string& value) {
8968   ::google::protobuf::internal::TSanWrite(&_impl_);
8969   _impl_._has_bits_[0] |= 0x00000001U;
8970   _impl_.producer_name_.Set(value, GetArena());
8971 }
8972 inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_producer_name() {
8973   ::google::protobuf::internal::TSanWrite(&_impl_);
8974   _impl_._has_bits_[0] |= 0x00000001U;
8975   return _impl_.producer_name_.Mutable( GetArena());
8976 }
8977 inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_producer_name() {
8978   ::google::protobuf::internal::TSanWrite(&_impl_);
8979   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
8980   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
8981     return nullptr;
8982   }
8983   _impl_._has_bits_[0] &= ~0x00000001U;
8984   auto* released = _impl_.producer_name_.Release();
8985   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
8986     _impl_.producer_name_.Set("", GetArena());
8987   }
8988   return released;
8989 }
8990 inline void ModelProto::set_allocated_producer_name(::std::string* PROTOBUF_NULLABLE value) {
8991   ::google::protobuf::internal::TSanWrite(&_impl_);
8992   if (value != nullptr) {
8993     _impl_._has_bits_[0] |= 0x00000001U;
8994   } else {
8995     _impl_._has_bits_[0] &= ~0x00000001U;
8996   }
8997   _impl_.producer_name_.SetAllocated(value, GetArena());
8998   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.producer_name_.IsDefault()) {
8999     _impl_.producer_name_.Set("", GetArena());
9000   }
9001   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
9002 }
9003 
9004 // optional string producer_version = 3;
9005 inline bool ModelProto::has_producer_version() const {
9006   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
9007   return value;
9008 }
9009 inline void ModelProto::clear_producer_version() {
9010   ::google::protobuf::internal::TSanWrite(&_impl_);
9011   _impl_.producer_version_.ClearToEmpty();
9012   _impl_._has_bits_[0] &= ~0x00000002U;
9013 }
9014 inline const ::std::string& ModelProto::producer_version() const
9015     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9016   // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
9017   return _internal_producer_version();
9018 }
9019 template <typename Arg_, typename... Args_>
9020 PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_version(Arg_&& arg, Args_... args) {
9021   ::google::protobuf::internal::TSanWrite(&_impl_);
9022   _impl_._has_bits_[0] |= 0x00000002U;
9023   _impl_.producer_version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9024   // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
9025 }
9026 inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_producer_version()
9027     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9028   ::std::string* _s = _internal_mutable_producer_version();
9029   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
9030   return _s;
9031 }
9032 inline const ::std::string& ModelProto::_internal_producer_version() const {
9033   ::google::protobuf::internal::TSanRead(&_impl_);
9034   return _impl_.producer_version_.Get();
9035 }
9036 inline void ModelProto::_internal_set_producer_version(const ::std::string& value) {
9037   ::google::protobuf::internal::TSanWrite(&_impl_);
9038   _impl_._has_bits_[0] |= 0x00000002U;
9039   _impl_.producer_version_.Set(value, GetArena());
9040 }
9041 inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_producer_version() {
9042   ::google::protobuf::internal::TSanWrite(&_impl_);
9043   _impl_._has_bits_[0] |= 0x00000002U;
9044   return _impl_.producer_version_.Mutable( GetArena());
9045 }
9046 inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_producer_version() {
9047   ::google::protobuf::internal::TSanWrite(&_impl_);
9048   // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
9049   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
9050     return nullptr;
9051   }
9052   _impl_._has_bits_[0] &= ~0x00000002U;
9053   auto* released = _impl_.producer_version_.Release();
9054   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9055     _impl_.producer_version_.Set("", GetArena());
9056   }
9057   return released;
9058 }
9059 inline void ModelProto::set_allocated_producer_version(::std::string* PROTOBUF_NULLABLE value) {
9060   ::google::protobuf::internal::TSanWrite(&_impl_);
9061   if (value != nullptr) {
9062     _impl_._has_bits_[0] |= 0x00000002U;
9063   } else {
9064     _impl_._has_bits_[0] &= ~0x00000002U;
9065   }
9066   _impl_.producer_version_.SetAllocated(value, GetArena());
9067   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.producer_version_.IsDefault()) {
9068     _impl_.producer_version_.Set("", GetArena());
9069   }
9070   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
9071 }
9072 
9073 // optional string domain = 4;
9074 inline bool ModelProto::has_domain() const {
9075   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
9076   return value;
9077 }
9078 inline void ModelProto::clear_domain() {
9079   ::google::protobuf::internal::TSanWrite(&_impl_);
9080   _impl_.domain_.ClearToEmpty();
9081   _impl_._has_bits_[0] &= ~0x00000004U;
9082 }
9083 inline const ::std::string& ModelProto::domain() const
9084     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9085   // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
9086   return _internal_domain();
9087 }
9088 template <typename Arg_, typename... Args_>
9089 PROTOBUF_ALWAYS_INLINE void ModelProto::set_domain(Arg_&& arg, Args_... args) {
9090   ::google::protobuf::internal::TSanWrite(&_impl_);
9091   _impl_._has_bits_[0] |= 0x00000004U;
9092   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9093   // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
9094 }
9095 inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_domain()
9096     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9097   ::std::string* _s = _internal_mutable_domain();
9098   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
9099   return _s;
9100 }
9101 inline const ::std::string& ModelProto::_internal_domain() const {
9102   ::google::protobuf::internal::TSanRead(&_impl_);
9103   return _impl_.domain_.Get();
9104 }
9105 inline void ModelProto::_internal_set_domain(const ::std::string& value) {
9106   ::google::protobuf::internal::TSanWrite(&_impl_);
9107   _impl_._has_bits_[0] |= 0x00000004U;
9108   _impl_.domain_.Set(value, GetArena());
9109 }
9110 inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_domain() {
9111   ::google::protobuf::internal::TSanWrite(&_impl_);
9112   _impl_._has_bits_[0] |= 0x00000004U;
9113   return _impl_.domain_.Mutable( GetArena());
9114 }
9115 inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_domain() {
9116   ::google::protobuf::internal::TSanWrite(&_impl_);
9117   // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
9118   if ((_impl_._has_bits_[0] & 0x00000004U) == 0) {
9119     return nullptr;
9120   }
9121   _impl_._has_bits_[0] &= ~0x00000004U;
9122   auto* released = _impl_.domain_.Release();
9123   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9124     _impl_.domain_.Set("", GetArena());
9125   }
9126   return released;
9127 }
9128 inline void ModelProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
9129   ::google::protobuf::internal::TSanWrite(&_impl_);
9130   if (value != nullptr) {
9131     _impl_._has_bits_[0] |= 0x00000004U;
9132   } else {
9133     _impl_._has_bits_[0] &= ~0x00000004U;
9134   }
9135   _impl_.domain_.SetAllocated(value, GetArena());
9136   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
9137     _impl_.domain_.Set("", GetArena());
9138   }
9139   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
9140 }
9141 
9142 // optional int64 model_version = 5;
9143 inline bool ModelProto::has_model_version() const {
9144   bool value = (_impl_._has_bits_[0] & 0x00000040U) != 0;
9145   return value;
9146 }
9147 inline void ModelProto::clear_model_version() {
9148   ::google::protobuf::internal::TSanWrite(&_impl_);
9149   _impl_.model_version_ = ::int64_t{0};
9150   _impl_._has_bits_[0] &= ~0x00000040U;
9151 }
9152 inline ::int64_t ModelProto::model_version() const {
9153   // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
9154   return _internal_model_version();
9155 }
9156 inline void ModelProto::set_model_version(::int64_t value) {
9157   _internal_set_model_version(value);
9158   _impl_._has_bits_[0] |= 0x00000040U;
9159   // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
9160 }
9161 inline ::int64_t ModelProto::_internal_model_version() const {
9162   ::google::protobuf::internal::TSanRead(&_impl_);
9163   return _impl_.model_version_;
9164 }
9165 inline void ModelProto::_internal_set_model_version(::int64_t value) {
9166   ::google::protobuf::internal::TSanWrite(&_impl_);
9167   _impl_.model_version_ = value;
9168 }
9169 
9170 // optional string doc_string = 6;
9171 inline bool ModelProto::has_doc_string() const {
9172   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
9173   return value;
9174 }
9175 inline void ModelProto::clear_doc_string() {
9176   ::google::protobuf::internal::TSanWrite(&_impl_);
9177   _impl_.doc_string_.ClearToEmpty();
9178   _impl_._has_bits_[0] &= ~0x00000008U;
9179 }
9180 inline const ::std::string& ModelProto::doc_string() const
9181     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9182   // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
9183   return _internal_doc_string();
9184 }
9185 template <typename Arg_, typename... Args_>
9186 PROTOBUF_ALWAYS_INLINE void ModelProto::set_doc_string(Arg_&& arg, Args_... args) {
9187   ::google::protobuf::internal::TSanWrite(&_impl_);
9188   _impl_._has_bits_[0] |= 0x00000008U;
9189   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9190   // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
9191 }
9192 inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_doc_string()
9193     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9194   ::std::string* _s = _internal_mutable_doc_string();
9195   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
9196   return _s;
9197 }
9198 inline const ::std::string& ModelProto::_internal_doc_string() const {
9199   ::google::protobuf::internal::TSanRead(&_impl_);
9200   return _impl_.doc_string_.Get();
9201 }
9202 inline void ModelProto::_internal_set_doc_string(const ::std::string& value) {
9203   ::google::protobuf::internal::TSanWrite(&_impl_);
9204   _impl_._has_bits_[0] |= 0x00000008U;
9205   _impl_.doc_string_.Set(value, GetArena());
9206 }
9207 inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_doc_string() {
9208   ::google::protobuf::internal::TSanWrite(&_impl_);
9209   _impl_._has_bits_[0] |= 0x00000008U;
9210   return _impl_.doc_string_.Mutable( GetArena());
9211 }
9212 inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_doc_string() {
9213   ::google::protobuf::internal::TSanWrite(&_impl_);
9214   // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
9215   if ((_impl_._has_bits_[0] & 0x00000008U) == 0) {
9216     return nullptr;
9217   }
9218   _impl_._has_bits_[0] &= ~0x00000008U;
9219   auto* released = _impl_.doc_string_.Release();
9220   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9221     _impl_.doc_string_.Set("", GetArena());
9222   }
9223   return released;
9224 }
9225 inline void ModelProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
9226   ::google::protobuf::internal::TSanWrite(&_impl_);
9227   if (value != nullptr) {
9228     _impl_._has_bits_[0] |= 0x00000008U;
9229   } else {
9230     _impl_._has_bits_[0] &= ~0x00000008U;
9231   }
9232   _impl_.doc_string_.SetAllocated(value, GetArena());
9233   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
9234     _impl_.doc_string_.Set("", GetArena());
9235   }
9236   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
9237 }
9238 
9239 // optional .onnx.GraphProto graph = 7;
9240 inline bool ModelProto::has_graph() const {
9241   bool value = (_impl_._has_bits_[0] & 0x00000010U) != 0;
9242   PROTOBUF_ASSUME(!value || _impl_.graph_ != nullptr);
9243   return value;
9244 }
9245 inline void ModelProto::clear_graph() {
9246   ::google::protobuf::internal::TSanWrite(&_impl_);
9247   if (_impl_.graph_ != nullptr) _impl_.graph_->Clear();
9248   _impl_._has_bits_[0] &= ~0x00000010U;
9249 }
9250 inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
9251   ::google::protobuf::internal::TSanRead(&_impl_);
9252   const ::onnx::GraphProto* p = _impl_.graph_;
9253   return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
9254 }
9255 inline const ::onnx::GraphProto& ModelProto::graph() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
9256   // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
9257   return _internal_graph();
9258 }
9259 inline void ModelProto::unsafe_arena_set_allocated_graph(
9260     ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
9261   ::google::protobuf::internal::TSanWrite(&_impl_);
9262   if (GetArena() == nullptr) {
9263     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
9264   }
9265   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
9266   if (value != nullptr) {
9267     _impl_._has_bits_[0] |= 0x00000010U;
9268   } else {
9269     _impl_._has_bits_[0] &= ~0x00000010U;
9270   }
9271   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
9272 }
9273 inline ::onnx::GraphProto* PROTOBUF_NULLABLE ModelProto::release_graph() {
9274   ::google::protobuf::internal::TSanWrite(&_impl_);
9275 
9276   _impl_._has_bits_[0] &= ~0x00000010U;
9277   ::onnx::GraphProto* released = _impl_.graph_;
9278   _impl_.graph_ = nullptr;
9279   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
9280     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
9281     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
9282     if (GetArena() == nullptr) {
9283       delete old;
9284     }
9285   } else {
9286     if (GetArena() != nullptr) {
9287       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
9288     }
9289   }
9290   return released;
9291 }
9292 inline ::onnx::GraphProto* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_graph() {
9293   ::google::protobuf::internal::TSanWrite(&_impl_);
9294   // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)
9295 
9296   _impl_._has_bits_[0] &= ~0x00000010U;
9297   ::onnx::GraphProto* temp = _impl_.graph_;
9298   _impl_.graph_ = nullptr;
9299   return temp;
9300 }
9301 inline ::onnx::GraphProto* PROTOBUF_NONNULL ModelProto::_internal_mutable_graph() {
9302   ::google::protobuf::internal::TSanWrite(&_impl_);
9303   if (_impl_.graph_ == nullptr) {
9304     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
9305     _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(p);
9306   }
9307   return _impl_.graph_;
9308 }
9309 inline ::onnx::GraphProto* PROTOBUF_NONNULL ModelProto::mutable_graph()
9310     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9311   _impl_._has_bits_[0] |= 0x00000010U;
9312   ::onnx::GraphProto* _msg = _internal_mutable_graph();
9313   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
9314   return _msg;
9315 }
9316 inline void ModelProto::set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
9317   ::google::protobuf::Arena* message_arena = GetArena();
9318   ::google::protobuf::internal::TSanWrite(&_impl_);
9319   if (message_arena == nullptr) {
9320     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
9321   }
9322 
9323   if (value != nullptr) {
9324     ::google::protobuf::Arena* submessage_arena = value->GetArena();
9325     if (message_arena != submessage_arena) {
9326       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
9327     }
9328     _impl_._has_bits_[0] |= 0x00000010U;
9329   } else {
9330     _impl_._has_bits_[0] &= ~0x00000010U;
9331   }
9332 
9333   _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
9334   // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
9335 }
9336 
9337 // repeated .onnx.StringStringEntryProto metadata_props = 14;
9338 inline int ModelProto::_internal_metadata_props_size() const {
9339   return _internal_metadata_props().size();
9340 }
9341 inline int ModelProto::metadata_props_size() const {
9342   return _internal_metadata_props_size();
9343 }
9344 inline void ModelProto::clear_metadata_props() {
9345   ::google::protobuf::internal::TSanWrite(&_impl_);
9346   _impl_.metadata_props_.Clear();
9347 }
9348 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ModelProto::mutable_metadata_props(int index)
9349     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9350   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
9351   return _internal_mutable_metadata_props()->Mutable(index);
9352 }
9353 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL ModelProto::mutable_metadata_props()
9354     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9355   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
9356   ::google::protobuf::internal::TSanWrite(&_impl_);
9357   return _internal_mutable_metadata_props();
9358 }
9359 inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const
9360     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9361   // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
9362   return _internal_metadata_props().Get(index);
9363 }
9364 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ModelProto::add_metadata_props()
9365     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9366   ::google::protobuf::internal::TSanWrite(&_impl_);
9367   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
9368   // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
9369   return _add;
9370 }
9371 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ModelProto::metadata_props() const
9372     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9373   // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
9374   return _internal_metadata_props();
9375 }
9376 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
9377 ModelProto::_internal_metadata_props() const {
9378   ::google::protobuf::internal::TSanRead(&_impl_);
9379   return _impl_.metadata_props_;
9380 }
9381 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
9382 ModelProto::_internal_mutable_metadata_props() {
9383   ::google::protobuf::internal::TSanRead(&_impl_);
9384   return &_impl_.metadata_props_;
9385 }
9386 
9387 // repeated .onnx.TrainingInfoProto training_info = 20;
9388 inline int ModelProto::_internal_training_info_size() const {
9389   return _internal_training_info().size();
9390 }
9391 inline int ModelProto::training_info_size() const {
9392   return _internal_training_info_size();
9393 }
9394 inline void ModelProto::clear_training_info() {
9395   ::google::protobuf::internal::TSanWrite(&_impl_);
9396   _impl_.training_info_.Clear();
9397 }
9398 inline ::onnx::TrainingInfoProto* PROTOBUF_NONNULL ModelProto::mutable_training_info(int index)
9399     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9400   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
9401   return _internal_mutable_training_info()->Mutable(index);
9402 }
9403 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL ModelProto::mutable_training_info()
9404     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9405   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
9406   ::google::protobuf::internal::TSanWrite(&_impl_);
9407   return _internal_mutable_training_info();
9408 }
9409 inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const
9410     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9411   // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
9412   return _internal_training_info().Get(index);
9413 }
9414 inline ::onnx::TrainingInfoProto* PROTOBUF_NONNULL ModelProto::add_training_info()
9415     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9416   ::google::protobuf::internal::TSanWrite(&_impl_);
9417   ::onnx::TrainingInfoProto* _add = _internal_mutable_training_info()->Add();
9418   // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
9419   return _add;
9420 }
9421 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& ModelProto::training_info() const
9422     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9423   // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
9424   return _internal_training_info();
9425 }
9426 inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>&
9427 ModelProto::_internal_training_info() const {
9428   ::google::protobuf::internal::TSanRead(&_impl_);
9429   return _impl_.training_info_;
9430 }
9431 inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL
9432 ModelProto::_internal_mutable_training_info() {
9433   ::google::protobuf::internal::TSanRead(&_impl_);
9434   return &_impl_.training_info_;
9435 }
9436 
9437 // repeated .onnx.FunctionProto functions = 25;
9438 inline int ModelProto::_internal_functions_size() const {
9439   return _internal_functions().size();
9440 }
9441 inline int ModelProto::functions_size() const {
9442   return _internal_functions_size();
9443 }
9444 inline void ModelProto::clear_functions() {
9445   ::google::protobuf::internal::TSanWrite(&_impl_);
9446   _impl_.functions_.Clear();
9447 }
9448 inline ::onnx::FunctionProto* PROTOBUF_NONNULL ModelProto::mutable_functions(int index)
9449     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9450   // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
9451   return _internal_mutable_functions()->Mutable(index);
9452 }
9453 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL ModelProto::mutable_functions()
9454     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9455   // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
9456   ::google::protobuf::internal::TSanWrite(&_impl_);
9457   return _internal_mutable_functions();
9458 }
9459 inline const ::onnx::FunctionProto& ModelProto::functions(int index) const
9460     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9461   // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
9462   return _internal_functions().Get(index);
9463 }
9464 inline ::onnx::FunctionProto* PROTOBUF_NONNULL ModelProto::add_functions()
9465     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9466   ::google::protobuf::internal::TSanWrite(&_impl_);
9467   ::onnx::FunctionProto* _add = _internal_mutable_functions()->Add();
9468   // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
9469   return _add;
9470 }
9471 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& ModelProto::functions() const
9472     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9473   // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
9474   return _internal_functions();
9475 }
9476 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>&
9477 ModelProto::_internal_functions() const {
9478   ::google::protobuf::internal::TSanRead(&_impl_);
9479   return _impl_.functions_;
9480 }
9481 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL
9482 ModelProto::_internal_mutable_functions() {
9483   ::google::protobuf::internal::TSanRead(&_impl_);
9484   return &_impl_.functions_;
9485 }
9486 
9487 // -------------------------------------------------------------------
9488 
9489 // StringStringEntryProto
9490 
9491 // optional string key = 1;
9492 inline bool StringStringEntryProto::has_key() const {
9493   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
9494   return value;
9495 }
9496 inline void StringStringEntryProto::clear_key() {
9497   ::google::protobuf::internal::TSanWrite(&_impl_);
9498   _impl_.key_.ClearToEmpty();
9499   _impl_._has_bits_[0] &= ~0x00000001U;
9500 }
9501 inline const ::std::string& StringStringEntryProto::key() const
9502     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9503   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
9504   return _internal_key();
9505 }
9506 template <typename Arg_, typename... Args_>
9507 PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_key(Arg_&& arg, Args_... args) {
9508   ::google::protobuf::internal::TSanWrite(&_impl_);
9509   _impl_._has_bits_[0] |= 0x00000001U;
9510   _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9511   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
9512 }
9513 inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::mutable_key()
9514     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9515   ::std::string* _s = _internal_mutable_key();
9516   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
9517   return _s;
9518 }
9519 inline const ::std::string& StringStringEntryProto::_internal_key() const {
9520   ::google::protobuf::internal::TSanRead(&_impl_);
9521   return _impl_.key_.Get();
9522 }
9523 inline void StringStringEntryProto::_internal_set_key(const ::std::string& value) {
9524   ::google::protobuf::internal::TSanWrite(&_impl_);
9525   _impl_._has_bits_[0] |= 0x00000001U;
9526   _impl_.key_.Set(value, GetArena());
9527 }
9528 inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::_internal_mutable_key() {
9529   ::google::protobuf::internal::TSanWrite(&_impl_);
9530   _impl_._has_bits_[0] |= 0x00000001U;
9531   return _impl_.key_.Mutable( GetArena());
9532 }
9533 inline ::std::string* PROTOBUF_NULLABLE StringStringEntryProto::release_key() {
9534   ::google::protobuf::internal::TSanWrite(&_impl_);
9535   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
9536   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
9537     return nullptr;
9538   }
9539   _impl_._has_bits_[0] &= ~0x00000001U;
9540   auto* released = _impl_.key_.Release();
9541   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9542     _impl_.key_.Set("", GetArena());
9543   }
9544   return released;
9545 }
9546 inline void StringStringEntryProto::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) {
9547   ::google::protobuf::internal::TSanWrite(&_impl_);
9548   if (value != nullptr) {
9549     _impl_._has_bits_[0] |= 0x00000001U;
9550   } else {
9551     _impl_._has_bits_[0] &= ~0x00000001U;
9552   }
9553   _impl_.key_.SetAllocated(value, GetArena());
9554   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) {
9555     _impl_.key_.Set("", GetArena());
9556   }
9557   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
9558 }
9559 
9560 // optional string value = 2;
9561 inline bool StringStringEntryProto::has_value() const {
9562   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
9563   return value;
9564 }
9565 inline void StringStringEntryProto::clear_value() {
9566   ::google::protobuf::internal::TSanWrite(&_impl_);
9567   _impl_.value_.ClearToEmpty();
9568   _impl_._has_bits_[0] &= ~0x00000002U;
9569 }
9570 inline const ::std::string& StringStringEntryProto::value() const
9571     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9572   // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
9573   return _internal_value();
9574 }
9575 template <typename Arg_, typename... Args_>
9576 PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_value(Arg_&& arg, Args_... args) {
9577   ::google::protobuf::internal::TSanWrite(&_impl_);
9578   _impl_._has_bits_[0] |= 0x00000002U;
9579   _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9580   // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
9581 }
9582 inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::mutable_value()
9583     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9584   ::std::string* _s = _internal_mutable_value();
9585   // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
9586   return _s;
9587 }
9588 inline const ::std::string& StringStringEntryProto::_internal_value() const {
9589   ::google::protobuf::internal::TSanRead(&_impl_);
9590   return _impl_.value_.Get();
9591 }
9592 inline void StringStringEntryProto::_internal_set_value(const ::std::string& value) {
9593   ::google::protobuf::internal::TSanWrite(&_impl_);
9594   _impl_._has_bits_[0] |= 0x00000002U;
9595   _impl_.value_.Set(value, GetArena());
9596 }
9597 inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::_internal_mutable_value() {
9598   ::google::protobuf::internal::TSanWrite(&_impl_);
9599   _impl_._has_bits_[0] |= 0x00000002U;
9600   return _impl_.value_.Mutable( GetArena());
9601 }
9602 inline ::std::string* PROTOBUF_NULLABLE StringStringEntryProto::release_value() {
9603   ::google::protobuf::internal::TSanWrite(&_impl_);
9604   // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
9605   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
9606     return nullptr;
9607   }
9608   _impl_._has_bits_[0] &= ~0x00000002U;
9609   auto* released = _impl_.value_.Release();
9610   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9611     _impl_.value_.Set("", GetArena());
9612   }
9613   return released;
9614 }
9615 inline void StringStringEntryProto::set_allocated_value(::std::string* PROTOBUF_NULLABLE value) {
9616   ::google::protobuf::internal::TSanWrite(&_impl_);
9617   if (value != nullptr) {
9618     _impl_._has_bits_[0] |= 0x00000002U;
9619   } else {
9620     _impl_._has_bits_[0] &= ~0x00000002U;
9621   }
9622   _impl_.value_.SetAllocated(value, GetArena());
9623   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_.IsDefault()) {
9624     _impl_.value_.Set("", GetArena());
9625   }
9626   // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
9627 }
9628 
9629 // -------------------------------------------------------------------
9630 
9631 // TensorAnnotation
9632 
9633 // optional string tensor_name = 1;
9634 inline bool TensorAnnotation::has_tensor_name() const {
9635   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
9636   return value;
9637 }
9638 inline void TensorAnnotation::clear_tensor_name() {
9639   ::google::protobuf::internal::TSanWrite(&_impl_);
9640   _impl_.tensor_name_.ClearToEmpty();
9641   _impl_._has_bits_[0] &= ~0x00000001U;
9642 }
9643 inline const ::std::string& TensorAnnotation::tensor_name() const
9644     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9645   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
9646   return _internal_tensor_name();
9647 }
9648 template <typename Arg_, typename... Args_>
9649 PROTOBUF_ALWAYS_INLINE void TensorAnnotation::set_tensor_name(Arg_&& arg, Args_... args) {
9650   ::google::protobuf::internal::TSanWrite(&_impl_);
9651   _impl_._has_bits_[0] |= 0x00000001U;
9652   _impl_.tensor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9653   // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
9654 }
9655 inline ::std::string* PROTOBUF_NONNULL TensorAnnotation::mutable_tensor_name()
9656     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9657   ::std::string* _s = _internal_mutable_tensor_name();
9658   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
9659   return _s;
9660 }
9661 inline const ::std::string& TensorAnnotation::_internal_tensor_name() const {
9662   ::google::protobuf::internal::TSanRead(&_impl_);
9663   return _impl_.tensor_name_.Get();
9664 }
9665 inline void TensorAnnotation::_internal_set_tensor_name(const ::std::string& value) {
9666   ::google::protobuf::internal::TSanWrite(&_impl_);
9667   _impl_._has_bits_[0] |= 0x00000001U;
9668   _impl_.tensor_name_.Set(value, GetArena());
9669 }
9670 inline ::std::string* PROTOBUF_NONNULL TensorAnnotation::_internal_mutable_tensor_name() {
9671   ::google::protobuf::internal::TSanWrite(&_impl_);
9672   _impl_._has_bits_[0] |= 0x00000001U;
9673   return _impl_.tensor_name_.Mutable( GetArena());
9674 }
9675 inline ::std::string* PROTOBUF_NULLABLE TensorAnnotation::release_tensor_name() {
9676   ::google::protobuf::internal::TSanWrite(&_impl_);
9677   // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
9678   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
9679     return nullptr;
9680   }
9681   _impl_._has_bits_[0] &= ~0x00000001U;
9682   auto* released = _impl_.tensor_name_.Release();
9683   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9684     _impl_.tensor_name_.Set("", GetArena());
9685   }
9686   return released;
9687 }
9688 inline void TensorAnnotation::set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value) {
9689   ::google::protobuf::internal::TSanWrite(&_impl_);
9690   if (value != nullptr) {
9691     _impl_._has_bits_[0] |= 0x00000001U;
9692   } else {
9693     _impl_._has_bits_[0] &= ~0x00000001U;
9694   }
9695   _impl_.tensor_name_.SetAllocated(value, GetArena());
9696   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tensor_name_.IsDefault()) {
9697     _impl_.tensor_name_.Set("", GetArena());
9698   }
9699   // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
9700 }
9701 
9702 // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
9703 inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
9704   return _internal_quant_parameter_tensor_names().size();
9705 }
9706 inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
9707   return _internal_quant_parameter_tensor_names_size();
9708 }
9709 inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
9710   ::google::protobuf::internal::TSanWrite(&_impl_);
9711   _impl_.quant_parameter_tensor_names_.Clear();
9712 }
9713 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorAnnotation::mutable_quant_parameter_tensor_names(int index)
9714     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9715   // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
9716   return _internal_mutable_quant_parameter_tensor_names()->Mutable(index);
9717 }
9718 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorAnnotation::mutable_quant_parameter_tensor_names()
9719     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9720   // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
9721   ::google::protobuf::internal::TSanWrite(&_impl_);
9722   return _internal_mutable_quant_parameter_tensor_names();
9723 }
9724 inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const
9725     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9726   // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
9727   return _internal_quant_parameter_tensor_names().Get(index);
9728 }
9729 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorAnnotation::add_quant_parameter_tensor_names()
9730     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9731   ::google::protobuf::internal::TSanWrite(&_impl_);
9732   ::onnx::StringStringEntryProto* _add = _internal_mutable_quant_parameter_tensor_names()->Add();
9733   // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
9734   return _add;
9735 }
9736 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorAnnotation::quant_parameter_tensor_names() const
9737     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9738   // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
9739   return _internal_quant_parameter_tensor_names();
9740 }
9741 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
9742 TensorAnnotation::_internal_quant_parameter_tensor_names() const {
9743   ::google::protobuf::internal::TSanRead(&_impl_);
9744   return _impl_.quant_parameter_tensor_names_;
9745 }
9746 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
9747 TensorAnnotation::_internal_mutable_quant_parameter_tensor_names() {
9748   ::google::protobuf::internal::TSanRead(&_impl_);
9749   return &_impl_.quant_parameter_tensor_names_;
9750 }
9751 
9752 // -------------------------------------------------------------------
9753 
9754 // GraphProto
9755 
9756 // repeated .onnx.NodeProto node = 1;
9757 inline int GraphProto::_internal_node_size() const {
9758   return _internal_node().size();
9759 }
9760 inline int GraphProto::node_size() const {
9761   return _internal_node_size();
9762 }
9763 inline void GraphProto::clear_node() {
9764   ::google::protobuf::internal::TSanWrite(&_impl_);
9765   _impl_.node_.Clear();
9766 }
9767 inline ::onnx::NodeProto* PROTOBUF_NONNULL GraphProto::mutable_node(int index)
9768     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9769   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
9770   return _internal_mutable_node()->Mutable(index);
9771 }
9772 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL GraphProto::mutable_node()
9773     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9774   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
9775   ::google::protobuf::internal::TSanWrite(&_impl_);
9776   return _internal_mutable_node();
9777 }
9778 inline const ::onnx::NodeProto& GraphProto::node(int index) const
9779     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9780   // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
9781   return _internal_node().Get(index);
9782 }
9783 inline ::onnx::NodeProto* PROTOBUF_NONNULL GraphProto::add_node()
9784     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9785   ::google::protobuf::internal::TSanWrite(&_impl_);
9786   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
9787   // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
9788   return _add;
9789 }
9790 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& GraphProto::node() const
9791     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9792   // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
9793   return _internal_node();
9794 }
9795 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
9796 GraphProto::_internal_node() const {
9797   ::google::protobuf::internal::TSanRead(&_impl_);
9798   return _impl_.node_;
9799 }
9800 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
9801 GraphProto::_internal_mutable_node() {
9802   ::google::protobuf::internal::TSanRead(&_impl_);
9803   return &_impl_.node_;
9804 }
9805 
9806 // optional string name = 2;
9807 inline bool GraphProto::has_name() const {
9808   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
9809   return value;
9810 }
9811 inline void GraphProto::clear_name() {
9812   ::google::protobuf::internal::TSanWrite(&_impl_);
9813   _impl_.name_.ClearToEmpty();
9814   _impl_._has_bits_[0] &= ~0x00000001U;
9815 }
9816 inline const ::std::string& GraphProto::name() const
9817     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9818   // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
9819   return _internal_name();
9820 }
9821 template <typename Arg_, typename... Args_>
9822 PROTOBUF_ALWAYS_INLINE void GraphProto::set_name(Arg_&& arg, Args_... args) {
9823   ::google::protobuf::internal::TSanWrite(&_impl_);
9824   _impl_._has_bits_[0] |= 0x00000001U;
9825   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9826   // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
9827 }
9828 inline ::std::string* PROTOBUF_NONNULL GraphProto::mutable_name()
9829     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9830   ::std::string* _s = _internal_mutable_name();
9831   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
9832   return _s;
9833 }
9834 inline const ::std::string& GraphProto::_internal_name() const {
9835   ::google::protobuf::internal::TSanRead(&_impl_);
9836   return _impl_.name_.Get();
9837 }
9838 inline void GraphProto::_internal_set_name(const ::std::string& value) {
9839   ::google::protobuf::internal::TSanWrite(&_impl_);
9840   _impl_._has_bits_[0] |= 0x00000001U;
9841   _impl_.name_.Set(value, GetArena());
9842 }
9843 inline ::std::string* PROTOBUF_NONNULL GraphProto::_internal_mutable_name() {
9844   ::google::protobuf::internal::TSanWrite(&_impl_);
9845   _impl_._has_bits_[0] |= 0x00000001U;
9846   return _impl_.name_.Mutable( GetArena());
9847 }
9848 inline ::std::string* PROTOBUF_NULLABLE GraphProto::release_name() {
9849   ::google::protobuf::internal::TSanWrite(&_impl_);
9850   // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
9851   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
9852     return nullptr;
9853   }
9854   _impl_._has_bits_[0] &= ~0x00000001U;
9855   auto* released = _impl_.name_.Release();
9856   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
9857     _impl_.name_.Set("", GetArena());
9858   }
9859   return released;
9860 }
9861 inline void GraphProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
9862   ::google::protobuf::internal::TSanWrite(&_impl_);
9863   if (value != nullptr) {
9864     _impl_._has_bits_[0] |= 0x00000001U;
9865   } else {
9866     _impl_._has_bits_[0] &= ~0x00000001U;
9867   }
9868   _impl_.name_.SetAllocated(value, GetArena());
9869   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
9870     _impl_.name_.Set("", GetArena());
9871   }
9872   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
9873 }
9874 
9875 // repeated .onnx.TensorProto initializer = 5;
9876 inline int GraphProto::_internal_initializer_size() const {
9877   return _internal_initializer().size();
9878 }
9879 inline int GraphProto::initializer_size() const {
9880   return _internal_initializer_size();
9881 }
9882 inline void GraphProto::clear_initializer() {
9883   ::google::protobuf::internal::TSanWrite(&_impl_);
9884   _impl_.initializer_.Clear();
9885 }
9886 inline ::onnx::TensorProto* PROTOBUF_NONNULL GraphProto::mutable_initializer(int index)
9887     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9888   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
9889   return _internal_mutable_initializer()->Mutable(index);
9890 }
9891 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL GraphProto::mutable_initializer()
9892     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9893   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
9894   ::google::protobuf::internal::TSanWrite(&_impl_);
9895   return _internal_mutable_initializer();
9896 }
9897 inline const ::onnx::TensorProto& GraphProto::initializer(int index) const
9898     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9899   // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
9900   return _internal_initializer().Get(index);
9901 }
9902 inline ::onnx::TensorProto* PROTOBUF_NONNULL GraphProto::add_initializer()
9903     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9904   ::google::protobuf::internal::TSanWrite(&_impl_);
9905   ::onnx::TensorProto* _add = _internal_mutable_initializer()->Add();
9906   // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
9907   return _add;
9908 }
9909 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& GraphProto::initializer() const
9910     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9911   // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
9912   return _internal_initializer();
9913 }
9914 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
9915 GraphProto::_internal_initializer() const {
9916   ::google::protobuf::internal::TSanRead(&_impl_);
9917   return _impl_.initializer_;
9918 }
9919 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
9920 GraphProto::_internal_mutable_initializer() {
9921   ::google::protobuf::internal::TSanRead(&_impl_);
9922   return &_impl_.initializer_;
9923 }
9924 
9925 // repeated .onnx.SparseTensorProto sparse_initializer = 15;
9926 inline int GraphProto::_internal_sparse_initializer_size() const {
9927   return _internal_sparse_initializer().size();
9928 }
9929 inline int GraphProto::sparse_initializer_size() const {
9930   return _internal_sparse_initializer_size();
9931 }
9932 inline void GraphProto::clear_sparse_initializer() {
9933   ::google::protobuf::internal::TSanWrite(&_impl_);
9934   _impl_.sparse_initializer_.Clear();
9935 }
9936 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL GraphProto::mutable_sparse_initializer(int index)
9937     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9938   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
9939   return _internal_mutable_sparse_initializer()->Mutable(index);
9940 }
9941 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL GraphProto::mutable_sparse_initializer()
9942     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9943   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
9944   ::google::protobuf::internal::TSanWrite(&_impl_);
9945   return _internal_mutable_sparse_initializer();
9946 }
9947 inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const
9948     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9949   // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
9950   return _internal_sparse_initializer().Get(index);
9951 }
9952 inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL GraphProto::add_sparse_initializer()
9953     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9954   ::google::protobuf::internal::TSanWrite(&_impl_);
9955   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_initializer()->Add();
9956   // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
9957   return _add;
9958 }
9959 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& GraphProto::sparse_initializer() const
9960     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9961   // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
9962   return _internal_sparse_initializer();
9963 }
9964 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
9965 GraphProto::_internal_sparse_initializer() const {
9966   ::google::protobuf::internal::TSanRead(&_impl_);
9967   return _impl_.sparse_initializer_;
9968 }
9969 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
9970 GraphProto::_internal_mutable_sparse_initializer() {
9971   ::google::protobuf::internal::TSanRead(&_impl_);
9972   return &_impl_.sparse_initializer_;
9973 }
9974 
9975 // optional string doc_string = 10;
9976 inline bool GraphProto::has_doc_string() const {
9977   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
9978   return value;
9979 }
9980 inline void GraphProto::clear_doc_string() {
9981   ::google::protobuf::internal::TSanWrite(&_impl_);
9982   _impl_.doc_string_.ClearToEmpty();
9983   _impl_._has_bits_[0] &= ~0x00000002U;
9984 }
9985 inline const ::std::string& GraphProto::doc_string() const
9986     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9987   // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
9988   return _internal_doc_string();
9989 }
9990 template <typename Arg_, typename... Args_>
9991 PROTOBUF_ALWAYS_INLINE void GraphProto::set_doc_string(Arg_&& arg, Args_... args) {
9992   ::google::protobuf::internal::TSanWrite(&_impl_);
9993   _impl_._has_bits_[0] |= 0x00000002U;
9994   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
9995   // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
9996 }
9997 inline ::std::string* PROTOBUF_NONNULL GraphProto::mutable_doc_string()
9998     ABSL_ATTRIBUTE_LIFETIME_BOUND {
9999   ::std::string* _s = _internal_mutable_doc_string();
10000   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
10001   return _s;
10002 }
10003 inline const ::std::string& GraphProto::_internal_doc_string() const {
10004   ::google::protobuf::internal::TSanRead(&_impl_);
10005   return _impl_.doc_string_.Get();
10006 }
10007 inline void GraphProto::_internal_set_doc_string(const ::std::string& value) {
10008   ::google::protobuf::internal::TSanWrite(&_impl_);
10009   _impl_._has_bits_[0] |= 0x00000002U;
10010   _impl_.doc_string_.Set(value, GetArena());
10011 }
10012 inline ::std::string* PROTOBUF_NONNULL GraphProto::_internal_mutable_doc_string() {
10013   ::google::protobuf::internal::TSanWrite(&_impl_);
10014   _impl_._has_bits_[0] |= 0x00000002U;
10015   return _impl_.doc_string_.Mutable( GetArena());
10016 }
10017 inline ::std::string* PROTOBUF_NULLABLE GraphProto::release_doc_string() {
10018   ::google::protobuf::internal::TSanWrite(&_impl_);
10019   // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
10020   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
10021     return nullptr;
10022   }
10023   _impl_._has_bits_[0] &= ~0x00000002U;
10024   auto* released = _impl_.doc_string_.Release();
10025   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
10026     _impl_.doc_string_.Set("", GetArena());
10027   }
10028   return released;
10029 }
10030 inline void GraphProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
10031   ::google::protobuf::internal::TSanWrite(&_impl_);
10032   if (value != nullptr) {
10033     _impl_._has_bits_[0] |= 0x00000002U;
10034   } else {
10035     _impl_._has_bits_[0] &= ~0x00000002U;
10036   }
10037   _impl_.doc_string_.SetAllocated(value, GetArena());
10038   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
10039     _impl_.doc_string_.Set("", GetArena());
10040   }
10041   // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
10042 }
10043 
10044 // repeated .onnx.ValueInfoProto input = 11;
10045 inline int GraphProto::_internal_input_size() const {
10046   return _internal_input().size();
10047 }
10048 inline int GraphProto::input_size() const {
10049   return _internal_input_size();
10050 }
10051 inline void GraphProto::clear_input() {
10052   ::google::protobuf::internal::TSanWrite(&_impl_);
10053   _impl_.input_.Clear();
10054 }
10055 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_input(int index)
10056     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10057   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
10058   return _internal_mutable_input()->Mutable(index);
10059 }
10060 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_input()
10061     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10062   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
10063   ::google::protobuf::internal::TSanWrite(&_impl_);
10064   return _internal_mutable_input();
10065 }
10066 inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const
10067     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10068   // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
10069   return _internal_input().Get(index);
10070 }
10071 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_input()
10072     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10073   ::google::protobuf::internal::TSanWrite(&_impl_);
10074   ::onnx::ValueInfoProto* _add = _internal_mutable_input()->Add();
10075   // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
10076   return _add;
10077 }
10078 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::input() const
10079     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10080   // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
10081   return _internal_input();
10082 }
10083 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
10084 GraphProto::_internal_input() const {
10085   ::google::protobuf::internal::TSanRead(&_impl_);
10086   return _impl_.input_;
10087 }
10088 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
10089 GraphProto::_internal_mutable_input() {
10090   ::google::protobuf::internal::TSanRead(&_impl_);
10091   return &_impl_.input_;
10092 }
10093 
10094 // repeated .onnx.ValueInfoProto output = 12;
10095 inline int GraphProto::_internal_output_size() const {
10096   return _internal_output().size();
10097 }
10098 inline int GraphProto::output_size() const {
10099   return _internal_output_size();
10100 }
10101 inline void GraphProto::clear_output() {
10102   ::google::protobuf::internal::TSanWrite(&_impl_);
10103   _impl_.output_.Clear();
10104 }
10105 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_output(int index)
10106     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10107   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
10108   return _internal_mutable_output()->Mutable(index);
10109 }
10110 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_output()
10111     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10112   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
10113   ::google::protobuf::internal::TSanWrite(&_impl_);
10114   return _internal_mutable_output();
10115 }
10116 inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const
10117     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10118   // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
10119   return _internal_output().Get(index);
10120 }
10121 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_output()
10122     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10123   ::google::protobuf::internal::TSanWrite(&_impl_);
10124   ::onnx::ValueInfoProto* _add = _internal_mutable_output()->Add();
10125   // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
10126   return _add;
10127 }
10128 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::output() const
10129     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10130   // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
10131   return _internal_output();
10132 }
10133 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
10134 GraphProto::_internal_output() const {
10135   ::google::protobuf::internal::TSanRead(&_impl_);
10136   return _impl_.output_;
10137 }
10138 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
10139 GraphProto::_internal_mutable_output() {
10140   ::google::protobuf::internal::TSanRead(&_impl_);
10141   return &_impl_.output_;
10142 }
10143 
10144 // repeated .onnx.ValueInfoProto value_info = 13;
10145 inline int GraphProto::_internal_value_info_size() const {
10146   return _internal_value_info().size();
10147 }
10148 inline int GraphProto::value_info_size() const {
10149   return _internal_value_info_size();
10150 }
10151 inline void GraphProto::clear_value_info() {
10152   ::google::protobuf::internal::TSanWrite(&_impl_);
10153   _impl_.value_info_.Clear();
10154 }
10155 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_value_info(int index)
10156     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10157   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
10158   return _internal_mutable_value_info()->Mutable(index);
10159 }
10160 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_value_info()
10161     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10162   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
10163   ::google::protobuf::internal::TSanWrite(&_impl_);
10164   return _internal_mutable_value_info();
10165 }
10166 inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const
10167     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10168   // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
10169   return _internal_value_info().Get(index);
10170 }
10171 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_value_info()
10172     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10173   ::google::protobuf::internal::TSanWrite(&_impl_);
10174   ::onnx::ValueInfoProto* _add = _internal_mutable_value_info()->Add();
10175   // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
10176   return _add;
10177 }
10178 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::value_info() const
10179     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10180   // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
10181   return _internal_value_info();
10182 }
10183 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
10184 GraphProto::_internal_value_info() const {
10185   ::google::protobuf::internal::TSanRead(&_impl_);
10186   return _impl_.value_info_;
10187 }
10188 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
10189 GraphProto::_internal_mutable_value_info() {
10190   ::google::protobuf::internal::TSanRead(&_impl_);
10191   return &_impl_.value_info_;
10192 }
10193 
10194 // repeated .onnx.TensorAnnotation quantization_annotation = 14;
10195 inline int GraphProto::_internal_quantization_annotation_size() const {
10196   return _internal_quantization_annotation().size();
10197 }
10198 inline int GraphProto::quantization_annotation_size() const {
10199   return _internal_quantization_annotation_size();
10200 }
10201 inline void GraphProto::clear_quantization_annotation() {
10202   ::google::protobuf::internal::TSanWrite(&_impl_);
10203   _impl_.quantization_annotation_.Clear();
10204 }
10205 inline ::onnx::TensorAnnotation* PROTOBUF_NONNULL GraphProto::mutable_quantization_annotation(int index)
10206     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10207   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
10208   return _internal_mutable_quantization_annotation()->Mutable(index);
10209 }
10210 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL GraphProto::mutable_quantization_annotation()
10211     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10212   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
10213   ::google::protobuf::internal::TSanWrite(&_impl_);
10214   return _internal_mutable_quantization_annotation();
10215 }
10216 inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const
10217     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10218   // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
10219   return _internal_quantization_annotation().Get(index);
10220 }
10221 inline ::onnx::TensorAnnotation* PROTOBUF_NONNULL GraphProto::add_quantization_annotation()
10222     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10223   ::google::protobuf::internal::TSanWrite(&_impl_);
10224   ::onnx::TensorAnnotation* _add = _internal_mutable_quantization_annotation()->Add();
10225   // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
10226   return _add;
10227 }
10228 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& GraphProto::quantization_annotation() const
10229     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10230   // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
10231   return _internal_quantization_annotation();
10232 }
10233 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>&
10234 GraphProto::_internal_quantization_annotation() const {
10235   ::google::protobuf::internal::TSanRead(&_impl_);
10236   return _impl_.quantization_annotation_;
10237 }
10238 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL
10239 GraphProto::_internal_mutable_quantization_annotation() {
10240   ::google::protobuf::internal::TSanRead(&_impl_);
10241   return &_impl_.quantization_annotation_;
10242 }
10243 
10244 // repeated .onnx.StringStringEntryProto metadata_props = 16;
10245 inline int GraphProto::_internal_metadata_props_size() const {
10246   return _internal_metadata_props().size();
10247 }
10248 inline int GraphProto::metadata_props_size() const {
10249   return _internal_metadata_props_size();
10250 }
10251 inline void GraphProto::clear_metadata_props() {
10252   ::google::protobuf::internal::TSanWrite(&_impl_);
10253   _impl_.metadata_props_.Clear();
10254 }
10255 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL GraphProto::mutable_metadata_props(int index)
10256     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10257   // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props)
10258   return _internal_mutable_metadata_props()->Mutable(index);
10259 }
10260 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL GraphProto::mutable_metadata_props()
10261     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10262   // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props)
10263   ::google::protobuf::internal::TSanWrite(&_impl_);
10264   return _internal_mutable_metadata_props();
10265 }
10266 inline const ::onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const
10267     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10268   // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props)
10269   return _internal_metadata_props().Get(index);
10270 }
10271 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL GraphProto::add_metadata_props()
10272     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10273   ::google::protobuf::internal::TSanWrite(&_impl_);
10274   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
10275   // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props)
10276   return _add;
10277 }
10278 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& GraphProto::metadata_props() const
10279     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10280   // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props)
10281   return _internal_metadata_props();
10282 }
10283 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
10284 GraphProto::_internal_metadata_props() const {
10285   ::google::protobuf::internal::TSanRead(&_impl_);
10286   return _impl_.metadata_props_;
10287 }
10288 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
10289 GraphProto::_internal_mutable_metadata_props() {
10290   ::google::protobuf::internal::TSanRead(&_impl_);
10291   return &_impl_.metadata_props_;
10292 }
10293 
10294 // -------------------------------------------------------------------
10295 
10296 // TensorProto_Segment
10297 
10298 // optional int64 begin = 1;
10299 inline bool TensorProto_Segment::has_begin() const {
10300   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
10301   return value;
10302 }
10303 inline void TensorProto_Segment::clear_begin() {
10304   ::google::protobuf::internal::TSanWrite(&_impl_);
10305   _impl_.begin_ = ::int64_t{0};
10306   _impl_._has_bits_[0] &= ~0x00000001U;
10307 }
10308 inline ::int64_t TensorProto_Segment::begin() const {
10309   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
10310   return _internal_begin();
10311 }
10312 inline void TensorProto_Segment::set_begin(::int64_t value) {
10313   _internal_set_begin(value);
10314   _impl_._has_bits_[0] |= 0x00000001U;
10315   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
10316 }
10317 inline ::int64_t TensorProto_Segment::_internal_begin() const {
10318   ::google::protobuf::internal::TSanRead(&_impl_);
10319   return _impl_.begin_;
10320 }
10321 inline void TensorProto_Segment::_internal_set_begin(::int64_t value) {
10322   ::google::protobuf::internal::TSanWrite(&_impl_);
10323   _impl_.begin_ = value;
10324 }
10325 
10326 // optional int64 end = 2;
10327 inline bool TensorProto_Segment::has_end() const {
10328   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
10329   return value;
10330 }
10331 inline void TensorProto_Segment::clear_end() {
10332   ::google::protobuf::internal::TSanWrite(&_impl_);
10333   _impl_.end_ = ::int64_t{0};
10334   _impl_._has_bits_[0] &= ~0x00000002U;
10335 }
10336 inline ::int64_t TensorProto_Segment::end() const {
10337   // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
10338   return _internal_end();
10339 }
10340 inline void TensorProto_Segment::set_end(::int64_t value) {
10341   _internal_set_end(value);
10342   _impl_._has_bits_[0] |= 0x00000002U;
10343   // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
10344 }
10345 inline ::int64_t TensorProto_Segment::_internal_end() const {
10346   ::google::protobuf::internal::TSanRead(&_impl_);
10347   return _impl_.end_;
10348 }
10349 inline void TensorProto_Segment::_internal_set_end(::int64_t value) {
10350   ::google::protobuf::internal::TSanWrite(&_impl_);
10351   _impl_.end_ = value;
10352 }
10353 
10354 // -------------------------------------------------------------------
10355 
10356 // TensorProto
10357 
10358 // repeated int64 dims = 1;
10359 inline int TensorProto::_internal_dims_size() const {
10360   return _internal_dims().size();
10361 }
10362 inline int TensorProto::dims_size() const {
10363   return _internal_dims_size();
10364 }
10365 inline void TensorProto::clear_dims() {
10366   ::google::protobuf::internal::TSanWrite(&_impl_);
10367   _impl_.dims_.Clear();
10368 }
10369 inline ::int64_t TensorProto::dims(int index) const {
10370   // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
10371   return _internal_dims().Get(index);
10372 }
10373 inline void TensorProto::set_dims(int index, ::int64_t value) {
10374   _internal_mutable_dims()->Set(index, value);
10375   // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
10376 }
10377 inline void TensorProto::add_dims(::int64_t value) {
10378   ::google::protobuf::internal::TSanWrite(&_impl_);
10379   _internal_mutable_dims()->Add(value);
10380   // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
10381 }
10382 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::dims() const
10383     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10384   // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
10385   return _internal_dims();
10386 }
10387 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL TensorProto::mutable_dims()
10388     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10389   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
10390   ::google::protobuf::internal::TSanWrite(&_impl_);
10391   return _internal_mutable_dims();
10392 }
10393 inline const ::google::protobuf::RepeatedField<::int64_t>&
10394 TensorProto::_internal_dims() const {
10395   ::google::protobuf::internal::TSanRead(&_impl_);
10396   return _impl_.dims_;
10397 }
10398 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
10399 TensorProto::_internal_mutable_dims() {
10400   ::google::protobuf::internal::TSanRead(&_impl_);
10401   return &_impl_.dims_;
10402 }
10403 
10404 // optional int32 data_type = 2;
10405 inline bool TensorProto::has_data_type() const {
10406   bool value = (_impl_._has_bits_[0] & 0x00000010U) != 0;
10407   return value;
10408 }
10409 inline void TensorProto::clear_data_type() {
10410   ::google::protobuf::internal::TSanWrite(&_impl_);
10411   _impl_.data_type_ = 0;
10412   _impl_._has_bits_[0] &= ~0x00000010U;
10413 }
10414 inline ::int32_t TensorProto::data_type() const {
10415   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
10416   return _internal_data_type();
10417 }
10418 inline void TensorProto::set_data_type(::int32_t value) {
10419   _internal_set_data_type(value);
10420   _impl_._has_bits_[0] |= 0x00000010U;
10421   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
10422 }
10423 inline ::int32_t TensorProto::_internal_data_type() const {
10424   ::google::protobuf::internal::TSanRead(&_impl_);
10425   return _impl_.data_type_;
10426 }
10427 inline void TensorProto::_internal_set_data_type(::int32_t value) {
10428   ::google::protobuf::internal::TSanWrite(&_impl_);
10429   _impl_.data_type_ = value;
10430 }
10431 
10432 // optional .onnx.TensorProto.Segment segment = 3;
10433 inline bool TensorProto::has_segment() const {
10434   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
10435   PROTOBUF_ASSUME(!value || _impl_.segment_ != nullptr);
10436   return value;
10437 }
10438 inline void TensorProto::clear_segment() {
10439   ::google::protobuf::internal::TSanWrite(&_impl_);
10440   if (_impl_.segment_ != nullptr) _impl_.segment_->Clear();
10441   _impl_._has_bits_[0] &= ~0x00000008U;
10442 }
10443 inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
10444   ::google::protobuf::internal::TSanRead(&_impl_);
10445   const ::onnx::TensorProto_Segment* p = _impl_.segment_;
10446   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto_Segment&>(::onnx::_TensorProto_Segment_default_instance_);
10447 }
10448 inline const ::onnx::TensorProto_Segment& TensorProto::segment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
10449   // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
10450   return _internal_segment();
10451 }
10452 inline void TensorProto::unsafe_arena_set_allocated_segment(
10453     ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value) {
10454   ::google::protobuf::internal::TSanWrite(&_impl_);
10455   if (GetArena() == nullptr) {
10456     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
10457   }
10458   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
10459   if (value != nullptr) {
10460     _impl_._has_bits_[0] |= 0x00000008U;
10461   } else {
10462     _impl_._has_bits_[0] &= ~0x00000008U;
10463   }
10464   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
10465 }
10466 inline ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE TensorProto::release_segment() {
10467   ::google::protobuf::internal::TSanWrite(&_impl_);
10468 
10469   _impl_._has_bits_[0] &= ~0x00000008U;
10470   ::onnx::TensorProto_Segment* released = _impl_.segment_;
10471   _impl_.segment_ = nullptr;
10472   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
10473     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
10474     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
10475     if (GetArena() == nullptr) {
10476       delete old;
10477     }
10478   } else {
10479     if (GetArena() != nullptr) {
10480       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
10481     }
10482   }
10483   return released;
10484 }
10485 inline ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE TensorProto::unsafe_arena_release_segment() {
10486   ::google::protobuf::internal::TSanWrite(&_impl_);
10487   // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)
10488 
10489   _impl_._has_bits_[0] &= ~0x00000008U;
10490   ::onnx::TensorProto_Segment* temp = _impl_.segment_;
10491   _impl_.segment_ = nullptr;
10492   return temp;
10493 }
10494 inline ::onnx::TensorProto_Segment* PROTOBUF_NONNULL TensorProto::_internal_mutable_segment() {
10495   ::google::protobuf::internal::TSanWrite(&_impl_);
10496   if (_impl_.segment_ == nullptr) {
10497     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto_Segment>(GetArena());
10498     _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(p);
10499   }
10500   return _impl_.segment_;
10501 }
10502 inline ::onnx::TensorProto_Segment* PROTOBUF_NONNULL TensorProto::mutable_segment()
10503     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10504   _impl_._has_bits_[0] |= 0x00000008U;
10505   ::onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
10506   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
10507   return _msg;
10508 }
10509 inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value) {
10510   ::google::protobuf::Arena* message_arena = GetArena();
10511   ::google::protobuf::internal::TSanWrite(&_impl_);
10512   if (message_arena == nullptr) {
10513     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
10514   }
10515 
10516   if (value != nullptr) {
10517     ::google::protobuf::Arena* submessage_arena = value->GetArena();
10518     if (message_arena != submessage_arena) {
10519       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
10520     }
10521     _impl_._has_bits_[0] |= 0x00000008U;
10522   } else {
10523     _impl_._has_bits_[0] &= ~0x00000008U;
10524   }
10525 
10526   _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
10527   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
10528 }
10529 
10530 // repeated float float_data = 4 [packed = true];
10531 inline int TensorProto::_internal_float_data_size() const {
10532   return _internal_float_data().size();
10533 }
10534 inline int TensorProto::float_data_size() const {
10535   return _internal_float_data_size();
10536 }
10537 inline void TensorProto::clear_float_data() {
10538   ::google::protobuf::internal::TSanWrite(&_impl_);
10539   _impl_.float_data_.Clear();
10540 }
10541 inline float TensorProto::float_data(int index) const {
10542   // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
10543   return _internal_float_data().Get(index);
10544 }
10545 inline void TensorProto::set_float_data(int index, float value) {
10546   _internal_mutable_float_data()->Set(index, value);
10547   // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
10548 }
10549 inline void TensorProto::add_float_data(float value) {
10550   ::google::protobuf::internal::TSanWrite(&_impl_);
10551   _internal_mutable_float_data()->Add(value);
10552   // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
10553 }
10554 inline const ::google::protobuf::RepeatedField<float>& TensorProto::float_data() const
10555     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10556   // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
10557   return _internal_float_data();
10558 }
10559 inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL TensorProto::mutable_float_data()
10560     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10561   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
10562   ::google::protobuf::internal::TSanWrite(&_impl_);
10563   return _internal_mutable_float_data();
10564 }
10565 inline const ::google::protobuf::RepeatedField<float>&
10566 TensorProto::_internal_float_data() const {
10567   ::google::protobuf::internal::TSanRead(&_impl_);
10568   return _impl_.float_data_;
10569 }
10570 inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL
10571 TensorProto::_internal_mutable_float_data() {
10572   ::google::protobuf::internal::TSanRead(&_impl_);
10573   return &_impl_.float_data_;
10574 }
10575 
10576 // repeated int32 int32_data = 5 [packed = true];
10577 inline int TensorProto::_internal_int32_data_size() const {
10578   return _internal_int32_data().size();
10579 }
10580 inline int TensorProto::int32_data_size() const {
10581   return _internal_int32_data_size();
10582 }
10583 inline void TensorProto::clear_int32_data() {
10584   ::google::protobuf::internal::TSanWrite(&_impl_);
10585   _impl_.int32_data_.Clear();
10586 }
10587 inline ::int32_t TensorProto::int32_data(int index) const {
10588   // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
10589   return _internal_int32_data().Get(index);
10590 }
10591 inline void TensorProto::set_int32_data(int index, ::int32_t value) {
10592   _internal_mutable_int32_data()->Set(index, value);
10593   // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
10594 }
10595 inline void TensorProto::add_int32_data(::int32_t value) {
10596   ::google::protobuf::internal::TSanWrite(&_impl_);
10597   _internal_mutable_int32_data()->Add(value);
10598   // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
10599 }
10600 inline const ::google::protobuf::RepeatedField<::int32_t>& TensorProto::int32_data() const
10601     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10602   // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
10603   return _internal_int32_data();
10604 }
10605 inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL TensorProto::mutable_int32_data()
10606     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10607   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
10608   ::google::protobuf::internal::TSanWrite(&_impl_);
10609   return _internal_mutable_int32_data();
10610 }
10611 inline const ::google::protobuf::RepeatedField<::int32_t>&
10612 TensorProto::_internal_int32_data() const {
10613   ::google::protobuf::internal::TSanRead(&_impl_);
10614   return _impl_.int32_data_;
10615 }
10616 inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL
10617 TensorProto::_internal_mutable_int32_data() {
10618   ::google::protobuf::internal::TSanRead(&_impl_);
10619   return &_impl_.int32_data_;
10620 }
10621 
10622 // repeated bytes string_data = 6;
10623 inline int TensorProto::_internal_string_data_size() const {
10624   return _internal_string_data().size();
10625 }
10626 inline int TensorProto::string_data_size() const {
10627   return _internal_string_data_size();
10628 }
10629 inline void TensorProto::clear_string_data() {
10630   ::google::protobuf::internal::TSanWrite(&_impl_);
10631   _impl_.string_data_.Clear();
10632 }
10633 inline ::std::string* PROTOBUF_NONNULL TensorProto::add_string_data()
10634     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10635   ::google::protobuf::internal::TSanWrite(&_impl_);
10636   ::std::string* _s = _internal_mutable_string_data()->Add();
10637   // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
10638   return _s;
10639 }
10640 inline const ::std::string& TensorProto::string_data(int index) const
10641     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10642   // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
10643   return _internal_string_data().Get(index);
10644 }
10645 inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_string_data(int index)
10646     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10647   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
10648   return _internal_mutable_string_data()->Mutable(index);
10649 }
10650 template <typename Arg_, typename... Args_>
10651 inline void TensorProto::set_string_data(int index, Arg_&& value, Args_... args) {
10652   ::google::protobuf::internal::AssignToString(*_internal_mutable_string_data()->Mutable(index), ::std::forward<Arg_>(value),
10653                         args... , ::google::protobuf::internal::BytesTag{});
10654   // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
10655 }
10656 template <typename Arg_, typename... Args_>
10657 inline void TensorProto::add_string_data(Arg_&& value, Args_... args) {
10658   ::google::protobuf::internal::TSanWrite(&_impl_);
10659   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_string_data(),
10660                                ::std::forward<Arg_>(value),
10661                                args... , ::google::protobuf::internal::BytesTag{});
10662   // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
10663 }
10664 inline const ::google::protobuf::RepeatedPtrField<::std::string>& TensorProto::string_data()
10665     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
10666   // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
10667   return _internal_string_data();
10668 }
10669 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
10670 TensorProto::mutable_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
10671   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
10672   ::google::protobuf::internal::TSanWrite(&_impl_);
10673   return _internal_mutable_string_data();
10674 }
10675 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
10676 TensorProto::_internal_string_data() const {
10677   ::google::protobuf::internal::TSanRead(&_impl_);
10678   return _impl_.string_data_;
10679 }
10680 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
10681 TensorProto::_internal_mutable_string_data() {
10682   ::google::protobuf::internal::TSanRead(&_impl_);
10683   return &_impl_.string_data_;
10684 }
10685 
10686 // repeated int64 int64_data = 7 [packed = true];
10687 inline int TensorProto::_internal_int64_data_size() const {
10688   return _internal_int64_data().size();
10689 }
10690 inline int TensorProto::int64_data_size() const {
10691   return _internal_int64_data_size();
10692 }
10693 inline void TensorProto::clear_int64_data() {
10694   ::google::protobuf::internal::TSanWrite(&_impl_);
10695   _impl_.int64_data_.Clear();
10696 }
10697 inline ::int64_t TensorProto::int64_data(int index) const {
10698   // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
10699   return _internal_int64_data().Get(index);
10700 }
10701 inline void TensorProto::set_int64_data(int index, ::int64_t value) {
10702   _internal_mutable_int64_data()->Set(index, value);
10703   // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
10704 }
10705 inline void TensorProto::add_int64_data(::int64_t value) {
10706   ::google::protobuf::internal::TSanWrite(&_impl_);
10707   _internal_mutable_int64_data()->Add(value);
10708   // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
10709 }
10710 inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::int64_data() const
10711     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10712   // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
10713   return _internal_int64_data();
10714 }
10715 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL TensorProto::mutable_int64_data()
10716     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10717   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
10718   ::google::protobuf::internal::TSanWrite(&_impl_);
10719   return _internal_mutable_int64_data();
10720 }
10721 inline const ::google::protobuf::RepeatedField<::int64_t>&
10722 TensorProto::_internal_int64_data() const {
10723   ::google::protobuf::internal::TSanRead(&_impl_);
10724   return _impl_.int64_data_;
10725 }
10726 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
10727 TensorProto::_internal_mutable_int64_data() {
10728   ::google::protobuf::internal::TSanRead(&_impl_);
10729   return &_impl_.int64_data_;
10730 }
10731 
10732 // optional string name = 8;
10733 inline bool TensorProto::has_name() const {
10734   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
10735   return value;
10736 }
10737 inline void TensorProto::clear_name() {
10738   ::google::protobuf::internal::TSanWrite(&_impl_);
10739   _impl_.name_.ClearToEmpty();
10740   _impl_._has_bits_[0] &= ~0x00000001U;
10741 }
10742 inline const ::std::string& TensorProto::name() const
10743     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10744   // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
10745   return _internal_name();
10746 }
10747 template <typename Arg_, typename... Args_>
10748 PROTOBUF_ALWAYS_INLINE void TensorProto::set_name(Arg_&& arg, Args_... args) {
10749   ::google::protobuf::internal::TSanWrite(&_impl_);
10750   _impl_._has_bits_[0] |= 0x00000001U;
10751   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
10752   // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
10753 }
10754 inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_name()
10755     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10756   ::std::string* _s = _internal_mutable_name();
10757   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
10758   return _s;
10759 }
10760 inline const ::std::string& TensorProto::_internal_name() const {
10761   ::google::protobuf::internal::TSanRead(&_impl_);
10762   return _impl_.name_.Get();
10763 }
10764 inline void TensorProto::_internal_set_name(const ::std::string& value) {
10765   ::google::protobuf::internal::TSanWrite(&_impl_);
10766   _impl_._has_bits_[0] |= 0x00000001U;
10767   _impl_.name_.Set(value, GetArena());
10768 }
10769 inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_name() {
10770   ::google::protobuf::internal::TSanWrite(&_impl_);
10771   _impl_._has_bits_[0] |= 0x00000001U;
10772   return _impl_.name_.Mutable( GetArena());
10773 }
10774 inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_name() {
10775   ::google::protobuf::internal::TSanWrite(&_impl_);
10776   // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
10777   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
10778     return nullptr;
10779   }
10780   _impl_._has_bits_[0] &= ~0x00000001U;
10781   auto* released = _impl_.name_.Release();
10782   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
10783     _impl_.name_.Set("", GetArena());
10784   }
10785   return released;
10786 }
10787 inline void TensorProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
10788   ::google::protobuf::internal::TSanWrite(&_impl_);
10789   if (value != nullptr) {
10790     _impl_._has_bits_[0] |= 0x00000001U;
10791   } else {
10792     _impl_._has_bits_[0] &= ~0x00000001U;
10793   }
10794   _impl_.name_.SetAllocated(value, GetArena());
10795   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
10796     _impl_.name_.Set("", GetArena());
10797   }
10798   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
10799 }
10800 
10801 // optional string doc_string = 12;
10802 inline bool TensorProto::has_doc_string() const {
10803   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
10804   return value;
10805 }
10806 inline void TensorProto::clear_doc_string() {
10807   ::google::protobuf::internal::TSanWrite(&_impl_);
10808   _impl_.doc_string_.ClearToEmpty();
10809   _impl_._has_bits_[0] &= ~0x00000004U;
10810 }
10811 inline const ::std::string& TensorProto::doc_string() const
10812     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10813   // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
10814   return _internal_doc_string();
10815 }
10816 template <typename Arg_, typename... Args_>
10817 PROTOBUF_ALWAYS_INLINE void TensorProto::set_doc_string(Arg_&& arg, Args_... args) {
10818   ::google::protobuf::internal::TSanWrite(&_impl_);
10819   _impl_._has_bits_[0] |= 0x00000004U;
10820   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
10821   // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
10822 }
10823 inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_doc_string()
10824     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10825   ::std::string* _s = _internal_mutable_doc_string();
10826   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
10827   return _s;
10828 }
10829 inline const ::std::string& TensorProto::_internal_doc_string() const {
10830   ::google::protobuf::internal::TSanRead(&_impl_);
10831   return _impl_.doc_string_.Get();
10832 }
10833 inline void TensorProto::_internal_set_doc_string(const ::std::string& value) {
10834   ::google::protobuf::internal::TSanWrite(&_impl_);
10835   _impl_._has_bits_[0] |= 0x00000004U;
10836   _impl_.doc_string_.Set(value, GetArena());
10837 }
10838 inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_doc_string() {
10839   ::google::protobuf::internal::TSanWrite(&_impl_);
10840   _impl_._has_bits_[0] |= 0x00000004U;
10841   return _impl_.doc_string_.Mutable( GetArena());
10842 }
10843 inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_doc_string() {
10844   ::google::protobuf::internal::TSanWrite(&_impl_);
10845   // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
10846   if ((_impl_._has_bits_[0] & 0x00000004U) == 0) {
10847     return nullptr;
10848   }
10849   _impl_._has_bits_[0] &= ~0x00000004U;
10850   auto* released = _impl_.doc_string_.Release();
10851   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
10852     _impl_.doc_string_.Set("", GetArena());
10853   }
10854   return released;
10855 }
10856 inline void TensorProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
10857   ::google::protobuf::internal::TSanWrite(&_impl_);
10858   if (value != nullptr) {
10859     _impl_._has_bits_[0] |= 0x00000004U;
10860   } else {
10861     _impl_._has_bits_[0] &= ~0x00000004U;
10862   }
10863   _impl_.doc_string_.SetAllocated(value, GetArena());
10864   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
10865     _impl_.doc_string_.Set("", GetArena());
10866   }
10867   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
10868 }
10869 
10870 // optional bytes raw_data = 9;
10871 inline bool TensorProto::has_raw_data() const {
10872   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
10873   return value;
10874 }
10875 inline void TensorProto::clear_raw_data() {
10876   ::google::protobuf::internal::TSanWrite(&_impl_);
10877   _impl_.raw_data_.ClearToEmpty();
10878   _impl_._has_bits_[0] &= ~0x00000002U;
10879 }
10880 inline const ::std::string& TensorProto::raw_data() const
10881     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10882   // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
10883   return _internal_raw_data();
10884 }
10885 template <typename Arg_, typename... Args_>
10886 PROTOBUF_ALWAYS_INLINE void TensorProto::set_raw_data(Arg_&& arg, Args_... args) {
10887   ::google::protobuf::internal::TSanWrite(&_impl_);
10888   _impl_._has_bits_[0] |= 0x00000002U;
10889   _impl_.raw_data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
10890   // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
10891 }
10892 inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_raw_data()
10893     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10894   ::std::string* _s = _internal_mutable_raw_data();
10895   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
10896   return _s;
10897 }
10898 inline const ::std::string& TensorProto::_internal_raw_data() const {
10899   ::google::protobuf::internal::TSanRead(&_impl_);
10900   return _impl_.raw_data_.Get();
10901 }
10902 inline void TensorProto::_internal_set_raw_data(const ::std::string& value) {
10903   ::google::protobuf::internal::TSanWrite(&_impl_);
10904   _impl_._has_bits_[0] |= 0x00000002U;
10905   _impl_.raw_data_.Set(value, GetArena());
10906 }
10907 inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_raw_data() {
10908   ::google::protobuf::internal::TSanWrite(&_impl_);
10909   _impl_._has_bits_[0] |= 0x00000002U;
10910   return _impl_.raw_data_.Mutable( GetArena());
10911 }
10912 inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_raw_data() {
10913   ::google::protobuf::internal::TSanWrite(&_impl_);
10914   // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
10915   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
10916     return nullptr;
10917   }
10918   _impl_._has_bits_[0] &= ~0x00000002U;
10919   auto* released = _impl_.raw_data_.Release();
10920   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
10921     _impl_.raw_data_.Set("", GetArena());
10922   }
10923   return released;
10924 }
10925 inline void TensorProto::set_allocated_raw_data(::std::string* PROTOBUF_NULLABLE value) {
10926   ::google::protobuf::internal::TSanWrite(&_impl_);
10927   if (value != nullptr) {
10928     _impl_._has_bits_[0] |= 0x00000002U;
10929   } else {
10930     _impl_._has_bits_[0] &= ~0x00000002U;
10931   }
10932   _impl_.raw_data_.SetAllocated(value, GetArena());
10933   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.raw_data_.IsDefault()) {
10934     _impl_.raw_data_.Set("", GetArena());
10935   }
10936   // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
10937 }
10938 
10939 // repeated .onnx.StringStringEntryProto external_data = 13;
10940 inline int TensorProto::_internal_external_data_size() const {
10941   return _internal_external_data().size();
10942 }
10943 inline int TensorProto::external_data_size() const {
10944   return _internal_external_data_size();
10945 }
10946 inline void TensorProto::clear_external_data() {
10947   ::google::protobuf::internal::TSanWrite(&_impl_);
10948   _impl_.external_data_.Clear();
10949 }
10950 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::mutable_external_data(int index)
10951     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10952   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
10953   return _internal_mutable_external_data()->Mutable(index);
10954 }
10955 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorProto::mutable_external_data()
10956     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10957   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
10958   ::google::protobuf::internal::TSanWrite(&_impl_);
10959   return _internal_mutable_external_data();
10960 }
10961 inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const
10962     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10963   // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
10964   return _internal_external_data().Get(index);
10965 }
10966 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::add_external_data()
10967     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10968   ::google::protobuf::internal::TSanWrite(&_impl_);
10969   ::onnx::StringStringEntryProto* _add = _internal_mutable_external_data()->Add();
10970   // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
10971   return _add;
10972 }
10973 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::external_data() const
10974     ABSL_ATTRIBUTE_LIFETIME_BOUND {
10975   // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
10976   return _internal_external_data();
10977 }
10978 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
10979 TensorProto::_internal_external_data() const {
10980   ::google::protobuf::internal::TSanRead(&_impl_);
10981   return _impl_.external_data_;
10982 }
10983 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
10984 TensorProto::_internal_mutable_external_data() {
10985   ::google::protobuf::internal::TSanRead(&_impl_);
10986   return &_impl_.external_data_;
10987 }
10988 
10989 // optional .onnx.TensorProto.DataLocation data_location = 14;
10990 inline bool TensorProto::has_data_location() const {
10991   bool value = (_impl_._has_bits_[0] & 0x00000020U) != 0;
10992   return value;
10993 }
10994 inline void TensorProto::clear_data_location() {
10995   ::google::protobuf::internal::TSanWrite(&_impl_);
10996   _impl_.data_location_ = 0;
10997   _impl_._has_bits_[0] &= ~0x00000020U;
10998 }
10999 inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
11000   // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
11001   return _internal_data_location();
11002 }
11003 inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
11004   _internal_set_data_location(value);
11005   _impl_._has_bits_[0] |= 0x00000020U;
11006   // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
11007 }
11008 inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
11009   ::google::protobuf::internal::TSanRead(&_impl_);
11010   return static_cast<::onnx::TensorProto_DataLocation>(_impl_.data_location_);
11011 }
11012 inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
11013   ::google::protobuf::internal::TSanWrite(&_impl_);
11014 
11015                                           assert(::google::protobuf::internal::ValidateEnum(
11016                                               value, ::onnx::TensorProto_DataLocation_internal_data_));
11017                                           _impl_.data_location_ = value;
11018 }
11019 
11020 // repeated double double_data = 10 [packed = true];
11021 inline int TensorProto::_internal_double_data_size() const {
11022   return _internal_double_data().size();
11023 }
11024 inline int TensorProto::double_data_size() const {
11025   return _internal_double_data_size();
11026 }
11027 inline void TensorProto::clear_double_data() {
11028   ::google::protobuf::internal::TSanWrite(&_impl_);
11029   _impl_.double_data_.Clear();
11030 }
11031 inline double TensorProto::double_data(int index) const {
11032   // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
11033   return _internal_double_data().Get(index);
11034 }
11035 inline void TensorProto::set_double_data(int index, double value) {
11036   _internal_mutable_double_data()->Set(index, value);
11037   // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
11038 }
11039 inline void TensorProto::add_double_data(double value) {
11040   ::google::protobuf::internal::TSanWrite(&_impl_);
11041   _internal_mutable_double_data()->Add(value);
11042   // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
11043 }
11044 inline const ::google::protobuf::RepeatedField<double>& TensorProto::double_data() const
11045     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11046   // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
11047   return _internal_double_data();
11048 }
11049 inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL TensorProto::mutable_double_data()
11050     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11051   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
11052   ::google::protobuf::internal::TSanWrite(&_impl_);
11053   return _internal_mutable_double_data();
11054 }
11055 inline const ::google::protobuf::RepeatedField<double>&
11056 TensorProto::_internal_double_data() const {
11057   ::google::protobuf::internal::TSanRead(&_impl_);
11058   return _impl_.double_data_;
11059 }
11060 inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL
11061 TensorProto::_internal_mutable_double_data() {
11062   ::google::protobuf::internal::TSanRead(&_impl_);
11063   return &_impl_.double_data_;
11064 }
11065 
11066 // repeated uint64 uint64_data = 11 [packed = true];
11067 inline int TensorProto::_internal_uint64_data_size() const {
11068   return _internal_uint64_data().size();
11069 }
11070 inline int TensorProto::uint64_data_size() const {
11071   return _internal_uint64_data_size();
11072 }
11073 inline void TensorProto::clear_uint64_data() {
11074   ::google::protobuf::internal::TSanWrite(&_impl_);
11075   _impl_.uint64_data_.Clear();
11076 }
11077 inline ::uint64_t TensorProto::uint64_data(int index) const {
11078   // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
11079   return _internal_uint64_data().Get(index);
11080 }
11081 inline void TensorProto::set_uint64_data(int index, ::uint64_t value) {
11082   _internal_mutable_uint64_data()->Set(index, value);
11083   // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
11084 }
11085 inline void TensorProto::add_uint64_data(::uint64_t value) {
11086   ::google::protobuf::internal::TSanWrite(&_impl_);
11087   _internal_mutable_uint64_data()->Add(value);
11088   // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
11089 }
11090 inline const ::google::protobuf::RepeatedField<::uint64_t>& TensorProto::uint64_data() const
11091     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11092   // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
11093   return _internal_uint64_data();
11094 }
11095 inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL TensorProto::mutable_uint64_data()
11096     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11097   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
11098   ::google::protobuf::internal::TSanWrite(&_impl_);
11099   return _internal_mutable_uint64_data();
11100 }
11101 inline const ::google::protobuf::RepeatedField<::uint64_t>&
11102 TensorProto::_internal_uint64_data() const {
11103   ::google::protobuf::internal::TSanRead(&_impl_);
11104   return _impl_.uint64_data_;
11105 }
11106 inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL
11107 TensorProto::_internal_mutable_uint64_data() {
11108   ::google::protobuf::internal::TSanRead(&_impl_);
11109   return &_impl_.uint64_data_;
11110 }
11111 
11112 // repeated .onnx.StringStringEntryProto metadata_props = 16;
11113 inline int TensorProto::_internal_metadata_props_size() const {
11114   return _internal_metadata_props().size();
11115 }
11116 inline int TensorProto::metadata_props_size() const {
11117   return _internal_metadata_props_size();
11118 }
11119 inline void TensorProto::clear_metadata_props() {
11120   ::google::protobuf::internal::TSanWrite(&_impl_);
11121   _impl_.metadata_props_.Clear();
11122 }
11123 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::mutable_metadata_props(int index)
11124     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11125   // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props)
11126   return _internal_mutable_metadata_props()->Mutable(index);
11127 }
11128 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorProto::mutable_metadata_props()
11129     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11130   // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props)
11131   ::google::protobuf::internal::TSanWrite(&_impl_);
11132   return _internal_mutable_metadata_props();
11133 }
11134 inline const ::onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const
11135     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11136   // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props)
11137   return _internal_metadata_props().Get(index);
11138 }
11139 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::add_metadata_props()
11140     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11141   ::google::protobuf::internal::TSanWrite(&_impl_);
11142   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
11143   // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props)
11144   return _add;
11145 }
11146 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::metadata_props() const
11147     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11148   // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props)
11149   return _internal_metadata_props();
11150 }
11151 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
11152 TensorProto::_internal_metadata_props() const {
11153   ::google::protobuf::internal::TSanRead(&_impl_);
11154   return _impl_.metadata_props_;
11155 }
11156 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
11157 TensorProto::_internal_mutable_metadata_props() {
11158   ::google::protobuf::internal::TSanRead(&_impl_);
11159   return &_impl_.metadata_props_;
11160 }
11161 
11162 // -------------------------------------------------------------------
11163 
11164 // SparseTensorProto
11165 
11166 // optional .onnx.TensorProto values = 1;
11167 inline bool SparseTensorProto::has_values() const {
11168   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
11169   PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
11170   return value;
11171 }
11172 inline void SparseTensorProto::clear_values() {
11173   ::google::protobuf::internal::TSanWrite(&_impl_);
11174   if (_impl_.values_ != nullptr) _impl_.values_->Clear();
11175   _impl_._has_bits_[0] &= ~0x00000001U;
11176 }
11177 inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
11178   ::google::protobuf::internal::TSanRead(&_impl_);
11179   const ::onnx::TensorProto* p = _impl_.values_;
11180   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
11181 }
11182 inline const ::onnx::TensorProto& SparseTensorProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11183   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
11184   return _internal_values();
11185 }
11186 inline void SparseTensorProto::unsafe_arena_set_allocated_values(
11187     ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
11188   ::google::protobuf::internal::TSanWrite(&_impl_);
11189   if (GetArena() == nullptr) {
11190     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
11191   }
11192   _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
11193   if (value != nullptr) {
11194     _impl_._has_bits_[0] |= 0x00000001U;
11195   } else {
11196     _impl_._has_bits_[0] &= ~0x00000001U;
11197   }
11198   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
11199 }
11200 inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::release_values() {
11201   ::google::protobuf::internal::TSanWrite(&_impl_);
11202 
11203   _impl_._has_bits_[0] &= ~0x00000001U;
11204   ::onnx::TensorProto* released = _impl_.values_;
11205   _impl_.values_ = nullptr;
11206   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
11207     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11208     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11209     if (GetArena() == nullptr) {
11210       delete old;
11211     }
11212   } else {
11213     if (GetArena() != nullptr) {
11214       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11215     }
11216   }
11217   return released;
11218 }
11219 inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::unsafe_arena_release_values() {
11220   ::google::protobuf::internal::TSanWrite(&_impl_);
11221   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)
11222 
11223   _impl_._has_bits_[0] &= ~0x00000001U;
11224   ::onnx::TensorProto* temp = _impl_.values_;
11225   _impl_.values_ = nullptr;
11226   return temp;
11227 }
11228 inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::_internal_mutable_values() {
11229   ::google::protobuf::internal::TSanWrite(&_impl_);
11230   if (_impl_.values_ == nullptr) {
11231     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
11232     _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(p);
11233   }
11234   return _impl_.values_;
11235 }
11236 inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::mutable_values()
11237     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11238   _impl_._has_bits_[0] |= 0x00000001U;
11239   ::onnx::TensorProto* _msg = _internal_mutable_values();
11240   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
11241   return _msg;
11242 }
11243 inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
11244   ::google::protobuf::Arena* message_arena = GetArena();
11245   ::google::protobuf::internal::TSanWrite(&_impl_);
11246   if (message_arena == nullptr) {
11247     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
11248   }
11249 
11250   if (value != nullptr) {
11251     ::google::protobuf::Arena* submessage_arena = value->GetArena();
11252     if (message_arena != submessage_arena) {
11253       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11254     }
11255     _impl_._has_bits_[0] |= 0x00000001U;
11256   } else {
11257     _impl_._has_bits_[0] &= ~0x00000001U;
11258   }
11259 
11260   _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
11261   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
11262 }
11263 
11264 // optional .onnx.TensorProto indices = 2;
11265 inline bool SparseTensorProto::has_indices() const {
11266   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
11267   PROTOBUF_ASSUME(!value || _impl_.indices_ != nullptr);
11268   return value;
11269 }
11270 inline void SparseTensorProto::clear_indices() {
11271   ::google::protobuf::internal::TSanWrite(&_impl_);
11272   if (_impl_.indices_ != nullptr) _impl_.indices_->Clear();
11273   _impl_._has_bits_[0] &= ~0x00000002U;
11274 }
11275 inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
11276   ::google::protobuf::internal::TSanRead(&_impl_);
11277   const ::onnx::TensorProto* p = _impl_.indices_;
11278   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
11279 }
11280 inline const ::onnx::TensorProto& SparseTensorProto::indices() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11281   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
11282   return _internal_indices();
11283 }
11284 inline void SparseTensorProto::unsafe_arena_set_allocated_indices(
11285     ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
11286   ::google::protobuf::internal::TSanWrite(&_impl_);
11287   if (GetArena() == nullptr) {
11288     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
11289   }
11290   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
11291   if (value != nullptr) {
11292     _impl_._has_bits_[0] |= 0x00000002U;
11293   } else {
11294     _impl_._has_bits_[0] &= ~0x00000002U;
11295   }
11296   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
11297 }
11298 inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::release_indices() {
11299   ::google::protobuf::internal::TSanWrite(&_impl_);
11300 
11301   _impl_._has_bits_[0] &= ~0x00000002U;
11302   ::onnx::TensorProto* released = _impl_.indices_;
11303   _impl_.indices_ = nullptr;
11304   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
11305     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11306     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11307     if (GetArena() == nullptr) {
11308       delete old;
11309     }
11310   } else {
11311     if (GetArena() != nullptr) {
11312       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11313     }
11314   }
11315   return released;
11316 }
11317 inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::unsafe_arena_release_indices() {
11318   ::google::protobuf::internal::TSanWrite(&_impl_);
11319   // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)
11320 
11321   _impl_._has_bits_[0] &= ~0x00000002U;
11322   ::onnx::TensorProto* temp = _impl_.indices_;
11323   _impl_.indices_ = nullptr;
11324   return temp;
11325 }
11326 inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::_internal_mutable_indices() {
11327   ::google::protobuf::internal::TSanWrite(&_impl_);
11328   if (_impl_.indices_ == nullptr) {
11329     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
11330     _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(p);
11331   }
11332   return _impl_.indices_;
11333 }
11334 inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::mutable_indices()
11335     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11336   _impl_._has_bits_[0] |= 0x00000002U;
11337   ::onnx::TensorProto* _msg = _internal_mutable_indices();
11338   // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
11339   return _msg;
11340 }
11341 inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
11342   ::google::protobuf::Arena* message_arena = GetArena();
11343   ::google::protobuf::internal::TSanWrite(&_impl_);
11344   if (message_arena == nullptr) {
11345     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
11346   }
11347 
11348   if (value != nullptr) {
11349     ::google::protobuf::Arena* submessage_arena = value->GetArena();
11350     if (message_arena != submessage_arena) {
11351       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11352     }
11353     _impl_._has_bits_[0] |= 0x00000002U;
11354   } else {
11355     _impl_._has_bits_[0] &= ~0x00000002U;
11356   }
11357 
11358   _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
11359   // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
11360 }
11361 
11362 // repeated int64 dims = 3;
11363 inline int SparseTensorProto::_internal_dims_size() const {
11364   return _internal_dims().size();
11365 }
11366 inline int SparseTensorProto::dims_size() const {
11367   return _internal_dims_size();
11368 }
11369 inline void SparseTensorProto::clear_dims() {
11370   ::google::protobuf::internal::TSanWrite(&_impl_);
11371   _impl_.dims_.Clear();
11372 }
11373 inline ::int64_t SparseTensorProto::dims(int index) const {
11374   // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
11375   return _internal_dims().Get(index);
11376 }
11377 inline void SparseTensorProto::set_dims(int index, ::int64_t value) {
11378   _internal_mutable_dims()->Set(index, value);
11379   // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
11380 }
11381 inline void SparseTensorProto::add_dims(::int64_t value) {
11382   ::google::protobuf::internal::TSanWrite(&_impl_);
11383   _internal_mutable_dims()->Add(value);
11384   // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
11385 }
11386 inline const ::google::protobuf::RepeatedField<::int64_t>& SparseTensorProto::dims() const
11387     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11388   // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
11389   return _internal_dims();
11390 }
11391 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL SparseTensorProto::mutable_dims()
11392     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11393   // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
11394   ::google::protobuf::internal::TSanWrite(&_impl_);
11395   return _internal_mutable_dims();
11396 }
11397 inline const ::google::protobuf::RepeatedField<::int64_t>&
11398 SparseTensorProto::_internal_dims() const {
11399   ::google::protobuf::internal::TSanRead(&_impl_);
11400   return _impl_.dims_;
11401 }
11402 inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
11403 SparseTensorProto::_internal_mutable_dims() {
11404   ::google::protobuf::internal::TSanRead(&_impl_);
11405   return &_impl_.dims_;
11406 }
11407 
11408 // -------------------------------------------------------------------
11409 
11410 // TensorShapeProto_Dimension
11411 
11412 // int64 dim_value = 1;
11413 inline bool TensorShapeProto_Dimension::has_dim_value() const {
11414   return value_case() == kDimValue;
11415 }
11416 inline void TensorShapeProto_Dimension::set_has_dim_value() {
11417   _impl_._oneof_case_[0] = kDimValue;
11418 }
11419 inline void TensorShapeProto_Dimension::clear_dim_value() {
11420   ::google::protobuf::internal::TSanWrite(&_impl_);
11421   if (value_case() == kDimValue) {
11422     _impl_.value_.dim_value_ = ::int64_t{0};
11423     clear_has_value();
11424   }
11425 }
11426 inline ::int64_t TensorShapeProto_Dimension::dim_value() const {
11427   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
11428   return _internal_dim_value();
11429 }
11430 inline void TensorShapeProto_Dimension::set_dim_value(::int64_t value) {
11431   if (value_case() != kDimValue) {
11432     clear_value();
11433     set_has_dim_value();
11434   }
11435   _impl_.value_.dim_value_ = value;
11436   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
11437 }
11438 inline ::int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
11439   if (value_case() == kDimValue) {
11440     return _impl_.value_.dim_value_;
11441   }
11442   return ::int64_t{0};
11443 }
11444 
11445 // string dim_param = 2;
11446 inline bool TensorShapeProto_Dimension::has_dim_param() const {
11447   return value_case() == kDimParam;
11448 }
11449 inline void TensorShapeProto_Dimension::set_has_dim_param() {
11450   _impl_._oneof_case_[0] = kDimParam;
11451 }
11452 inline void TensorShapeProto_Dimension::clear_dim_param() {
11453   ::google::protobuf::internal::TSanWrite(&_impl_);
11454   if (value_case() == kDimParam) {
11455     _impl_.value_.dim_param_.Destroy();
11456     clear_has_value();
11457   }
11458 }
11459 inline const ::std::string& TensorShapeProto_Dimension::dim_param() const
11460     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11461   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
11462   return _internal_dim_param();
11463 }
11464 template <typename Arg_, typename... Args_>
11465 PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_dim_param(Arg_&& arg, Args_... args) {
11466   ::google::protobuf::internal::TSanWrite(&_impl_);
11467   if (value_case() != kDimParam) {
11468     clear_value();
11469 
11470     set_has_dim_param();
11471     _impl_.value_.dim_param_.InitDefault();
11472   }
11473   _impl_.value_.dim_param_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
11474   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
11475 }
11476 inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::mutable_dim_param()
11477     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11478   ::std::string* _s = _internal_mutable_dim_param();
11479   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
11480   return _s;
11481 }
11482 inline const ::std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
11483   ::google::protobuf::internal::TSanRead(&_impl_);
11484   if (value_case() != kDimParam) {
11485     return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
11486   }
11487   return _impl_.value_.dim_param_.Get();
11488 }
11489 inline void TensorShapeProto_Dimension::_internal_set_dim_param(const ::std::string& value) {
11490   ::google::protobuf::internal::TSanWrite(&_impl_);
11491   if (value_case() != kDimParam) {
11492     clear_value();
11493 
11494     set_has_dim_param();
11495     _impl_.value_.dim_param_.InitDefault();
11496   }
11497   _impl_.value_.dim_param_.Set(value, GetArena());
11498 }
11499 inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::_internal_mutable_dim_param() {
11500   ::google::protobuf::internal::TSanWrite(&_impl_);
11501   if (value_case() != kDimParam) {
11502     clear_value();
11503 
11504     set_has_dim_param();
11505     _impl_.value_.dim_param_.InitDefault();
11506   }
11507   return _impl_.value_.dim_param_.Mutable( GetArena());
11508 }
11509 inline ::std::string* PROTOBUF_NULLABLE TensorShapeProto_Dimension::release_dim_param() {
11510   ::google::protobuf::internal::TSanWrite(&_impl_);
11511   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
11512   if (value_case() != kDimParam) {
11513     return nullptr;
11514   }
11515   clear_has_value();
11516   return _impl_.value_.dim_param_.Release();
11517 }
11518 inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value) {
11519   ::google::protobuf::internal::TSanWrite(&_impl_);
11520   if (has_value()) {
11521     clear_value();
11522   }
11523   if (value != nullptr) {
11524     set_has_dim_param();
11525     _impl_.value_.dim_param_.InitAllocated(value, GetArena());
11526   }
11527   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
11528 }
11529 
11530 // optional string denotation = 3;
11531 inline bool TensorShapeProto_Dimension::has_denotation() const {
11532   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
11533   return value;
11534 }
11535 inline void TensorShapeProto_Dimension::clear_denotation() {
11536   ::google::protobuf::internal::TSanWrite(&_impl_);
11537   _impl_.denotation_.ClearToEmpty();
11538   _impl_._has_bits_[0] &= ~0x00000001U;
11539 }
11540 inline const ::std::string& TensorShapeProto_Dimension::denotation() const
11541     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11542   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
11543   return _internal_denotation();
11544 }
11545 template <typename Arg_, typename... Args_>
11546 PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_denotation(Arg_&& arg, Args_... args) {
11547   ::google::protobuf::internal::TSanWrite(&_impl_);
11548   _impl_._has_bits_[0] |= 0x00000001U;
11549   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
11550   // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
11551 }
11552 inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::mutable_denotation()
11553     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11554   ::std::string* _s = _internal_mutable_denotation();
11555   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
11556   return _s;
11557 }
11558 inline const ::std::string& TensorShapeProto_Dimension::_internal_denotation() const {
11559   ::google::protobuf::internal::TSanRead(&_impl_);
11560   return _impl_.denotation_.Get();
11561 }
11562 inline void TensorShapeProto_Dimension::_internal_set_denotation(const ::std::string& value) {
11563   ::google::protobuf::internal::TSanWrite(&_impl_);
11564   _impl_._has_bits_[0] |= 0x00000001U;
11565   _impl_.denotation_.Set(value, GetArena());
11566 }
11567 inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::_internal_mutable_denotation() {
11568   ::google::protobuf::internal::TSanWrite(&_impl_);
11569   _impl_._has_bits_[0] |= 0x00000001U;
11570   return _impl_.denotation_.Mutable( GetArena());
11571 }
11572 inline ::std::string* PROTOBUF_NULLABLE TensorShapeProto_Dimension::release_denotation() {
11573   ::google::protobuf::internal::TSanWrite(&_impl_);
11574   // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
11575   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
11576     return nullptr;
11577   }
11578   _impl_._has_bits_[0] &= ~0x00000001U;
11579   auto* released = _impl_.denotation_.Release();
11580   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
11581     _impl_.denotation_.Set("", GetArena());
11582   }
11583   return released;
11584 }
11585 inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value) {
11586   ::google::protobuf::internal::TSanWrite(&_impl_);
11587   if (value != nullptr) {
11588     _impl_._has_bits_[0] |= 0x00000001U;
11589   } else {
11590     _impl_._has_bits_[0] &= ~0x00000001U;
11591   }
11592   _impl_.denotation_.SetAllocated(value, GetArena());
11593   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.denotation_.IsDefault()) {
11594     _impl_.denotation_.Set("", GetArena());
11595   }
11596   // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
11597 }
11598 
11599 inline bool TensorShapeProto_Dimension::has_value() const {
11600   return value_case() != VALUE_NOT_SET;
11601 }
11602 inline void TensorShapeProto_Dimension::clear_has_value() {
11603   _impl_._oneof_case_[0] = VALUE_NOT_SET;
11604 }
11605 inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
11606   return TensorShapeProto_Dimension::ValueCase(_impl_._oneof_case_[0]);
11607 }
11608 // -------------------------------------------------------------------
11609 
11610 // TensorShapeProto
11611 
11612 // repeated .onnx.TensorShapeProto.Dimension dim = 1;
11613 inline int TensorShapeProto::_internal_dim_size() const {
11614   return _internal_dim().size();
11615 }
11616 inline int TensorShapeProto::dim_size() const {
11617   return _internal_dim_size();
11618 }
11619 inline void TensorShapeProto::clear_dim() {
11620   ::google::protobuf::internal::TSanWrite(&_impl_);
11621   _impl_.dim_.Clear();
11622 }
11623 inline ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL TensorShapeProto::mutable_dim(int index)
11624     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11625   // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
11626   return _internal_mutable_dim()->Mutable(index);
11627 }
11628 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL TensorShapeProto::mutable_dim()
11629     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11630   // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
11631   ::google::protobuf::internal::TSanWrite(&_impl_);
11632   return _internal_mutable_dim();
11633 }
11634 inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const
11635     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11636   // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
11637   return _internal_dim().Get(index);
11638 }
11639 inline ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL TensorShapeProto::add_dim()
11640     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11641   ::google::protobuf::internal::TSanWrite(&_impl_);
11642   ::onnx::TensorShapeProto_Dimension* _add = _internal_mutable_dim()->Add();
11643   // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
11644   return _add;
11645 }
11646 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& TensorShapeProto::dim() const
11647     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11648   // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
11649   return _internal_dim();
11650 }
11651 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>&
11652 TensorShapeProto::_internal_dim() const {
11653   ::google::protobuf::internal::TSanRead(&_impl_);
11654   return _impl_.dim_;
11655 }
11656 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL
11657 TensorShapeProto::_internal_mutable_dim() {
11658   ::google::protobuf::internal::TSanRead(&_impl_);
11659   return &_impl_.dim_;
11660 }
11661 
11662 // -------------------------------------------------------------------
11663 
11664 // TypeProto_Tensor
11665 
11666 // optional int32 elem_type = 1;
11667 inline bool TypeProto_Tensor::has_elem_type() const {
11668   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
11669   return value;
11670 }
11671 inline void TypeProto_Tensor::clear_elem_type() {
11672   ::google::protobuf::internal::TSanWrite(&_impl_);
11673   _impl_.elem_type_ = 0;
11674   _impl_._has_bits_[0] &= ~0x00000002U;
11675 }
11676 inline ::int32_t TypeProto_Tensor::elem_type() const {
11677   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
11678   return _internal_elem_type();
11679 }
11680 inline void TypeProto_Tensor::set_elem_type(::int32_t value) {
11681   _internal_set_elem_type(value);
11682   _impl_._has_bits_[0] |= 0x00000002U;
11683   // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
11684 }
11685 inline ::int32_t TypeProto_Tensor::_internal_elem_type() const {
11686   ::google::protobuf::internal::TSanRead(&_impl_);
11687   return _impl_.elem_type_;
11688 }
11689 inline void TypeProto_Tensor::_internal_set_elem_type(::int32_t value) {
11690   ::google::protobuf::internal::TSanWrite(&_impl_);
11691   _impl_.elem_type_ = value;
11692 }
11693 
11694 // optional .onnx.TensorShapeProto shape = 2;
11695 inline bool TypeProto_Tensor::has_shape() const {
11696   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
11697   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
11698   return value;
11699 }
11700 inline void TypeProto_Tensor::clear_shape() {
11701   ::google::protobuf::internal::TSanWrite(&_impl_);
11702   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
11703   _impl_._has_bits_[0] &= ~0x00000001U;
11704 }
11705 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
11706   ::google::protobuf::internal::TSanRead(&_impl_);
11707   const ::onnx::TensorShapeProto* p = _impl_.shape_;
11708   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
11709 }
11710 inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11711   // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
11712   return _internal_shape();
11713 }
11714 inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
11715     ::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
11716   ::google::protobuf::internal::TSanWrite(&_impl_);
11717   if (GetArena() == nullptr) {
11718     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
11719   }
11720   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
11721   if (value != nullptr) {
11722     _impl_._has_bits_[0] |= 0x00000001U;
11723   } else {
11724     _impl_._has_bits_[0] &= ~0x00000001U;
11725   }
11726   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
11727 }
11728 inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_Tensor::release_shape() {
11729   ::google::protobuf::internal::TSanWrite(&_impl_);
11730 
11731   _impl_._has_bits_[0] &= ~0x00000001U;
11732   ::onnx::TensorShapeProto* released = _impl_.shape_;
11733   _impl_.shape_ = nullptr;
11734   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
11735     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11736     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11737     if (GetArena() == nullptr) {
11738       delete old;
11739     }
11740   } else {
11741     if (GetArena() != nullptr) {
11742       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11743     }
11744   }
11745   return released;
11746 }
11747 inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_Tensor::unsafe_arena_release_shape() {
11748   ::google::protobuf::internal::TSanWrite(&_impl_);
11749   // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)
11750 
11751   _impl_._has_bits_[0] &= ~0x00000001U;
11752   ::onnx::TensorShapeProto* temp = _impl_.shape_;
11753   _impl_.shape_ = nullptr;
11754   return temp;
11755 }
11756 inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_Tensor::_internal_mutable_shape() {
11757   ::google::protobuf::internal::TSanWrite(&_impl_);
11758   if (_impl_.shape_ == nullptr) {
11759     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
11760     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
11761   }
11762   return _impl_.shape_;
11763 }
11764 inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_Tensor::mutable_shape()
11765     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11766   _impl_._has_bits_[0] |= 0x00000001U;
11767   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
11768   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
11769   return _msg;
11770 }
11771 inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
11772   ::google::protobuf::Arena* message_arena = GetArena();
11773   ::google::protobuf::internal::TSanWrite(&_impl_);
11774   if (message_arena == nullptr) {
11775     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
11776   }
11777 
11778   if (value != nullptr) {
11779     ::google::protobuf::Arena* submessage_arena = value->GetArena();
11780     if (message_arena != submessage_arena) {
11781       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11782     }
11783     _impl_._has_bits_[0] |= 0x00000001U;
11784   } else {
11785     _impl_._has_bits_[0] &= ~0x00000001U;
11786   }
11787 
11788   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
11789   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
11790 }
11791 
11792 // -------------------------------------------------------------------
11793 
11794 // TypeProto_Sequence
11795 
11796 // optional .onnx.TypeProto elem_type = 1;
11797 inline bool TypeProto_Sequence::has_elem_type() const {
11798   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
11799   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
11800   return value;
11801 }
11802 inline void TypeProto_Sequence::clear_elem_type() {
11803   ::google::protobuf::internal::TSanWrite(&_impl_);
11804   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
11805   _impl_._has_bits_[0] &= ~0x00000001U;
11806 }
11807 inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
11808   ::google::protobuf::internal::TSanRead(&_impl_);
11809   const ::onnx::TypeProto* p = _impl_.elem_type_;
11810   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
11811 }
11812 inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11813   // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
11814   return _internal_elem_type();
11815 }
11816 inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(
11817     ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
11818   ::google::protobuf::internal::TSanWrite(&_impl_);
11819   if (GetArena() == nullptr) {
11820     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
11821   }
11822   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11823   if (value != nullptr) {
11824     _impl_._has_bits_[0] |= 0x00000001U;
11825   } else {
11826     _impl_._has_bits_[0] &= ~0x00000001U;
11827   }
11828   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
11829 }
11830 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Sequence::release_elem_type() {
11831   ::google::protobuf::internal::TSanWrite(&_impl_);
11832 
11833   _impl_._has_bits_[0] &= ~0x00000001U;
11834   ::onnx::TypeProto* released = _impl_.elem_type_;
11835   _impl_.elem_type_ = nullptr;
11836   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
11837     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11838     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11839     if (GetArena() == nullptr) {
11840       delete old;
11841     }
11842   } else {
11843     if (GetArena() != nullptr) {
11844       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11845     }
11846   }
11847   return released;
11848 }
11849 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Sequence::unsafe_arena_release_elem_type() {
11850   ::google::protobuf::internal::TSanWrite(&_impl_);
11851   // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)
11852 
11853   _impl_._has_bits_[0] &= ~0x00000001U;
11854   ::onnx::TypeProto* temp = _impl_.elem_type_;
11855   _impl_.elem_type_ = nullptr;
11856   return temp;
11857 }
11858 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Sequence::_internal_mutable_elem_type() {
11859   ::google::protobuf::internal::TSanWrite(&_impl_);
11860   if (_impl_.elem_type_ == nullptr) {
11861     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
11862     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
11863   }
11864   return _impl_.elem_type_;
11865 }
11866 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Sequence::mutable_elem_type()
11867     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11868   _impl_._has_bits_[0] |= 0x00000001U;
11869   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
11870   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
11871   return _msg;
11872 }
11873 inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
11874   ::google::protobuf::Arena* message_arena = GetArena();
11875   ::google::protobuf::internal::TSanWrite(&_impl_);
11876   if (message_arena == nullptr) {
11877     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
11878   }
11879 
11880   if (value != nullptr) {
11881     ::google::protobuf::Arena* submessage_arena = value->GetArena();
11882     if (message_arena != submessage_arena) {
11883       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
11884     }
11885     _impl_._has_bits_[0] |= 0x00000001U;
11886   } else {
11887     _impl_._has_bits_[0] &= ~0x00000001U;
11888   }
11889 
11890   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11891   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
11892 }
11893 
11894 // -------------------------------------------------------------------
11895 
11896 // TypeProto_Map
11897 
11898 // optional int32 key_type = 1;
11899 inline bool TypeProto_Map::has_key_type() const {
11900   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
11901   return value;
11902 }
11903 inline void TypeProto_Map::clear_key_type() {
11904   ::google::protobuf::internal::TSanWrite(&_impl_);
11905   _impl_.key_type_ = 0;
11906   _impl_._has_bits_[0] &= ~0x00000002U;
11907 }
11908 inline ::int32_t TypeProto_Map::key_type() const {
11909   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
11910   return _internal_key_type();
11911 }
11912 inline void TypeProto_Map::set_key_type(::int32_t value) {
11913   _internal_set_key_type(value);
11914   _impl_._has_bits_[0] |= 0x00000002U;
11915   // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
11916 }
11917 inline ::int32_t TypeProto_Map::_internal_key_type() const {
11918   ::google::protobuf::internal::TSanRead(&_impl_);
11919   return _impl_.key_type_;
11920 }
11921 inline void TypeProto_Map::_internal_set_key_type(::int32_t value) {
11922   ::google::protobuf::internal::TSanWrite(&_impl_);
11923   _impl_.key_type_ = value;
11924 }
11925 
11926 // optional .onnx.TypeProto value_type = 2;
11927 inline bool TypeProto_Map::has_value_type() const {
11928   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
11929   PROTOBUF_ASSUME(!value || _impl_.value_type_ != nullptr);
11930   return value;
11931 }
11932 inline void TypeProto_Map::clear_value_type() {
11933   ::google::protobuf::internal::TSanWrite(&_impl_);
11934   if (_impl_.value_type_ != nullptr) _impl_.value_type_->Clear();
11935   _impl_._has_bits_[0] &= ~0x00000001U;
11936 }
11937 inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
11938   ::google::protobuf::internal::TSanRead(&_impl_);
11939   const ::onnx::TypeProto* p = _impl_.value_type_;
11940   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
11941 }
11942 inline const ::onnx::TypeProto& TypeProto_Map::value_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
11943   // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
11944   return _internal_value_type();
11945 }
11946 inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(
11947     ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
11948   ::google::protobuf::internal::TSanWrite(&_impl_);
11949   if (GetArena() == nullptr) {
11950     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
11951   }
11952   _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
11953   if (value != nullptr) {
11954     _impl_._has_bits_[0] |= 0x00000001U;
11955   } else {
11956     _impl_._has_bits_[0] &= ~0x00000001U;
11957   }
11958   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
11959 }
11960 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Map::release_value_type() {
11961   ::google::protobuf::internal::TSanWrite(&_impl_);
11962 
11963   _impl_._has_bits_[0] &= ~0x00000001U;
11964   ::onnx::TypeProto* released = _impl_.value_type_;
11965   _impl_.value_type_ = nullptr;
11966   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
11967     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
11968     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11969     if (GetArena() == nullptr) {
11970       delete old;
11971     }
11972   } else {
11973     if (GetArena() != nullptr) {
11974       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
11975     }
11976   }
11977   return released;
11978 }
11979 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Map::unsafe_arena_release_value_type() {
11980   ::google::protobuf::internal::TSanWrite(&_impl_);
11981   // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)
11982 
11983   _impl_._has_bits_[0] &= ~0x00000001U;
11984   ::onnx::TypeProto* temp = _impl_.value_type_;
11985   _impl_.value_type_ = nullptr;
11986   return temp;
11987 }
11988 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Map::_internal_mutable_value_type() {
11989   ::google::protobuf::internal::TSanWrite(&_impl_);
11990   if (_impl_.value_type_ == nullptr) {
11991     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
11992     _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
11993   }
11994   return _impl_.value_type_;
11995 }
11996 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Map::mutable_value_type()
11997     ABSL_ATTRIBUTE_LIFETIME_BOUND {
11998   _impl_._has_bits_[0] |= 0x00000001U;
11999   ::onnx::TypeProto* _msg = _internal_mutable_value_type();
12000   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
12001   return _msg;
12002 }
12003 inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
12004   ::google::protobuf::Arena* message_arena = GetArena();
12005   ::google::protobuf::internal::TSanWrite(&_impl_);
12006   if (message_arena == nullptr) {
12007     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
12008   }
12009 
12010   if (value != nullptr) {
12011     ::google::protobuf::Arena* submessage_arena = value->GetArena();
12012     if (message_arena != submessage_arena) {
12013       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
12014     }
12015     _impl_._has_bits_[0] |= 0x00000001U;
12016   } else {
12017     _impl_._has_bits_[0] &= ~0x00000001U;
12018   }
12019 
12020   _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
12021   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
12022 }
12023 
12024 // -------------------------------------------------------------------
12025 
12026 // TypeProto_Optional
12027 
12028 // optional .onnx.TypeProto elem_type = 1;
12029 inline bool TypeProto_Optional::has_elem_type() const {
12030   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
12031   PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
12032   return value;
12033 }
12034 inline void TypeProto_Optional::clear_elem_type() {
12035   ::google::protobuf::internal::TSanWrite(&_impl_);
12036   if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
12037   _impl_._has_bits_[0] &= ~0x00000001U;
12038 }
12039 inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
12040   ::google::protobuf::internal::TSanRead(&_impl_);
12041   const ::onnx::TypeProto* p = _impl_.elem_type_;
12042   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
12043 }
12044 inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12045   // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
12046   return _internal_elem_type();
12047 }
12048 inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(
12049     ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
12050   ::google::protobuf::internal::TSanWrite(&_impl_);
12051   if (GetArena() == nullptr) {
12052     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
12053   }
12054   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
12055   if (value != nullptr) {
12056     _impl_._has_bits_[0] |= 0x00000001U;
12057   } else {
12058     _impl_._has_bits_[0] &= ~0x00000001U;
12059   }
12060   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
12061 }
12062 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Optional::release_elem_type() {
12063   ::google::protobuf::internal::TSanWrite(&_impl_);
12064 
12065   _impl_._has_bits_[0] &= ~0x00000001U;
12066   ::onnx::TypeProto* released = _impl_.elem_type_;
12067   _impl_.elem_type_ = nullptr;
12068   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
12069     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
12070     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12071     if (GetArena() == nullptr) {
12072       delete old;
12073     }
12074   } else {
12075     if (GetArena() != nullptr) {
12076       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12077     }
12078   }
12079   return released;
12080 }
12081 inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Optional::unsafe_arena_release_elem_type() {
12082   ::google::protobuf::internal::TSanWrite(&_impl_);
12083   // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)
12084 
12085   _impl_._has_bits_[0] &= ~0x00000001U;
12086   ::onnx::TypeProto* temp = _impl_.elem_type_;
12087   _impl_.elem_type_ = nullptr;
12088   return temp;
12089 }
12090 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Optional::_internal_mutable_elem_type() {
12091   ::google::protobuf::internal::TSanWrite(&_impl_);
12092   if (_impl_.elem_type_ == nullptr) {
12093     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
12094     _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
12095   }
12096   return _impl_.elem_type_;
12097 }
12098 inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Optional::mutable_elem_type()
12099     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12100   _impl_._has_bits_[0] |= 0x00000001U;
12101   ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
12102   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
12103   return _msg;
12104 }
12105 inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
12106   ::google::protobuf::Arena* message_arena = GetArena();
12107   ::google::protobuf::internal::TSanWrite(&_impl_);
12108   if (message_arena == nullptr) {
12109     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
12110   }
12111 
12112   if (value != nullptr) {
12113     ::google::protobuf::Arena* submessage_arena = value->GetArena();
12114     if (message_arena != submessage_arena) {
12115       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
12116     }
12117     _impl_._has_bits_[0] |= 0x00000001U;
12118   } else {
12119     _impl_._has_bits_[0] &= ~0x00000001U;
12120   }
12121 
12122   _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
12123   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
12124 }
12125 
12126 // -------------------------------------------------------------------
12127 
12128 // TypeProto_SparseTensor
12129 
12130 // optional int32 elem_type = 1;
12131 inline bool TypeProto_SparseTensor::has_elem_type() const {
12132   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
12133   return value;
12134 }
12135 inline void TypeProto_SparseTensor::clear_elem_type() {
12136   ::google::protobuf::internal::TSanWrite(&_impl_);
12137   _impl_.elem_type_ = 0;
12138   _impl_._has_bits_[0] &= ~0x00000002U;
12139 }
12140 inline ::int32_t TypeProto_SparseTensor::elem_type() const {
12141   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
12142   return _internal_elem_type();
12143 }
12144 inline void TypeProto_SparseTensor::set_elem_type(::int32_t value) {
12145   _internal_set_elem_type(value);
12146   _impl_._has_bits_[0] |= 0x00000002U;
12147   // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
12148 }
12149 inline ::int32_t TypeProto_SparseTensor::_internal_elem_type() const {
12150   ::google::protobuf::internal::TSanRead(&_impl_);
12151   return _impl_.elem_type_;
12152 }
12153 inline void TypeProto_SparseTensor::_internal_set_elem_type(::int32_t value) {
12154   ::google::protobuf::internal::TSanWrite(&_impl_);
12155   _impl_.elem_type_ = value;
12156 }
12157 
12158 // optional .onnx.TensorShapeProto shape = 2;
12159 inline bool TypeProto_SparseTensor::has_shape() const {
12160   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
12161   PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
12162   return value;
12163 }
12164 inline void TypeProto_SparseTensor::clear_shape() {
12165   ::google::protobuf::internal::TSanWrite(&_impl_);
12166   if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
12167   _impl_._has_bits_[0] &= ~0x00000001U;
12168 }
12169 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
12170   ::google::protobuf::internal::TSanRead(&_impl_);
12171   const ::onnx::TensorShapeProto* p = _impl_.shape_;
12172   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
12173 }
12174 inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12175   // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
12176   return _internal_shape();
12177 }
12178 inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(
12179     ::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
12180   ::google::protobuf::internal::TSanWrite(&_impl_);
12181   if (GetArena() == nullptr) {
12182     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
12183   }
12184   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
12185   if (value != nullptr) {
12186     _impl_._has_bits_[0] |= 0x00000001U;
12187   } else {
12188     _impl_._has_bits_[0] &= ~0x00000001U;
12189   }
12190   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
12191 }
12192 inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_SparseTensor::release_shape() {
12193   ::google::protobuf::internal::TSanWrite(&_impl_);
12194 
12195   _impl_._has_bits_[0] &= ~0x00000001U;
12196   ::onnx::TensorShapeProto* released = _impl_.shape_;
12197   _impl_.shape_ = nullptr;
12198   if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
12199     auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
12200     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12201     if (GetArena() == nullptr) {
12202       delete old;
12203     }
12204   } else {
12205     if (GetArena() != nullptr) {
12206       released = ::google::protobuf::internal::DuplicateIfNonNull(released);
12207     }
12208   }
12209   return released;
12210 }
12211 inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_SparseTensor::unsafe_arena_release_shape() {
12212   ::google::protobuf::internal::TSanWrite(&_impl_);
12213   // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)
12214 
12215   _impl_._has_bits_[0] &= ~0x00000001U;
12216   ::onnx::TensorShapeProto* temp = _impl_.shape_;
12217   _impl_.shape_ = nullptr;
12218   return temp;
12219 }
12220 inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_SparseTensor::_internal_mutable_shape() {
12221   ::google::protobuf::internal::TSanWrite(&_impl_);
12222   if (_impl_.shape_ == nullptr) {
12223     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
12224     _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
12225   }
12226   return _impl_.shape_;
12227 }
12228 inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_SparseTensor::mutable_shape()
12229     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12230   _impl_._has_bits_[0] |= 0x00000001U;
12231   ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
12232   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
12233   return _msg;
12234 }
12235 inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
12236   ::google::protobuf::Arena* message_arena = GetArena();
12237   ::google::protobuf::internal::TSanWrite(&_impl_);
12238   if (message_arena == nullptr) {
12239     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
12240   }
12241 
12242   if (value != nullptr) {
12243     ::google::protobuf::Arena* submessage_arena = value->GetArena();
12244     if (message_arena != submessage_arena) {
12245       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
12246     }
12247     _impl_._has_bits_[0] |= 0x00000001U;
12248   } else {
12249     _impl_._has_bits_[0] &= ~0x00000001U;
12250   }
12251 
12252   _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
12253   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
12254 }
12255 
12256 // -------------------------------------------------------------------
12257 
12258 // TypeProto_Opaque
12259 
12260 // optional string domain = 1;
12261 inline bool TypeProto_Opaque::has_domain() const {
12262   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
12263   return value;
12264 }
12265 inline void TypeProto_Opaque::clear_domain() {
12266   ::google::protobuf::internal::TSanWrite(&_impl_);
12267   _impl_.domain_.ClearToEmpty();
12268   _impl_._has_bits_[0] &= ~0x00000001U;
12269 }
12270 inline const ::std::string& TypeProto_Opaque::domain() const
12271     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12272   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.domain)
12273   return _internal_domain();
12274 }
12275 template <typename Arg_, typename... Args_>
12276 PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_domain(Arg_&& arg, Args_... args) {
12277   ::google::protobuf::internal::TSanWrite(&_impl_);
12278   _impl_._has_bits_[0] |= 0x00000001U;
12279   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12280   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.domain)
12281 }
12282 inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::mutable_domain()
12283     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12284   ::std::string* _s = _internal_mutable_domain();
12285   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.domain)
12286   return _s;
12287 }
12288 inline const ::std::string& TypeProto_Opaque::_internal_domain() const {
12289   ::google::protobuf::internal::TSanRead(&_impl_);
12290   return _impl_.domain_.Get();
12291 }
12292 inline void TypeProto_Opaque::_internal_set_domain(const ::std::string& value) {
12293   ::google::protobuf::internal::TSanWrite(&_impl_);
12294   _impl_._has_bits_[0] |= 0x00000001U;
12295   _impl_.domain_.Set(value, GetArena());
12296 }
12297 inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::_internal_mutable_domain() {
12298   ::google::protobuf::internal::TSanWrite(&_impl_);
12299   _impl_._has_bits_[0] |= 0x00000001U;
12300   return _impl_.domain_.Mutable( GetArena());
12301 }
12302 inline ::std::string* PROTOBUF_NULLABLE TypeProto_Opaque::release_domain() {
12303   ::google::protobuf::internal::TSanWrite(&_impl_);
12304   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.domain)
12305   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
12306     return nullptr;
12307   }
12308   _impl_._has_bits_[0] &= ~0x00000001U;
12309   auto* released = _impl_.domain_.Release();
12310   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
12311     _impl_.domain_.Set("", GetArena());
12312   }
12313   return released;
12314 }
12315 inline void TypeProto_Opaque::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
12316   ::google::protobuf::internal::TSanWrite(&_impl_);
12317   if (value != nullptr) {
12318     _impl_._has_bits_[0] |= 0x00000001U;
12319   } else {
12320     _impl_._has_bits_[0] &= ~0x00000001U;
12321   }
12322   _impl_.domain_.SetAllocated(value, GetArena());
12323   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
12324     _impl_.domain_.Set("", GetArena());
12325   }
12326   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.domain)
12327 }
12328 
12329 // optional string name = 2;
12330 inline bool TypeProto_Opaque::has_name() const {
12331   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
12332   return value;
12333 }
12334 inline void TypeProto_Opaque::clear_name() {
12335   ::google::protobuf::internal::TSanWrite(&_impl_);
12336   _impl_.name_.ClearToEmpty();
12337   _impl_._has_bits_[0] &= ~0x00000002U;
12338 }
12339 inline const ::std::string& TypeProto_Opaque::name() const
12340     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12341   // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.name)
12342   return _internal_name();
12343 }
12344 template <typename Arg_, typename... Args_>
12345 PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_name(Arg_&& arg, Args_... args) {
12346   ::google::protobuf::internal::TSanWrite(&_impl_);
12347   _impl_._has_bits_[0] |= 0x00000002U;
12348   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12349   // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.name)
12350 }
12351 inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::mutable_name()
12352     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12353   ::std::string* _s = _internal_mutable_name();
12354   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.name)
12355   return _s;
12356 }
12357 inline const ::std::string& TypeProto_Opaque::_internal_name() const {
12358   ::google::protobuf::internal::TSanRead(&_impl_);
12359   return _impl_.name_.Get();
12360 }
12361 inline void TypeProto_Opaque::_internal_set_name(const ::std::string& value) {
12362   ::google::protobuf::internal::TSanWrite(&_impl_);
12363   _impl_._has_bits_[0] |= 0x00000002U;
12364   _impl_.name_.Set(value, GetArena());
12365 }
12366 inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::_internal_mutable_name() {
12367   ::google::protobuf::internal::TSanWrite(&_impl_);
12368   _impl_._has_bits_[0] |= 0x00000002U;
12369   return _impl_.name_.Mutable( GetArena());
12370 }
12371 inline ::std::string* PROTOBUF_NULLABLE TypeProto_Opaque::release_name() {
12372   ::google::protobuf::internal::TSanWrite(&_impl_);
12373   // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.name)
12374   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
12375     return nullptr;
12376   }
12377   _impl_._has_bits_[0] &= ~0x00000002U;
12378   auto* released = _impl_.name_.Release();
12379   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
12380     _impl_.name_.Set("", GetArena());
12381   }
12382   return released;
12383 }
12384 inline void TypeProto_Opaque::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
12385   ::google::protobuf::internal::TSanWrite(&_impl_);
12386   if (value != nullptr) {
12387     _impl_._has_bits_[0] |= 0x00000002U;
12388   } else {
12389     _impl_._has_bits_[0] &= ~0x00000002U;
12390   }
12391   _impl_.name_.SetAllocated(value, GetArena());
12392   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
12393     _impl_.name_.Set("", GetArena());
12394   }
12395   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.name)
12396 }
12397 
12398 // -------------------------------------------------------------------
12399 
12400 // TypeProto
12401 
12402 // .onnx.TypeProto.Tensor tensor_type = 1;
12403 inline bool TypeProto::has_tensor_type() const {
12404   return value_case() == kTensorType;
12405 }
12406 inline bool TypeProto::_internal_has_tensor_type() const {
12407   return value_case() == kTensorType;
12408 }
12409 inline void TypeProto::set_has_tensor_type() {
12410   _impl_._oneof_case_[0] = kTensorType;
12411 }
12412 inline void TypeProto::clear_tensor_type() {
12413   ::google::protobuf::internal::TSanWrite(&_impl_);
12414   if (value_case() == kTensorType) {
12415     if (GetArena() == nullptr) {
12416       delete _impl_.value_.tensor_type_;
12417     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12418       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.tensor_type_);
12419     }
12420     clear_has_value();
12421   }
12422 }
12423 inline ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE TypeProto::release_tensor_type() {
12424   // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
12425   if (value_case() == kTensorType) {
12426     clear_has_value();
12427     auto* temp = reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
12428     if (GetArena() != nullptr) {
12429       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12430     }
12431     _impl_.value_.tensor_type_ = nullptr;
12432     return temp;
12433   } else {
12434     return nullptr;
12435   }
12436 }
12437 inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
12438   return value_case() == kTensorType ? *reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_) : reinterpret_cast<::onnx::TypeProto_Tensor&>(::onnx::_TypeProto_Tensor_default_instance_);
12439 }
12440 inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12441   // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
12442   return _internal_tensor_type();
12443 }
12444 inline ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_tensor_type() {
12445   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
12446   if (value_case() == kTensorType) {
12447     clear_has_value();
12448     auto* temp = reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
12449     _impl_.value_.tensor_type_ = nullptr;
12450     return temp;
12451   } else {
12452     return nullptr;
12453   }
12454 }
12455 inline void TypeProto::unsafe_arena_set_allocated_tensor_type(
12456     ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value) {
12457   // We rely on the oneof clear method to free the earlier contents
12458   // of this oneof. We can directly use the pointer we're given to
12459   // set the new value.
12460   clear_value();
12461   if (value) {
12462     set_has_tensor_type();
12463     _impl_.value_.tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12464   }
12465   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
12466 }
12467 inline ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL TypeProto::_internal_mutable_tensor_type() {
12468   if (value_case() != kTensorType) {
12469     clear_value();
12470     set_has_tensor_type();
12471     _impl_.value_.tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(
12472         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Tensor>(GetArena()));
12473   }
12474   return reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
12475 }
12476 inline ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL TypeProto::mutable_tensor_type()
12477     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12478   ::onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
12479   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
12480   return _msg;
12481 }
12482 
12483 // .onnx.TypeProto.Sequence sequence_type = 4;
12484 inline bool TypeProto::has_sequence_type() const {
12485   return value_case() == kSequenceType;
12486 }
12487 inline bool TypeProto::_internal_has_sequence_type() const {
12488   return value_case() == kSequenceType;
12489 }
12490 inline void TypeProto::set_has_sequence_type() {
12491   _impl_._oneof_case_[0] = kSequenceType;
12492 }
12493 inline void TypeProto::clear_sequence_type() {
12494   ::google::protobuf::internal::TSanWrite(&_impl_);
12495   if (value_case() == kSequenceType) {
12496     if (GetArena() == nullptr) {
12497       delete _impl_.value_.sequence_type_;
12498     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12499       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sequence_type_);
12500     }
12501     clear_has_value();
12502   }
12503 }
12504 inline ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE TypeProto::release_sequence_type() {
12505   // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
12506   if (value_case() == kSequenceType) {
12507     clear_has_value();
12508     auto* temp = reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
12509     if (GetArena() != nullptr) {
12510       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12511     }
12512     _impl_.value_.sequence_type_ = nullptr;
12513     return temp;
12514   } else {
12515     return nullptr;
12516   }
12517 }
12518 inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
12519   return value_case() == kSequenceType ? *reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_) : reinterpret_cast<::onnx::TypeProto_Sequence&>(::onnx::_TypeProto_Sequence_default_instance_);
12520 }
12521 inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12522   // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
12523   return _internal_sequence_type();
12524 }
12525 inline ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_sequence_type() {
12526   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
12527   if (value_case() == kSequenceType) {
12528     clear_has_value();
12529     auto* temp = reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
12530     _impl_.value_.sequence_type_ = nullptr;
12531     return temp;
12532   } else {
12533     return nullptr;
12534   }
12535 }
12536 inline void TypeProto::unsafe_arena_set_allocated_sequence_type(
12537     ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value) {
12538   // We rely on the oneof clear method to free the earlier contents
12539   // of this oneof. We can directly use the pointer we're given to
12540   // set the new value.
12541   clear_value();
12542   if (value) {
12543     set_has_sequence_type();
12544     _impl_.value_.sequence_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12545   }
12546   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
12547 }
12548 inline ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL TypeProto::_internal_mutable_sequence_type() {
12549   if (value_case() != kSequenceType) {
12550     clear_value();
12551     set_has_sequence_type();
12552     _impl_.value_.sequence_type_ = reinterpret_cast<::google::protobuf::Message*>(
12553         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Sequence>(GetArena()));
12554   }
12555   return reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
12556 }
12557 inline ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL TypeProto::mutable_sequence_type()
12558     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12559   ::onnx::TypeProto_Sequence* _msg = _internal_mutable_sequence_type();
12560   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
12561   return _msg;
12562 }
12563 
12564 // .onnx.TypeProto.Map map_type = 5;
12565 inline bool TypeProto::has_map_type() const {
12566   return value_case() == kMapType;
12567 }
12568 inline bool TypeProto::_internal_has_map_type() const {
12569   return value_case() == kMapType;
12570 }
12571 inline void TypeProto::set_has_map_type() {
12572   _impl_._oneof_case_[0] = kMapType;
12573 }
12574 inline void TypeProto::clear_map_type() {
12575   ::google::protobuf::internal::TSanWrite(&_impl_);
12576   if (value_case() == kMapType) {
12577     if (GetArena() == nullptr) {
12578       delete _impl_.value_.map_type_;
12579     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12580       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.map_type_);
12581     }
12582     clear_has_value();
12583   }
12584 }
12585 inline ::onnx::TypeProto_Map* PROTOBUF_NULLABLE TypeProto::release_map_type() {
12586   // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
12587   if (value_case() == kMapType) {
12588     clear_has_value();
12589     auto* temp = reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
12590     if (GetArena() != nullptr) {
12591       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12592     }
12593     _impl_.value_.map_type_ = nullptr;
12594     return temp;
12595   } else {
12596     return nullptr;
12597   }
12598 }
12599 inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
12600   return value_case() == kMapType ? *reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_) : reinterpret_cast<::onnx::TypeProto_Map&>(::onnx::_TypeProto_Map_default_instance_);
12601 }
12602 inline const ::onnx::TypeProto_Map& TypeProto::map_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12603   // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
12604   return _internal_map_type();
12605 }
12606 inline ::onnx::TypeProto_Map* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_map_type() {
12607   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
12608   if (value_case() == kMapType) {
12609     clear_has_value();
12610     auto* temp = reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
12611     _impl_.value_.map_type_ = nullptr;
12612     return temp;
12613   } else {
12614     return nullptr;
12615   }
12616 }
12617 inline void TypeProto::unsafe_arena_set_allocated_map_type(
12618     ::onnx::TypeProto_Map* PROTOBUF_NULLABLE value) {
12619   // We rely on the oneof clear method to free the earlier contents
12620   // of this oneof. We can directly use the pointer we're given to
12621   // set the new value.
12622   clear_value();
12623   if (value) {
12624     set_has_map_type();
12625     _impl_.value_.map_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12626   }
12627   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
12628 }
12629 inline ::onnx::TypeProto_Map* PROTOBUF_NONNULL TypeProto::_internal_mutable_map_type() {
12630   if (value_case() != kMapType) {
12631     clear_value();
12632     set_has_map_type();
12633     _impl_.value_.map_type_ = reinterpret_cast<::google::protobuf::Message*>(
12634         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Map>(GetArena()));
12635   }
12636   return reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
12637 }
12638 inline ::onnx::TypeProto_Map* PROTOBUF_NONNULL TypeProto::mutable_map_type()
12639     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12640   ::onnx::TypeProto_Map* _msg = _internal_mutable_map_type();
12641   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
12642   return _msg;
12643 }
12644 
12645 // .onnx.TypeProto.Optional optional_type = 9;
12646 inline bool TypeProto::has_optional_type() const {
12647   return value_case() == kOptionalType;
12648 }
12649 inline bool TypeProto::_internal_has_optional_type() const {
12650   return value_case() == kOptionalType;
12651 }
12652 inline void TypeProto::set_has_optional_type() {
12653   _impl_._oneof_case_[0] = kOptionalType;
12654 }
12655 inline void TypeProto::clear_optional_type() {
12656   ::google::protobuf::internal::TSanWrite(&_impl_);
12657   if (value_case() == kOptionalType) {
12658     if (GetArena() == nullptr) {
12659       delete _impl_.value_.optional_type_;
12660     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12661       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.optional_type_);
12662     }
12663     clear_has_value();
12664   }
12665 }
12666 inline ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE TypeProto::release_optional_type() {
12667   // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
12668   if (value_case() == kOptionalType) {
12669     clear_has_value();
12670     auto* temp = reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
12671     if (GetArena() != nullptr) {
12672       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12673     }
12674     _impl_.value_.optional_type_ = nullptr;
12675     return temp;
12676   } else {
12677     return nullptr;
12678   }
12679 }
12680 inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
12681   return value_case() == kOptionalType ? *reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_) : reinterpret_cast<::onnx::TypeProto_Optional&>(::onnx::_TypeProto_Optional_default_instance_);
12682 }
12683 inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12684   // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
12685   return _internal_optional_type();
12686 }
12687 inline ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_optional_type() {
12688   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
12689   if (value_case() == kOptionalType) {
12690     clear_has_value();
12691     auto* temp = reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
12692     _impl_.value_.optional_type_ = nullptr;
12693     return temp;
12694   } else {
12695     return nullptr;
12696   }
12697 }
12698 inline void TypeProto::unsafe_arena_set_allocated_optional_type(
12699     ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value) {
12700   // We rely on the oneof clear method to free the earlier contents
12701   // of this oneof. We can directly use the pointer we're given to
12702   // set the new value.
12703   clear_value();
12704   if (value) {
12705     set_has_optional_type();
12706     _impl_.value_.optional_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12707   }
12708   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
12709 }
12710 inline ::onnx::TypeProto_Optional* PROTOBUF_NONNULL TypeProto::_internal_mutable_optional_type() {
12711   if (value_case() != kOptionalType) {
12712     clear_value();
12713     set_has_optional_type();
12714     _impl_.value_.optional_type_ = reinterpret_cast<::google::protobuf::Message*>(
12715         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Optional>(GetArena()));
12716   }
12717   return reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
12718 }
12719 inline ::onnx::TypeProto_Optional* PROTOBUF_NONNULL TypeProto::mutable_optional_type()
12720     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12721   ::onnx::TypeProto_Optional* _msg = _internal_mutable_optional_type();
12722   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
12723   return _msg;
12724 }
12725 
12726 // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
12727 inline bool TypeProto::has_sparse_tensor_type() const {
12728   return value_case() == kSparseTensorType;
12729 }
12730 inline bool TypeProto::_internal_has_sparse_tensor_type() const {
12731   return value_case() == kSparseTensorType;
12732 }
12733 inline void TypeProto::set_has_sparse_tensor_type() {
12734   _impl_._oneof_case_[0] = kSparseTensorType;
12735 }
12736 inline void TypeProto::clear_sparse_tensor_type() {
12737   ::google::protobuf::internal::TSanWrite(&_impl_);
12738   if (value_case() == kSparseTensorType) {
12739     if (GetArena() == nullptr) {
12740       delete _impl_.value_.sparse_tensor_type_;
12741     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12742       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sparse_tensor_type_);
12743     }
12744     clear_has_value();
12745   }
12746 }
12747 inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE TypeProto::release_sparse_tensor_type() {
12748   // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
12749   if (value_case() == kSparseTensorType) {
12750     clear_has_value();
12751     auto* temp = reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
12752     if (GetArena() != nullptr) {
12753       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12754     }
12755     _impl_.value_.sparse_tensor_type_ = nullptr;
12756     return temp;
12757   } else {
12758     return nullptr;
12759   }
12760 }
12761 inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
12762   return value_case() == kSparseTensorType ? *reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_) : reinterpret_cast<::onnx::TypeProto_SparseTensor&>(::onnx::_TypeProto_SparseTensor_default_instance_);
12763 }
12764 inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12765   // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
12766   return _internal_sparse_tensor_type();
12767 }
12768 inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_sparse_tensor_type() {
12769   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
12770   if (value_case() == kSparseTensorType) {
12771     clear_has_value();
12772     auto* temp = reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
12773     _impl_.value_.sparse_tensor_type_ = nullptr;
12774     return temp;
12775   } else {
12776     return nullptr;
12777   }
12778 }
12779 inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(
12780     ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value) {
12781   // We rely on the oneof clear method to free the earlier contents
12782   // of this oneof. We can directly use the pointer we're given to
12783   // set the new value.
12784   clear_value();
12785   if (value) {
12786     set_has_sparse_tensor_type();
12787     _impl_.value_.sparse_tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12788   }
12789   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
12790 }
12791 inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL TypeProto::_internal_mutable_sparse_tensor_type() {
12792   if (value_case() != kSparseTensorType) {
12793     clear_value();
12794     set_has_sparse_tensor_type();
12795     _impl_.value_.sparse_tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(
12796         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_SparseTensor>(GetArena()));
12797   }
12798   return reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
12799 }
12800 inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL TypeProto::mutable_sparse_tensor_type()
12801     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12802   ::onnx::TypeProto_SparseTensor* _msg = _internal_mutable_sparse_tensor_type();
12803   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
12804   return _msg;
12805 }
12806 
12807 // .onnx.TypeProto.Opaque opaque_type = 7;
12808 inline bool TypeProto::has_opaque_type() const {
12809   return value_case() == kOpaqueType;
12810 }
12811 inline bool TypeProto::_internal_has_opaque_type() const {
12812   return value_case() == kOpaqueType;
12813 }
12814 inline void TypeProto::set_has_opaque_type() {
12815   _impl_._oneof_case_[0] = kOpaqueType;
12816 }
12817 inline void TypeProto::clear_opaque_type() {
12818   ::google::protobuf::internal::TSanWrite(&_impl_);
12819   if (value_case() == kOpaqueType) {
12820     if (GetArena() == nullptr) {
12821       delete _impl_.value_.opaque_type_;
12822     } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
12823       ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.opaque_type_);
12824     }
12825     clear_has_value();
12826   }
12827 }
12828 inline ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE TypeProto::release_opaque_type() {
12829   // @@protoc_insertion_point(field_release:onnx.TypeProto.opaque_type)
12830   if (value_case() == kOpaqueType) {
12831     clear_has_value();
12832     auto* temp = reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
12833     if (GetArena() != nullptr) {
12834       temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
12835     }
12836     _impl_.value_.opaque_type_ = nullptr;
12837     return temp;
12838   } else {
12839     return nullptr;
12840   }
12841 }
12842 inline const ::onnx::TypeProto_Opaque& TypeProto::_internal_opaque_type() const {
12843   return value_case() == kOpaqueType ? *reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_) : reinterpret_cast<::onnx::TypeProto_Opaque&>(::onnx::_TypeProto_Opaque_default_instance_);
12844 }
12845 inline const ::onnx::TypeProto_Opaque& TypeProto::opaque_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
12846   // @@protoc_insertion_point(field_get:onnx.TypeProto.opaque_type)
12847   return _internal_opaque_type();
12848 }
12849 inline ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_opaque_type() {
12850   // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.opaque_type)
12851   if (value_case() == kOpaqueType) {
12852     clear_has_value();
12853     auto* temp = reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
12854     _impl_.value_.opaque_type_ = nullptr;
12855     return temp;
12856   } else {
12857     return nullptr;
12858   }
12859 }
12860 inline void TypeProto::unsafe_arena_set_allocated_opaque_type(
12861     ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value) {
12862   // We rely on the oneof clear method to free the earlier contents
12863   // of this oneof. We can directly use the pointer we're given to
12864   // set the new value.
12865   clear_value();
12866   if (value) {
12867     set_has_opaque_type();
12868     _impl_.value_.opaque_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
12869   }
12870   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.opaque_type)
12871 }
12872 inline ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL TypeProto::_internal_mutable_opaque_type() {
12873   if (value_case() != kOpaqueType) {
12874     clear_value();
12875     set_has_opaque_type();
12876     _impl_.value_.opaque_type_ = reinterpret_cast<::google::protobuf::Message*>(
12877         ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Opaque>(GetArena()));
12878   }
12879   return reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
12880 }
12881 inline ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL TypeProto::mutable_opaque_type()
12882     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12883   ::onnx::TypeProto_Opaque* _msg = _internal_mutable_opaque_type();
12884   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.opaque_type)
12885   return _msg;
12886 }
12887 
12888 // optional string denotation = 6;
12889 inline bool TypeProto::has_denotation() const {
12890   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
12891   return value;
12892 }
12893 inline void TypeProto::clear_denotation() {
12894   ::google::protobuf::internal::TSanWrite(&_impl_);
12895   _impl_.denotation_.ClearToEmpty();
12896   _impl_._has_bits_[0] &= ~0x00000001U;
12897 }
12898 inline const ::std::string& TypeProto::denotation() const
12899     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12900   // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
12901   return _internal_denotation();
12902 }
12903 template <typename Arg_, typename... Args_>
12904 PROTOBUF_ALWAYS_INLINE void TypeProto::set_denotation(Arg_&& arg, Args_... args) {
12905   ::google::protobuf::internal::TSanWrite(&_impl_);
12906   _impl_._has_bits_[0] |= 0x00000001U;
12907   _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12908   // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
12909 }
12910 inline ::std::string* PROTOBUF_NONNULL TypeProto::mutable_denotation()
12911     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12912   ::std::string* _s = _internal_mutable_denotation();
12913   // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
12914   return _s;
12915 }
12916 inline const ::std::string& TypeProto::_internal_denotation() const {
12917   ::google::protobuf::internal::TSanRead(&_impl_);
12918   return _impl_.denotation_.Get();
12919 }
12920 inline void TypeProto::_internal_set_denotation(const ::std::string& value) {
12921   ::google::protobuf::internal::TSanWrite(&_impl_);
12922   _impl_._has_bits_[0] |= 0x00000001U;
12923   _impl_.denotation_.Set(value, GetArena());
12924 }
12925 inline ::std::string* PROTOBUF_NONNULL TypeProto::_internal_mutable_denotation() {
12926   ::google::protobuf::internal::TSanWrite(&_impl_);
12927   _impl_._has_bits_[0] |= 0x00000001U;
12928   return _impl_.denotation_.Mutable( GetArena());
12929 }
12930 inline ::std::string* PROTOBUF_NULLABLE TypeProto::release_denotation() {
12931   ::google::protobuf::internal::TSanWrite(&_impl_);
12932   // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
12933   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
12934     return nullptr;
12935   }
12936   _impl_._has_bits_[0] &= ~0x00000001U;
12937   auto* released = _impl_.denotation_.Release();
12938   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
12939     _impl_.denotation_.Set("", GetArena());
12940   }
12941   return released;
12942 }
12943 inline void TypeProto::set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value) {
12944   ::google::protobuf::internal::TSanWrite(&_impl_);
12945   if (value != nullptr) {
12946     _impl_._has_bits_[0] |= 0x00000001U;
12947   } else {
12948     _impl_._has_bits_[0] &= ~0x00000001U;
12949   }
12950   _impl_.denotation_.SetAllocated(value, GetArena());
12951   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.denotation_.IsDefault()) {
12952     _impl_.denotation_.Set("", GetArena());
12953   }
12954   // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
12955 }
12956 
12957 inline bool TypeProto::has_value() const {
12958   return value_case() != VALUE_NOT_SET;
12959 }
12960 inline void TypeProto::clear_has_value() {
12961   _impl_._oneof_case_[0] = VALUE_NOT_SET;
12962 }
12963 inline TypeProto::ValueCase TypeProto::value_case() const {
12964   return TypeProto::ValueCase(_impl_._oneof_case_[0]);
12965 }
12966 // -------------------------------------------------------------------
12967 
12968 // OperatorSetIdProto
12969 
12970 // optional string domain = 1;
12971 inline bool OperatorSetIdProto::has_domain() const {
12972   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
12973   return value;
12974 }
12975 inline void OperatorSetIdProto::clear_domain() {
12976   ::google::protobuf::internal::TSanWrite(&_impl_);
12977   _impl_.domain_.ClearToEmpty();
12978   _impl_._has_bits_[0] &= ~0x00000001U;
12979 }
12980 inline const ::std::string& OperatorSetIdProto::domain() const
12981     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12982   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
12983   return _internal_domain();
12984 }
12985 template <typename Arg_, typename... Args_>
12986 PROTOBUF_ALWAYS_INLINE void OperatorSetIdProto::set_domain(Arg_&& arg, Args_... args) {
12987   ::google::protobuf::internal::TSanWrite(&_impl_);
12988   _impl_._has_bits_[0] |= 0x00000001U;
12989   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
12990   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
12991 }
12992 inline ::std::string* PROTOBUF_NONNULL OperatorSetIdProto::mutable_domain()
12993     ABSL_ATTRIBUTE_LIFETIME_BOUND {
12994   ::std::string* _s = _internal_mutable_domain();
12995   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
12996   return _s;
12997 }
12998 inline const ::std::string& OperatorSetIdProto::_internal_domain() const {
12999   ::google::protobuf::internal::TSanRead(&_impl_);
13000   return _impl_.domain_.Get();
13001 }
13002 inline void OperatorSetIdProto::_internal_set_domain(const ::std::string& value) {
13003   ::google::protobuf::internal::TSanWrite(&_impl_);
13004   _impl_._has_bits_[0] |= 0x00000001U;
13005   _impl_.domain_.Set(value, GetArena());
13006 }
13007 inline ::std::string* PROTOBUF_NONNULL OperatorSetIdProto::_internal_mutable_domain() {
13008   ::google::protobuf::internal::TSanWrite(&_impl_);
13009   _impl_._has_bits_[0] |= 0x00000001U;
13010   return _impl_.domain_.Mutable( GetArena());
13011 }
13012 inline ::std::string* PROTOBUF_NULLABLE OperatorSetIdProto::release_domain() {
13013   ::google::protobuf::internal::TSanWrite(&_impl_);
13014   // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
13015   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
13016     return nullptr;
13017   }
13018   _impl_._has_bits_[0] &= ~0x00000001U;
13019   auto* released = _impl_.domain_.Release();
13020   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
13021     _impl_.domain_.Set("", GetArena());
13022   }
13023   return released;
13024 }
13025 inline void OperatorSetIdProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
13026   ::google::protobuf::internal::TSanWrite(&_impl_);
13027   if (value != nullptr) {
13028     _impl_._has_bits_[0] |= 0x00000001U;
13029   } else {
13030     _impl_._has_bits_[0] &= ~0x00000001U;
13031   }
13032   _impl_.domain_.SetAllocated(value, GetArena());
13033   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
13034     _impl_.domain_.Set("", GetArena());
13035   }
13036   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
13037 }
13038 
13039 // optional int64 version = 2;
13040 inline bool OperatorSetIdProto::has_version() const {
13041   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
13042   return value;
13043 }
13044 inline void OperatorSetIdProto::clear_version() {
13045   ::google::protobuf::internal::TSanWrite(&_impl_);
13046   _impl_.version_ = ::int64_t{0};
13047   _impl_._has_bits_[0] &= ~0x00000002U;
13048 }
13049 inline ::int64_t OperatorSetIdProto::version() const {
13050   // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
13051   return _internal_version();
13052 }
13053 inline void OperatorSetIdProto::set_version(::int64_t value) {
13054   _internal_set_version(value);
13055   _impl_._has_bits_[0] |= 0x00000002U;
13056   // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
13057 }
13058 inline ::int64_t OperatorSetIdProto::_internal_version() const {
13059   ::google::protobuf::internal::TSanRead(&_impl_);
13060   return _impl_.version_;
13061 }
13062 inline void OperatorSetIdProto::_internal_set_version(::int64_t value) {
13063   ::google::protobuf::internal::TSanWrite(&_impl_);
13064   _impl_.version_ = value;
13065 }
13066 
13067 // -------------------------------------------------------------------
13068 
13069 // FunctionProto
13070 
13071 // optional string name = 1;
13072 inline bool FunctionProto::has_name() const {
13073   bool value = (_impl_._has_bits_[0] & 0x00000001U) != 0;
13074   return value;
13075 }
13076 inline void FunctionProto::clear_name() {
13077   ::google::protobuf::internal::TSanWrite(&_impl_);
13078   _impl_.name_.ClearToEmpty();
13079   _impl_._has_bits_[0] &= ~0x00000001U;
13080 }
13081 inline const ::std::string& FunctionProto::name() const
13082     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13083   // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
13084   return _internal_name();
13085 }
13086 template <typename Arg_, typename... Args_>
13087 PROTOBUF_ALWAYS_INLINE void FunctionProto::set_name(Arg_&& arg, Args_... args) {
13088   ::google::protobuf::internal::TSanWrite(&_impl_);
13089   _impl_._has_bits_[0] |= 0x00000001U;
13090   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13091   // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
13092 }
13093 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_name()
13094     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13095   ::std::string* _s = _internal_mutable_name();
13096   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
13097   return _s;
13098 }
13099 inline const ::std::string& FunctionProto::_internal_name() const {
13100   ::google::protobuf::internal::TSanRead(&_impl_);
13101   return _impl_.name_.Get();
13102 }
13103 inline void FunctionProto::_internal_set_name(const ::std::string& value) {
13104   ::google::protobuf::internal::TSanWrite(&_impl_);
13105   _impl_._has_bits_[0] |= 0x00000001U;
13106   _impl_.name_.Set(value, GetArena());
13107 }
13108 inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_name() {
13109   ::google::protobuf::internal::TSanWrite(&_impl_);
13110   _impl_._has_bits_[0] |= 0x00000001U;
13111   return _impl_.name_.Mutable( GetArena());
13112 }
13113 inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_name() {
13114   ::google::protobuf::internal::TSanWrite(&_impl_);
13115   // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
13116   if ((_impl_._has_bits_[0] & 0x00000001U) == 0) {
13117     return nullptr;
13118   }
13119   _impl_._has_bits_[0] &= ~0x00000001U;
13120   auto* released = _impl_.name_.Release();
13121   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
13122     _impl_.name_.Set("", GetArena());
13123   }
13124   return released;
13125 }
13126 inline void FunctionProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
13127   ::google::protobuf::internal::TSanWrite(&_impl_);
13128   if (value != nullptr) {
13129     _impl_._has_bits_[0] |= 0x00000001U;
13130   } else {
13131     _impl_._has_bits_[0] &= ~0x00000001U;
13132   }
13133   _impl_.name_.SetAllocated(value, GetArena());
13134   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
13135     _impl_.name_.Set("", GetArena());
13136   }
13137   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
13138 }
13139 
13140 // repeated string input = 4;
13141 inline int FunctionProto::_internal_input_size() const {
13142   return _internal_input().size();
13143 }
13144 inline int FunctionProto::input_size() const {
13145   return _internal_input_size();
13146 }
13147 inline void FunctionProto::clear_input() {
13148   ::google::protobuf::internal::TSanWrite(&_impl_);
13149   _impl_.input_.Clear();
13150 }
13151 inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_input()
13152     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13153   ::google::protobuf::internal::TSanWrite(&_impl_);
13154   ::std::string* _s = _internal_mutable_input()->Add();
13155   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
13156   return _s;
13157 }
13158 inline const ::std::string& FunctionProto::input(int index) const
13159     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13160   // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
13161   return _internal_input().Get(index);
13162 }
13163 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_input(int index)
13164     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13165   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
13166   return _internal_mutable_input()->Mutable(index);
13167 }
13168 template <typename Arg_, typename... Args_>
13169 inline void FunctionProto::set_input(int index, Arg_&& value, Args_... args) {
13170   ::google::protobuf::internal::AssignToString(*_internal_mutable_input()->Mutable(index), ::std::forward<Arg_>(value),
13171                         args... );
13172   // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
13173 }
13174 template <typename Arg_, typename... Args_>
13175 inline void FunctionProto::add_input(Arg_&& value, Args_... args) {
13176   ::google::protobuf::internal::TSanWrite(&_impl_);
13177   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_input(),
13178                                ::std::forward<Arg_>(value),
13179                                args... );
13180   // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
13181 }
13182 inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::input()
13183     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13184   // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
13185   return _internal_input();
13186 }
13187 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13188 FunctionProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13189   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
13190   ::google::protobuf::internal::TSanWrite(&_impl_);
13191   return _internal_mutable_input();
13192 }
13193 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
13194 FunctionProto::_internal_input() const {
13195   ::google::protobuf::internal::TSanRead(&_impl_);
13196   return _impl_.input_;
13197 }
13198 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13199 FunctionProto::_internal_mutable_input() {
13200   ::google::protobuf::internal::TSanRead(&_impl_);
13201   return &_impl_.input_;
13202 }
13203 
13204 // repeated string output = 5;
13205 inline int FunctionProto::_internal_output_size() const {
13206   return _internal_output().size();
13207 }
13208 inline int FunctionProto::output_size() const {
13209   return _internal_output_size();
13210 }
13211 inline void FunctionProto::clear_output() {
13212   ::google::protobuf::internal::TSanWrite(&_impl_);
13213   _impl_.output_.Clear();
13214 }
13215 inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_output()
13216     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13217   ::google::protobuf::internal::TSanWrite(&_impl_);
13218   ::std::string* _s = _internal_mutable_output()->Add();
13219   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
13220   return _s;
13221 }
13222 inline const ::std::string& FunctionProto::output(int index) const
13223     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13224   // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
13225   return _internal_output().Get(index);
13226 }
13227 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_output(int index)
13228     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13229   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
13230   return _internal_mutable_output()->Mutable(index);
13231 }
13232 template <typename Arg_, typename... Args_>
13233 inline void FunctionProto::set_output(int index, Arg_&& value, Args_... args) {
13234   ::google::protobuf::internal::AssignToString(*_internal_mutable_output()->Mutable(index), ::std::forward<Arg_>(value),
13235                         args... );
13236   // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
13237 }
13238 template <typename Arg_, typename... Args_>
13239 inline void FunctionProto::add_output(Arg_&& value, Args_... args) {
13240   ::google::protobuf::internal::TSanWrite(&_impl_);
13241   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_output(),
13242                                ::std::forward<Arg_>(value),
13243                                args... );
13244   // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
13245 }
13246 inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::output()
13247     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13248   // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
13249   return _internal_output();
13250 }
13251 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13252 FunctionProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13253   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
13254   ::google::protobuf::internal::TSanWrite(&_impl_);
13255   return _internal_mutable_output();
13256 }
13257 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
13258 FunctionProto::_internal_output() const {
13259   ::google::protobuf::internal::TSanRead(&_impl_);
13260   return _impl_.output_;
13261 }
13262 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13263 FunctionProto::_internal_mutable_output() {
13264   ::google::protobuf::internal::TSanRead(&_impl_);
13265   return &_impl_.output_;
13266 }
13267 
13268 // repeated string attribute = 6;
13269 inline int FunctionProto::_internal_attribute_size() const {
13270   return _internal_attribute().size();
13271 }
13272 inline int FunctionProto::attribute_size() const {
13273   return _internal_attribute_size();
13274 }
13275 inline void FunctionProto::clear_attribute() {
13276   ::google::protobuf::internal::TSanWrite(&_impl_);
13277   _impl_.attribute_.Clear();
13278 }
13279 inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_attribute()
13280     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13281   ::google::protobuf::internal::TSanWrite(&_impl_);
13282   ::std::string* _s = _internal_mutable_attribute()->Add();
13283   // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
13284   return _s;
13285 }
13286 inline const ::std::string& FunctionProto::attribute(int index) const
13287     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13288   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
13289   return _internal_attribute().Get(index);
13290 }
13291 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_attribute(int index)
13292     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13293   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
13294   return _internal_mutable_attribute()->Mutable(index);
13295 }
13296 template <typename Arg_, typename... Args_>
13297 inline void FunctionProto::set_attribute(int index, Arg_&& value, Args_... args) {
13298   ::google::protobuf::internal::AssignToString(*_internal_mutable_attribute()->Mutable(index), ::std::forward<Arg_>(value),
13299                         args... );
13300   // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
13301 }
13302 template <typename Arg_, typename... Args_>
13303 inline void FunctionProto::add_attribute(Arg_&& value, Args_... args) {
13304   ::google::protobuf::internal::TSanWrite(&_impl_);
13305   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_attribute(),
13306                                ::std::forward<Arg_>(value),
13307                                args... );
13308   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
13309 }
13310 inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::attribute()
13311     const ABSL_ATTRIBUTE_LIFETIME_BOUND {
13312   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
13313   return _internal_attribute();
13314 }
13315 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13316 FunctionProto::mutable_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
13317   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
13318   ::google::protobuf::internal::TSanWrite(&_impl_);
13319   return _internal_mutable_attribute();
13320 }
13321 inline const ::google::protobuf::RepeatedPtrField<::std::string>&
13322 FunctionProto::_internal_attribute() const {
13323   ::google::protobuf::internal::TSanRead(&_impl_);
13324   return _impl_.attribute_;
13325 }
13326 inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
13327 FunctionProto::_internal_mutable_attribute() {
13328   ::google::protobuf::internal::TSanRead(&_impl_);
13329   return &_impl_.attribute_;
13330 }
13331 
13332 // repeated .onnx.AttributeProto attribute_proto = 11;
13333 inline int FunctionProto::_internal_attribute_proto_size() const {
13334   return _internal_attribute_proto().size();
13335 }
13336 inline int FunctionProto::attribute_proto_size() const {
13337   return _internal_attribute_proto_size();
13338 }
13339 inline void FunctionProto::clear_attribute_proto() {
13340   ::google::protobuf::internal::TSanWrite(&_impl_);
13341   _impl_.attribute_proto_.Clear();
13342 }
13343 inline ::onnx::AttributeProto* PROTOBUF_NONNULL FunctionProto::mutable_attribute_proto(int index)
13344     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13345   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
13346   return _internal_mutable_attribute_proto()->Mutable(index);
13347 }
13348 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL FunctionProto::mutable_attribute_proto()
13349     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13350   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
13351   ::google::protobuf::internal::TSanWrite(&_impl_);
13352   return _internal_mutable_attribute_proto();
13353 }
13354 inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const
13355     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13356   // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
13357   return _internal_attribute_proto().Get(index);
13358 }
13359 inline ::onnx::AttributeProto* PROTOBUF_NONNULL FunctionProto::add_attribute_proto()
13360     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13361   ::google::protobuf::internal::TSanWrite(&_impl_);
13362   ::onnx::AttributeProto* _add = _internal_mutable_attribute_proto()->Add();
13363   // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
13364   return _add;
13365 }
13366 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& FunctionProto::attribute_proto() const
13367     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13368   // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
13369   return _internal_attribute_proto();
13370 }
13371 inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
13372 FunctionProto::_internal_attribute_proto() const {
13373   ::google::protobuf::internal::TSanRead(&_impl_);
13374   return _impl_.attribute_proto_;
13375 }
13376 inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
13377 FunctionProto::_internal_mutable_attribute_proto() {
13378   ::google::protobuf::internal::TSanRead(&_impl_);
13379   return &_impl_.attribute_proto_;
13380 }
13381 
13382 // repeated .onnx.NodeProto node = 7;
13383 inline int FunctionProto::_internal_node_size() const {
13384   return _internal_node().size();
13385 }
13386 inline int FunctionProto::node_size() const {
13387   return _internal_node_size();
13388 }
13389 inline void FunctionProto::clear_node() {
13390   ::google::protobuf::internal::TSanWrite(&_impl_);
13391   _impl_.node_.Clear();
13392 }
13393 inline ::onnx::NodeProto* PROTOBUF_NONNULL FunctionProto::mutable_node(int index)
13394     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13395   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
13396   return _internal_mutable_node()->Mutable(index);
13397 }
13398 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL FunctionProto::mutable_node()
13399     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13400   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
13401   ::google::protobuf::internal::TSanWrite(&_impl_);
13402   return _internal_mutable_node();
13403 }
13404 inline const ::onnx::NodeProto& FunctionProto::node(int index) const
13405     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13406   // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
13407   return _internal_node().Get(index);
13408 }
13409 inline ::onnx::NodeProto* PROTOBUF_NONNULL FunctionProto::add_node()
13410     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13411   ::google::protobuf::internal::TSanWrite(&_impl_);
13412   ::onnx::NodeProto* _add = _internal_mutable_node()->Add();
13413   // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
13414   return _add;
13415 }
13416 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& FunctionProto::node() const
13417     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13418   // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
13419   return _internal_node();
13420 }
13421 inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
13422 FunctionProto::_internal_node() const {
13423   ::google::protobuf::internal::TSanRead(&_impl_);
13424   return _impl_.node_;
13425 }
13426 inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
13427 FunctionProto::_internal_mutable_node() {
13428   ::google::protobuf::internal::TSanRead(&_impl_);
13429   return &_impl_.node_;
13430 }
13431 
13432 // optional string doc_string = 8;
13433 inline bool FunctionProto::has_doc_string() const {
13434   bool value = (_impl_._has_bits_[0] & 0x00000002U) != 0;
13435   return value;
13436 }
13437 inline void FunctionProto::clear_doc_string() {
13438   ::google::protobuf::internal::TSanWrite(&_impl_);
13439   _impl_.doc_string_.ClearToEmpty();
13440   _impl_._has_bits_[0] &= ~0x00000002U;
13441 }
13442 inline const ::std::string& FunctionProto::doc_string() const
13443     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13444   // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
13445   return _internal_doc_string();
13446 }
13447 template <typename Arg_, typename... Args_>
13448 PROTOBUF_ALWAYS_INLINE void FunctionProto::set_doc_string(Arg_&& arg, Args_... args) {
13449   ::google::protobuf::internal::TSanWrite(&_impl_);
13450   _impl_._has_bits_[0] |= 0x00000002U;
13451   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13452   // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
13453 }
13454 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_doc_string()
13455     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13456   ::std::string* _s = _internal_mutable_doc_string();
13457   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
13458   return _s;
13459 }
13460 inline const ::std::string& FunctionProto::_internal_doc_string() const {
13461   ::google::protobuf::internal::TSanRead(&_impl_);
13462   return _impl_.doc_string_.Get();
13463 }
13464 inline void FunctionProto::_internal_set_doc_string(const ::std::string& value) {
13465   ::google::protobuf::internal::TSanWrite(&_impl_);
13466   _impl_._has_bits_[0] |= 0x00000002U;
13467   _impl_.doc_string_.Set(value, GetArena());
13468 }
13469 inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_doc_string() {
13470   ::google::protobuf::internal::TSanWrite(&_impl_);
13471   _impl_._has_bits_[0] |= 0x00000002U;
13472   return _impl_.doc_string_.Mutable( GetArena());
13473 }
13474 inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_doc_string() {
13475   ::google::protobuf::internal::TSanWrite(&_impl_);
13476   // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
13477   if ((_impl_._has_bits_[0] & 0x00000002U) == 0) {
13478     return nullptr;
13479   }
13480   _impl_._has_bits_[0] &= ~0x00000002U;
13481   auto* released = _impl_.doc_string_.Release();
13482   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
13483     _impl_.doc_string_.Set("", GetArena());
13484   }
13485   return released;
13486 }
13487 inline void FunctionProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
13488   ::google::protobuf::internal::TSanWrite(&_impl_);
13489   if (value != nullptr) {
13490     _impl_._has_bits_[0] |= 0x00000002U;
13491   } else {
13492     _impl_._has_bits_[0] &= ~0x00000002U;
13493   }
13494   _impl_.doc_string_.SetAllocated(value, GetArena());
13495   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
13496     _impl_.doc_string_.Set("", GetArena());
13497   }
13498   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
13499 }
13500 
13501 // repeated .onnx.OperatorSetIdProto opset_import = 9;
13502 inline int FunctionProto::_internal_opset_import_size() const {
13503   return _internal_opset_import().size();
13504 }
13505 inline int FunctionProto::opset_import_size() const {
13506   return _internal_opset_import_size();
13507 }
13508 inline void FunctionProto::clear_opset_import() {
13509   ::google::protobuf::internal::TSanWrite(&_impl_);
13510   _impl_.opset_import_.Clear();
13511 }
13512 inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL FunctionProto::mutable_opset_import(int index)
13513     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13514   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
13515   return _internal_mutable_opset_import()->Mutable(index);
13516 }
13517 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL FunctionProto::mutable_opset_import()
13518     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13519   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
13520   ::google::protobuf::internal::TSanWrite(&_impl_);
13521   return _internal_mutable_opset_import();
13522 }
13523 inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const
13524     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13525   // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
13526   return _internal_opset_import().Get(index);
13527 }
13528 inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL FunctionProto::add_opset_import()
13529     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13530   ::google::protobuf::internal::TSanWrite(&_impl_);
13531   ::onnx::OperatorSetIdProto* _add = _internal_mutable_opset_import()->Add();
13532   // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
13533   return _add;
13534 }
13535 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& FunctionProto::opset_import() const
13536     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13537   // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
13538   return _internal_opset_import();
13539 }
13540 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
13541 FunctionProto::_internal_opset_import() const {
13542   ::google::protobuf::internal::TSanRead(&_impl_);
13543   return _impl_.opset_import_;
13544 }
13545 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
13546 FunctionProto::_internal_mutable_opset_import() {
13547   ::google::protobuf::internal::TSanRead(&_impl_);
13548   return &_impl_.opset_import_;
13549 }
13550 
13551 // optional string domain = 10;
13552 inline bool FunctionProto::has_domain() const {
13553   bool value = (_impl_._has_bits_[0] & 0x00000004U) != 0;
13554   return value;
13555 }
13556 inline void FunctionProto::clear_domain() {
13557   ::google::protobuf::internal::TSanWrite(&_impl_);
13558   _impl_.domain_.ClearToEmpty();
13559   _impl_._has_bits_[0] &= ~0x00000004U;
13560 }
13561 inline const ::std::string& FunctionProto::domain() const
13562     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13563   // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
13564   return _internal_domain();
13565 }
13566 template <typename Arg_, typename... Args_>
13567 PROTOBUF_ALWAYS_INLINE void FunctionProto::set_domain(Arg_&& arg, Args_... args) {
13568   ::google::protobuf::internal::TSanWrite(&_impl_);
13569   _impl_._has_bits_[0] |= 0x00000004U;
13570   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13571   // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
13572 }
13573 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_domain()
13574     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13575   ::std::string* _s = _internal_mutable_domain();
13576   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
13577   return _s;
13578 }
13579 inline const ::std::string& FunctionProto::_internal_domain() const {
13580   ::google::protobuf::internal::TSanRead(&_impl_);
13581   return _impl_.domain_.Get();
13582 }
13583 inline void FunctionProto::_internal_set_domain(const ::std::string& value) {
13584   ::google::protobuf::internal::TSanWrite(&_impl_);
13585   _impl_._has_bits_[0] |= 0x00000004U;
13586   _impl_.domain_.Set(value, GetArena());
13587 }
13588 inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_domain() {
13589   ::google::protobuf::internal::TSanWrite(&_impl_);
13590   _impl_._has_bits_[0] |= 0x00000004U;
13591   return _impl_.domain_.Mutable( GetArena());
13592 }
13593 inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_domain() {
13594   ::google::protobuf::internal::TSanWrite(&_impl_);
13595   // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
13596   if ((_impl_._has_bits_[0] & 0x00000004U) == 0) {
13597     return nullptr;
13598   }
13599   _impl_._has_bits_[0] &= ~0x00000004U;
13600   auto* released = _impl_.domain_.Release();
13601   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
13602     _impl_.domain_.Set("", GetArena());
13603   }
13604   return released;
13605 }
13606 inline void FunctionProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
13607   ::google::protobuf::internal::TSanWrite(&_impl_);
13608   if (value != nullptr) {
13609     _impl_._has_bits_[0] |= 0x00000004U;
13610   } else {
13611     _impl_._has_bits_[0] &= ~0x00000004U;
13612   }
13613   _impl_.domain_.SetAllocated(value, GetArena());
13614   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
13615     _impl_.domain_.Set("", GetArena());
13616   }
13617   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
13618 }
13619 
13620 // optional string overload = 13;
13621 inline bool FunctionProto::has_overload() const {
13622   bool value = (_impl_._has_bits_[0] & 0x00000008U) != 0;
13623   return value;
13624 }
13625 inline void FunctionProto::clear_overload() {
13626   ::google::protobuf::internal::TSanWrite(&_impl_);
13627   _impl_.overload_.ClearToEmpty();
13628   _impl_._has_bits_[0] &= ~0x00000008U;
13629 }
13630 inline const ::std::string& FunctionProto::overload() const
13631     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13632   // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload)
13633   return _internal_overload();
13634 }
13635 template <typename Arg_, typename... Args_>
13636 PROTOBUF_ALWAYS_INLINE void FunctionProto::set_overload(Arg_&& arg, Args_... args) {
13637   ::google::protobuf::internal::TSanWrite(&_impl_);
13638   _impl_._has_bits_[0] |= 0x00000008U;
13639   _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
13640   // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload)
13641 }
13642 inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_overload()
13643     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13644   ::std::string* _s = _internal_mutable_overload();
13645   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload)
13646   return _s;
13647 }
13648 inline const ::std::string& FunctionProto::_internal_overload() const {
13649   ::google::protobuf::internal::TSanRead(&_impl_);
13650   return _impl_.overload_.Get();
13651 }
13652 inline void FunctionProto::_internal_set_overload(const ::std::string& value) {
13653   ::google::protobuf::internal::TSanWrite(&_impl_);
13654   _impl_._has_bits_[0] |= 0x00000008U;
13655   _impl_.overload_.Set(value, GetArena());
13656 }
13657 inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_overload() {
13658   ::google::protobuf::internal::TSanWrite(&_impl_);
13659   _impl_._has_bits_[0] |= 0x00000008U;
13660   return _impl_.overload_.Mutable( GetArena());
13661 }
13662 inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_overload() {
13663   ::google::protobuf::internal::TSanWrite(&_impl_);
13664   // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload)
13665   if ((_impl_._has_bits_[0] & 0x00000008U) == 0) {
13666     return nullptr;
13667   }
13668   _impl_._has_bits_[0] &= ~0x00000008U;
13669   auto* released = _impl_.overload_.Release();
13670   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
13671     _impl_.overload_.Set("", GetArena());
13672   }
13673   return released;
13674 }
13675 inline void FunctionProto::set_allocated_overload(::std::string* PROTOBUF_NULLABLE value) {
13676   ::google::protobuf::internal::TSanWrite(&_impl_);
13677   if (value != nullptr) {
13678     _impl_._has_bits_[0] |= 0x00000008U;
13679   } else {
13680     _impl_._has_bits_[0] &= ~0x00000008U;
13681   }
13682   _impl_.overload_.SetAllocated(value, GetArena());
13683   if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.overload_.IsDefault()) {
13684     _impl_.overload_.Set("", GetArena());
13685   }
13686   // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload)
13687 }
13688 
13689 // repeated .onnx.ValueInfoProto value_info = 12;
13690 inline int FunctionProto::_internal_value_info_size() const {
13691   return _internal_value_info().size();
13692 }
13693 inline int FunctionProto::value_info_size() const {
13694   return _internal_value_info_size();
13695 }
13696 inline void FunctionProto::clear_value_info() {
13697   ::google::protobuf::internal::TSanWrite(&_impl_);
13698   _impl_.value_info_.Clear();
13699 }
13700 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL FunctionProto::mutable_value_info(int index)
13701     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13702   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info)
13703   return _internal_mutable_value_info()->Mutable(index);
13704 }
13705 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL FunctionProto::mutable_value_info()
13706     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13707   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info)
13708   ::google::protobuf::internal::TSanWrite(&_impl_);
13709   return _internal_mutable_value_info();
13710 }
13711 inline const ::onnx::ValueInfoProto& FunctionProto::value_info(int index) const
13712     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13713   // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info)
13714   return _internal_value_info().Get(index);
13715 }
13716 inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL FunctionProto::add_value_info()
13717     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13718   ::google::protobuf::internal::TSanWrite(&_impl_);
13719   ::onnx::ValueInfoProto* _add = _internal_mutable_value_info()->Add();
13720   // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info)
13721   return _add;
13722 }
13723 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& FunctionProto::value_info() const
13724     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13725   // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info)
13726   return _internal_value_info();
13727 }
13728 inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
13729 FunctionProto::_internal_value_info() const {
13730   ::google::protobuf::internal::TSanRead(&_impl_);
13731   return _impl_.value_info_;
13732 }
13733 inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
13734 FunctionProto::_internal_mutable_value_info() {
13735   ::google::protobuf::internal::TSanRead(&_impl_);
13736   return &_impl_.value_info_;
13737 }
13738 
13739 // repeated .onnx.StringStringEntryProto metadata_props = 14;
13740 inline int FunctionProto::_internal_metadata_props_size() const {
13741   return _internal_metadata_props().size();
13742 }
13743 inline int FunctionProto::metadata_props_size() const {
13744   return _internal_metadata_props_size();
13745 }
13746 inline void FunctionProto::clear_metadata_props() {
13747   ::google::protobuf::internal::TSanWrite(&_impl_);
13748   _impl_.metadata_props_.Clear();
13749 }
13750 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL FunctionProto::mutable_metadata_props(int index)
13751     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13752   // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props)
13753   return _internal_mutable_metadata_props()->Mutable(index);
13754 }
13755 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL FunctionProto::mutable_metadata_props()
13756     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13757   // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props)
13758   ::google::protobuf::internal::TSanWrite(&_impl_);
13759   return _internal_mutable_metadata_props();
13760 }
13761 inline const ::onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const
13762     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13763   // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props)
13764   return _internal_metadata_props().Get(index);
13765 }
13766 inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL FunctionProto::add_metadata_props()
13767     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13768   ::google::protobuf::internal::TSanWrite(&_impl_);
13769   ::onnx::StringStringEntryProto* _add = _internal_mutable_metadata_props()->Add();
13770   // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props)
13771   return _add;
13772 }
13773 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& FunctionProto::metadata_props() const
13774     ABSL_ATTRIBUTE_LIFETIME_BOUND {
13775   // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props)
13776   return _internal_metadata_props();
13777 }
13778 inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
13779 FunctionProto::_internal_metadata_props() const {
13780   ::google::protobuf::internal::TSanRead(&_impl_);
13781   return _impl_.metadata_props_;
13782 }
13783 inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
13784 FunctionProto::_internal_mutable_metadata_props() {
13785   ::google::protobuf::internal::TSanRead(&_impl_);
13786   return &_impl_.metadata_props_;
13787 }
13788 
13789 #ifdef __GNUC__
13790 #pragma GCC diagnostic pop
13791 #endif  // __GNUC__
13792 
13793 // @@protoc_insertion_point(namespace_scope)
13794 }  // namespace onnx
13795 
13796 
13797 namespace google {
13798 namespace protobuf {
13799 
13800 template <>
13801 struct is_proto_enum<::onnx::AttributeProto_AttributeType> : std::true_type {};
13802 template <>
13803 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::AttributeProto_AttributeType>() {
13804   return ::onnx::AttributeProto_AttributeType_descriptor();
13805 }
13806 template <>
13807 struct is_proto_enum<::onnx::TensorProto_DataType> : std::true_type {};
13808 template <>
13809 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::TensorProto_DataType>() {
13810   return ::onnx::TensorProto_DataType_descriptor();
13811 }
13812 template <>
13813 struct is_proto_enum<::onnx::TensorProto_DataLocation> : std::true_type {};
13814 template <>
13815 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::TensorProto_DataLocation>() {
13816   return ::onnx::TensorProto_DataLocation_descriptor();
13817 }
13818 template <>
13819 struct is_proto_enum<::onnx::Version> : std::true_type {};
13820 template <>
13821 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::Version>() {
13822   return ::onnx::Version_descriptor();
13823 }
13824 template <>
13825 struct is_proto_enum<::onnx::OperatorStatus> : std::true_type {};
13826 template <>
13827 inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::OperatorStatus>() {
13828   return ::onnx::OperatorStatus_descriptor();
13829 }
13830 
13831 }  // namespace protobuf
13832 }  // namespace google
13833 
13834 // @@protoc_insertion_point(global_scope)
13835 
13836 #include "google/protobuf/port_undef.inc"
13837 
13838 #endif  // onnx_2fonnx_2dml_2eproto_2epb_2eh
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!