// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: onnx/onnx-ml.proto
// Protobuf C++ Version: 7.34.1

#ifndef onnx_2fonnx_2dml_2eproto_2epb_2eh
#define onnx_2fonnx_2dml_2eproto_2epb_2eh

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

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7034001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2dml_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_onnx_2fonnx_2dml_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_onnx_2fonnx_2dml_2eproto;
}  // extern "C"
namespace onnx {
enum AttributeProto_AttributeType : int;
extern const uint32_t AttributeProto_AttributeType_internal_data_[];
enum OperatorStatus : int;
extern const uint32_t OperatorStatus_internal_data_[];
enum TensorProto_DataLocation : int;
extern const uint32_t TensorProto_DataLocation_internal_data_[];
enum TensorProto_DataType : int;
extern const uint32_t TensorProto_DataType_internal_data_[];
enum Version : int;
extern const uint32_t Version_internal_data_[];
class AttributeProto;
struct AttributeProtoDefaultTypeInternal;
extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull AttributeProto_class_data_;
class DeviceConfigurationProto;
struct DeviceConfigurationProtoDefaultTypeInternal;
extern DeviceConfigurationProtoDefaultTypeInternal _DeviceConfigurationProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull DeviceConfigurationProto_class_data_;
class FunctionProto;
struct FunctionProtoDefaultTypeInternal;
extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull FunctionProto_class_data_;
class GraphProto;
struct GraphProtoDefaultTypeInternal;
extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull GraphProto_class_data_;
class IntIntListEntryProto;
struct IntIntListEntryProtoDefaultTypeInternal;
extern IntIntListEntryProtoDefaultTypeInternal _IntIntListEntryProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull IntIntListEntryProto_class_data_;
class ModelProto;
struct ModelProtoDefaultTypeInternal;
extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull ModelProto_class_data_;
class NodeDeviceConfigurationProto;
struct NodeDeviceConfigurationProtoDefaultTypeInternal;
extern NodeDeviceConfigurationProtoDefaultTypeInternal _NodeDeviceConfigurationProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull NodeDeviceConfigurationProto_class_data_;
class NodeProto;
struct NodeProtoDefaultTypeInternal;
extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull NodeProto_class_data_;
class OperatorSetIdProto;
struct OperatorSetIdProtoDefaultTypeInternal;
extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull OperatorSetIdProto_class_data_;
class ShardedDimProto;
struct ShardedDimProtoDefaultTypeInternal;
extern ShardedDimProtoDefaultTypeInternal _ShardedDimProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull ShardedDimProto_class_data_;
class ShardingSpecProto;
struct ShardingSpecProtoDefaultTypeInternal;
extern ShardingSpecProtoDefaultTypeInternal _ShardingSpecProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull ShardingSpecProto_class_data_;
class SimpleShardedDimProto;
struct SimpleShardedDimProtoDefaultTypeInternal;
extern SimpleShardedDimProtoDefaultTypeInternal _SimpleShardedDimProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull SimpleShardedDimProto_class_data_;
class SparseTensorProto;
struct SparseTensorProtoDefaultTypeInternal;
extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull SparseTensorProto_class_data_;
class StringStringEntryProto;
struct StringStringEntryProtoDefaultTypeInternal;
extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull StringStringEntryProto_class_data_;
class TensorAnnotation;
struct TensorAnnotationDefaultTypeInternal;
extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TensorAnnotation_class_data_;
class TensorProto;
struct TensorProtoDefaultTypeInternal;
extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TensorProto_class_data_;
class TensorProto_Segment;
struct TensorProto_SegmentDefaultTypeInternal;
extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TensorProto_Segment_class_data_;
class TensorShapeProto;
struct TensorShapeProtoDefaultTypeInternal;
extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_class_data_;
class TensorShapeProto_Dimension;
struct TensorShapeProto_DimensionDefaultTypeInternal;
extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_Dimension_class_data_;
class TrainingInfoProto;
struct TrainingInfoProtoDefaultTypeInternal;
extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TrainingInfoProto_class_data_;
class TypeProto;
struct TypeProtoDefaultTypeInternal;
extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_class_data_;
class TypeProto_Map;
struct TypeProto_MapDefaultTypeInternal;
extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_Map_class_data_;
class TypeProto_Opaque;
struct TypeProto_OpaqueDefaultTypeInternal;
extern TypeProto_OpaqueDefaultTypeInternal _TypeProto_Opaque_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_Opaque_class_data_;
class TypeProto_Optional;
struct TypeProto_OptionalDefaultTypeInternal;
extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_Optional_class_data_;
class TypeProto_Sequence;
struct TypeProto_SequenceDefaultTypeInternal;
extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_Sequence_class_data_;
class TypeProto_SparseTensor;
struct TypeProto_SparseTensorDefaultTypeInternal;
extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_SparseTensor_class_data_;
class TypeProto_Tensor;
struct TypeProto_TensorDefaultTypeInternal;
extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull TypeProto_Tensor_class_data_;
class ValueInfoProto;
struct ValueInfoProtoDefaultTypeInternal;
extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
extern const ::google::protobuf::internal::ClassDataFull ValueInfoProto_class_data_;
}  // namespace onnx
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::onnx::AttributeProto_AttributeType_internal_data_>
    internal::EnumTraitsImpl::value<::onnx::AttributeProto_AttributeType>;
template <>
internal::EnumTraitsT<::onnx::OperatorStatus_internal_data_>
    internal::EnumTraitsImpl::value<::onnx::OperatorStatus>;
template <>
internal::EnumTraitsT<::onnx::TensorProto_DataLocation_internal_data_>
    internal::EnumTraitsImpl::value<::onnx::TensorProto_DataLocation>;
template <>
internal::EnumTraitsT<::onnx::TensorProto_DataType_internal_data_>
    internal::EnumTraitsImpl::value<::onnx::TensorProto_DataType>;
template <>
internal::EnumTraitsT<::onnx::Version_internal_data_>
    internal::EnumTraitsImpl::value<::onnx::Version>;
}  // namespace protobuf
}  // namespace google

namespace onnx {
enum AttributeProto_AttributeType : int {
  AttributeProto_AttributeType_UNDEFINED = 0,
  AttributeProto_AttributeType_FLOAT = 1,
  AttributeProto_AttributeType_INT = 2,
  AttributeProto_AttributeType_STRING = 3,
  AttributeProto_AttributeType_TENSOR = 4,
  AttributeProto_AttributeType_GRAPH = 5,
  AttributeProto_AttributeType_SPARSE_TENSOR = 11,
  AttributeProto_AttributeType_TYPE_PROTO = 13,
  AttributeProto_AttributeType_FLOATS = 6,
  AttributeProto_AttributeType_INTS = 7,
  AttributeProto_AttributeType_STRINGS = 8,
  AttributeProto_AttributeType_TENSORS = 9,
  AttributeProto_AttributeType_GRAPHS = 10,
  AttributeProto_AttributeType_SPARSE_TENSORS = 12,
  AttributeProto_AttributeType_TYPE_PROTOS = 14,
};

extern const uint32_t AttributeProto_AttributeType_internal_data_[];
inline constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN =
    static_cast<AttributeProto_AttributeType>(0);
inline constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX =
    static_cast<AttributeProto_AttributeType>(14);
[[nodiscard]] inline bool AttributeProto_AttributeType_IsValid(int value) {
  return 0 <= value && value <= 14;
}
inline constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = 14 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
AttributeProto_AttributeType_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(AttributeProto_AttributeType) {
  return AttributeProto_AttributeType_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& AttributeProto_AttributeType_Name(T value) {
  static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to AttributeType_Name().");
  return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(value));
}
template <>
[[nodiscard]] inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AttributeProto_AttributeType_descriptor, 0, 14>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool AttributeProto_AttributeType_Parse(
    ::absl::string_view name, AttributeProto_AttributeType* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(AttributeProto_AttributeType_descriptor(), name,
                                           value);
}
enum TensorProto_DataType : int {
  TensorProto_DataType_UNDEFINED = 0,
  TensorProto_DataType_FLOAT = 1,
  TensorProto_DataType_UINT8 = 2,
  TensorProto_DataType_INT8 = 3,
  TensorProto_DataType_UINT16 = 4,
  TensorProto_DataType_INT16 = 5,
  TensorProto_DataType_INT32 = 6,
  TensorProto_DataType_INT64 = 7,
  TensorProto_DataType_STRING = 8,
  TensorProto_DataType_BOOL = 9,
  TensorProto_DataType_FLOAT16 = 10,
  TensorProto_DataType_DOUBLE = 11,
  TensorProto_DataType_UINT32 = 12,
  TensorProto_DataType_UINT64 = 13,
  TensorProto_DataType_COMPLEX64 = 14,
  TensorProto_DataType_COMPLEX128 = 15,
  TensorProto_DataType_BFLOAT16 = 16,
  TensorProto_DataType_FLOAT8E4M3FN = 17,
  TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
  TensorProto_DataType_FLOAT8E5M2 = 19,
  TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
  TensorProto_DataType_UINT4 = 21,
  TensorProto_DataType_INT4 = 22,
  TensorProto_DataType_FLOAT4E2M1 = 23,
  TensorProto_DataType_FLOAT8E8M0 = 24,
  TensorProto_DataType_UINT2 = 25,
  TensorProto_DataType_INT2 = 26,
};

extern const uint32_t TensorProto_DataType_internal_data_[];
inline constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN =
    static_cast<TensorProto_DataType>(0);
inline constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX =
    static_cast<TensorProto_DataType>(26);
[[nodiscard]] inline bool TensorProto_DataType_IsValid(int value) {
  return 0 <= value && value <= 26;
}
inline constexpr int TensorProto_DataType_DataType_ARRAYSIZE = 26 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
TensorProto_DataType_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(TensorProto_DataType) {
  return TensorProto_DataType_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& TensorProto_DataType_Name(T value) {
  static_assert(::std::is_same<T, TensorProto_DataType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to DataType_Name().");
  return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(value));
}
template <>
[[nodiscard]] inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataType_descriptor, 0, 26>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool TensorProto_DataType_Parse(
    ::absl::string_view name, TensorProto_DataType* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(TensorProto_DataType_descriptor(), name,
                                           value);
}
enum TensorProto_DataLocation : int {
  TensorProto_DataLocation_DEFAULT = 0,
  TensorProto_DataLocation_EXTERNAL = 1,
};

extern const uint32_t TensorProto_DataLocation_internal_data_[];
inline constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN =
    static_cast<TensorProto_DataLocation>(0);
inline constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX =
    static_cast<TensorProto_DataLocation>(1);
[[nodiscard]] inline bool TensorProto_DataLocation_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
TensorProto_DataLocation_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(TensorProto_DataLocation) {
  return TensorProto_DataLocation_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& TensorProto_DataLocation_Name(T value) {
  static_assert(::std::is_same<T, TensorProto_DataLocation>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to DataLocation_Name().");
  return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(value));
}
template <>
[[nodiscard]] inline const ::std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value) {
  return ::google::protobuf::internal::NameOfDenseEnum<TensorProto_DataLocation_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool TensorProto_DataLocation_Parse(
    ::absl::string_view name, TensorProto_DataLocation* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataLocation>(TensorProto_DataLocation_descriptor(), name,
                                           value);
}
enum Version : int {
  _START_VERSION = 0,
  IR_VERSION_2017_10_10 = 1,
  IR_VERSION_2017_10_30 = 2,
  IR_VERSION_2017_11_3 = 3,
  IR_VERSION_2019_1_22 = 4,
  IR_VERSION_2019_3_18 = 5,
  IR_VERSION_2019_9_19 = 6,
  IR_VERSION_2020_5_8 = 7,
  IR_VERSION_2021_7_30 = 8,
  IR_VERSION_2023_5_5 = 9,
  IR_VERSION_2024_3_25 = 10,
  IR_VERSION_2025_05_12 = 11,
  IR_VERSION_2025_08_26 = 12,
  IR_VERSION = 13,
};

extern const uint32_t Version_internal_data_[];
inline constexpr Version Version_MIN =
    static_cast<Version>(0);
inline constexpr Version Version_MAX =
    static_cast<Version>(13);
[[nodiscard]] inline bool Version_IsValid(int value) {
  return 0 <= value && value <= 13;
}
inline constexpr int Version_ARRAYSIZE = 13 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
Version_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(Version) {
  return Version_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& Version_Name(T value) {
  static_assert(::std::is_same<T, Version>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Version_Name().");
  return Version_Name(static_cast<Version>(value));
}
template <>
[[nodiscard]] inline const ::std::string& Version_Name(Version value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Version_descriptor, 0, 13>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool Version_Parse(
    ::absl::string_view name, Version* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<Version>(Version_descriptor(), name,
                                           value);
}
enum OperatorStatus : int {
  EXPERIMENTAL = 0,
  STABLE = 1,
};

extern const uint32_t OperatorStatus_internal_data_[];
inline constexpr OperatorStatus OperatorStatus_MIN =
    static_cast<OperatorStatus>(0);
inline constexpr OperatorStatus OperatorStatus_MAX =
    static_cast<OperatorStatus>(1);
[[nodiscard]] inline bool OperatorStatus_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int OperatorStatus_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
OperatorStatus_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(OperatorStatus) {
  return OperatorStatus_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& OperatorStatus_Name(T value) {
  static_assert(::std::is_same<T, OperatorStatus>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to OperatorStatus_Name().");
  return OperatorStatus_Name(static_cast<OperatorStatus>(value));
}
template <>
[[nodiscard]] inline const ::std::string& OperatorStatus_Name(OperatorStatus value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OperatorStatus_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool OperatorStatus_Parse(
    ::absl::string_view name, OperatorStatus* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<OperatorStatus>(OperatorStatus_descriptor(), name,
                                           value);
}

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_Opaque final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.Opaque) */ {
 public:
  inline TypeProto_Opaque() : TypeProto_Opaque(nullptr) {}
  ~TypeProto_Opaque() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_Opaque* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Opaque));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_Opaque(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_Opaque(const TypeProto_Opaque& from) : TypeProto_Opaque(nullptr, from) {}
  inline TypeProto_Opaque(TypeProto_Opaque&& from) noexcept
      : TypeProto_Opaque(nullptr, ::std::move(from)) {}
  inline TypeProto_Opaque& operator=(const TypeProto_Opaque& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_Opaque& operator=(TypeProto_Opaque&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_Opaque& default_instance() {
    return *reinterpret_cast<const TypeProto_Opaque*>(
        &_TypeProto_Opaque_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 24;
  friend void swap(TypeProto_Opaque& a, TypeProto_Opaque& b) { a.Swap(&b); }
  inline void Swap(TypeProto_Opaque* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_Opaque* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_Opaque* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_Opaque>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_Opaque& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_Opaque& from) { TypeProto_Opaque::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_Opaque* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Opaque"; }

  explicit TypeProto_Opaque(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_Opaque(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Opaque& from);
  TypeProto_Opaque(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Opaque&& from) noexcept
      : TypeProto_Opaque(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDomainFieldNumber = 1,
    kNameFieldNumber = 2,
  };
  // optional string domain = 1;
  [[nodiscard]] bool has_domain()
      const;
  void clear_domain() ;
  [[nodiscard]] const ::std::string& domain() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_domain(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_domain();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
  void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_domain() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // optional string name = 2;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_Opaque& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr domain_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_Opaque_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TensorShapeProto_Dimension final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
 public:
  inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
  ~TensorShapeProto_Dimension() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TensorShapeProto_Dimension* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorShapeProto_Dimension));
  }
#endif

  template <typename = void>
  explicit constexpr TensorShapeProto_Dimension(::google::protobuf::internal::ConstantInitialized);

  inline TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from) : TensorShapeProto_Dimension(nullptr, from) {}
  inline TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
      : TensorShapeProto_Dimension(nullptr, ::std::move(from)) {}
  inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TensorShapeProto_Dimension& default_instance() {
    return *reinterpret_cast<const TensorShapeProto_Dimension*>(
        &_TensorShapeProto_Dimension_default_instance_);
  }
  enum ValueCase {
    kDimValue = 1,
    kDimParam = 2,
    VALUE_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 17;
  friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) { a.Swap(&b); }
  inline void Swap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TensorShapeProto_Dimension* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto_Dimension>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TensorShapeProto_Dimension& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TensorShapeProto_Dimension& from) { TensorShapeProto_Dimension::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TensorShapeProto_Dimension* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto.Dimension"; }

  explicit TensorShapeProto_Dimension(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TensorShapeProto_Dimension(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorShapeProto_Dimension& from);
  TensorShapeProto_Dimension(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorShapeProto_Dimension&& from) noexcept
      : TensorShapeProto_Dimension(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDenotationFieldNumber = 3,
    kDimValueFieldNumber = 1,
    kDimParamFieldNumber = 2,
  };
  // optional string denotation = 3;
  [[nodiscard]] bool has_denotation()
      const;
  void clear_denotation() ;
  [[nodiscard]] const ::std::string& denotation() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_denotation(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_denotation();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_denotation();
  void set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_denotation() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_denotation();

  public:
  // int64 dim_value = 1;
  [[nodiscard]] bool has_dim_value()
      const;
  void clear_dim_value() ;
  [[nodiscard]] ::int64_t dim_value() const;
  void set_dim_value(::int64_t value);

  private:
  ::int64_t _internal_dim_value() const;
  void _internal_set_dim_value(::int64_t value);

  public:
  // string dim_param = 2;
  [[nodiscard]] bool has_dim_param()
      const;
  void clear_dim_param() ;
  [[nodiscard]] const ::std::string& dim_param() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_dim_param(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_dim_param();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dim_param();
  void set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_dim_param() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_dim_param();

  public:
  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
 private:
  class _Internal;
  void set_has_dim_value();
  void set_has_dim_param();
  [[nodiscard]] inline bool has_value() const;
  inline void clear_has_value();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 3,
                                   0, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TensorShapeProto_Dimension& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr denotation_;
    union ValueUnion {
      constexpr ValueUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::int64_t dim_value_;
      ::google::protobuf::internal::ArenaStringPtr dim_param_;
    } value_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_Dimension_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TensorProto_Segment final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
 public:
  inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
  ~TensorProto_Segment() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TensorProto_Segment* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorProto_Segment));
  }
#endif

  template <typename = void>
  explicit constexpr TensorProto_Segment(::google::protobuf::internal::ConstantInitialized);

  inline TensorProto_Segment(const TensorProto_Segment& from) : TensorProto_Segment(nullptr, from) {}
  inline TensorProto_Segment(TensorProto_Segment&& from) noexcept
      : TensorProto_Segment(nullptr, ::std::move(from)) {}
  inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TensorProto_Segment& default_instance() {
    return *reinterpret_cast<const TensorProto_Segment*>(
        &_TensorProto_Segment_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 14;
  friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) { a.Swap(&b); }
  inline void Swap(TensorProto_Segment* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorProto_Segment* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TensorProto_Segment* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TensorProto_Segment>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TensorProto_Segment& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TensorProto_Segment& from) { TensorProto_Segment::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TensorProto_Segment* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TensorProto.Segment"; }

  explicit TensorProto_Segment(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TensorProto_Segment(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorProto_Segment& from);
  TensorProto_Segment(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorProto_Segment&& from) noexcept
      : TensorProto_Segment(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kBeginFieldNumber = 1,
    kEndFieldNumber = 2,
  };
  // optional int64 begin = 1;
  [[nodiscard]] bool has_begin()
      const;
  void clear_begin() ;
  [[nodiscard]] ::int64_t begin() const;
  void set_begin(::int64_t value);

  private:
  ::int64_t _internal_begin() const;
  void _internal_set_begin(::int64_t value);

  public:
  // optional int64 end = 2;
  [[nodiscard]] bool has_end()
      const;
  void clear_end() ;
  [[nodiscard]] ::int64_t end() const;
  void set_end(::int64_t value);

  private:
  ::int64_t _internal_end() const;
  void _internal_set_end(::int64_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TensorProto_Segment& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::int64_t begin_;
    ::int64_t end_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TensorProto_Segment_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED StringStringEntryProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
 public:
  inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
  ~StringStringEntryProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(StringStringEntryProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(StringStringEntryProto));
  }
#endif

  template <typename = void>
  explicit constexpr StringStringEntryProto(::google::protobuf::internal::ConstantInitialized);

  inline StringStringEntryProto(const StringStringEntryProto& from) : StringStringEntryProto(nullptr, from) {}
  inline StringStringEntryProto(StringStringEntryProto&& from) noexcept
      : StringStringEntryProto(nullptr, ::std::move(from)) {}
  inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const StringStringEntryProto& default_instance() {
    return *reinterpret_cast<const StringStringEntryProto*>(
        &_StringStringEntryProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 11;
  friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) { a.Swap(&b); }
  inline void Swap(StringStringEntryProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StringStringEntryProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] StringStringEntryProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<StringStringEntryProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const StringStringEntryProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const StringStringEntryProto& from) { StringStringEntryProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(StringStringEntryProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.StringStringEntryProto"; }

  explicit StringStringEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  StringStringEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StringStringEntryProto& from);
  StringStringEntryProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StringStringEntryProto&& from) noexcept
      : StringStringEntryProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional string key = 1;
  [[nodiscard]] bool has_key()
      const;
  void clear_key() ;
  [[nodiscard]] const ::std::string& key() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_key();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key();
  void set_allocated_key(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_key() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_key();

  public:
  // optional string value = 2;
  [[nodiscard]] bool has_value()
      const;
  void clear_value() ;
  [[nodiscard]] const ::std::string& value() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_value(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_value();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_value();
  void set_allocated_value(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_value() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_value(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_value();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const StringStringEntryProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr key_;
    ::google::protobuf::internal::ArenaStringPtr value_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull StringStringEntryProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SimpleShardedDimProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.SimpleShardedDimProto) */ {
 public:
  inline SimpleShardedDimProto() : SimpleShardedDimProto(nullptr) {}
  ~SimpleShardedDimProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SimpleShardedDimProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SimpleShardedDimProto));
  }
#endif

  template <typename = void>
  explicit constexpr SimpleShardedDimProto(::google::protobuf::internal::ConstantInitialized);

  inline SimpleShardedDimProto(const SimpleShardedDimProto& from) : SimpleShardedDimProto(nullptr, from) {}
  inline SimpleShardedDimProto(SimpleShardedDimProto&& from) noexcept
      : SimpleShardedDimProto(nullptr, ::std::move(from)) {}
  inline SimpleShardedDimProto& operator=(const SimpleShardedDimProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SimpleShardedDimProto& operator=(SimpleShardedDimProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const SimpleShardedDimProto& default_instance() {
    return *reinterpret_cast<const SimpleShardedDimProto*>(
        &_SimpleShardedDimProto_default_instance_);
  }
  enum DimCase {
    kDimValue = 1,
    kDimParam = 2,
    DIM_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(SimpleShardedDimProto& a, SimpleShardedDimProto& b) { a.Swap(&b); }
  inline void Swap(SimpleShardedDimProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SimpleShardedDimProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SimpleShardedDimProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SimpleShardedDimProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SimpleShardedDimProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SimpleShardedDimProto& from) { SimpleShardedDimProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SimpleShardedDimProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.SimpleShardedDimProto"; }

  explicit SimpleShardedDimProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SimpleShardedDimProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SimpleShardedDimProto& from);
  SimpleShardedDimProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SimpleShardedDimProto&& from) noexcept
      : SimpleShardedDimProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNumShardsFieldNumber = 3,
    kDimValueFieldNumber = 1,
    kDimParamFieldNumber = 2,
  };
  // optional int64 num_shards = 3;
  [[nodiscard]] bool has_num_shards()
      const;
  void clear_num_shards() ;
  [[nodiscard]] ::int64_t num_shards() const;
  void set_num_shards(::int64_t value);

  private:
  ::int64_t _internal_num_shards() const;
  void _internal_set_num_shards(::int64_t value);

  public:
  // int64 dim_value = 1;
  [[nodiscard]] bool has_dim_value()
      const;
  void clear_dim_value() ;
  [[nodiscard]] ::int64_t dim_value() const;
  void set_dim_value(::int64_t value);

  private:
  ::int64_t _internal_dim_value() const;
  void _internal_set_dim_value(::int64_t value);

  public:
  // string dim_param = 2;
  [[nodiscard]] bool has_dim_param()
      const;
  void clear_dim_param() ;
  [[nodiscard]] const ::std::string& dim_param() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_dim_param(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_dim_param();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dim_param();
  void set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_dim_param() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_dim_param();

  public:
  void clear_dim();
  DimCase dim_case() const;
  // @@protoc_insertion_point(class_scope:onnx.SimpleShardedDimProto)
 private:
  class _Internal;
  void set_has_dim_value();
  void set_has_dim_param();
  [[nodiscard]] inline bool has_dim() const;
  inline void clear_has_dim();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 3,
                                   0, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SimpleShardedDimProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::int64_t num_shards_;
    union DimUnion {
      constexpr DimUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::int64_t dim_value_;
      ::google::protobuf::internal::ArenaStringPtr dim_param_;
    } dim_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull SimpleShardedDimProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED OperatorSetIdProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
 public:
  inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
  ~OperatorSetIdProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(OperatorSetIdProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(OperatorSetIdProto));
  }
#endif

  template <typename = void>
  explicit constexpr OperatorSetIdProto(::google::protobuf::internal::ConstantInitialized);

  inline OperatorSetIdProto(const OperatorSetIdProto& from) : OperatorSetIdProto(nullptr, from) {}
  inline OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
      : OperatorSetIdProto(nullptr, ::std::move(from)) {}
  inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const OperatorSetIdProto& default_instance() {
    return *reinterpret_cast<const OperatorSetIdProto*>(
        &_OperatorSetIdProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 26;
  friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) { a.Swap(&b); }
  inline void Swap(OperatorSetIdProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OperatorSetIdProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] OperatorSetIdProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<OperatorSetIdProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OperatorSetIdProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const OperatorSetIdProto& from) { OperatorSetIdProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(OperatorSetIdProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.OperatorSetIdProto"; }

  explicit OperatorSetIdProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  OperatorSetIdProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OperatorSetIdProto& from);
  OperatorSetIdProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OperatorSetIdProto&& from) noexcept
      : OperatorSetIdProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDomainFieldNumber = 1,
    kVersionFieldNumber = 2,
  };
  // optional string domain = 1;
  [[nodiscard]] bool has_domain()
      const;
  void clear_domain() ;
  [[nodiscard]] const ::std::string& domain() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_domain(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_domain();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
  void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_domain() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // optional int64 version = 2;
  [[nodiscard]] bool has_version()
      const;
  void clear_version() ;
  [[nodiscard]] ::int64_t version() const;
  void set_version(::int64_t value);

  private:
  ::int64_t _internal_version() const;
  void _internal_set_version(::int64_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const OperatorSetIdProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr domain_;
    ::int64_t version_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull OperatorSetIdProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED IntIntListEntryProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.IntIntListEntryProto) */ {
 public:
  inline IntIntListEntryProto() : IntIntListEntryProto(nullptr) {}
  ~IntIntListEntryProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(IntIntListEntryProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(IntIntListEntryProto));
  }
#endif

  template <typename = void>
  explicit constexpr IntIntListEntryProto(::google::protobuf::internal::ConstantInitialized);

  inline IntIntListEntryProto(const IntIntListEntryProto& from) : IntIntListEntryProto(nullptr, from) {}
  inline IntIntListEntryProto(IntIntListEntryProto&& from) noexcept
      : IntIntListEntryProto(nullptr, ::std::move(from)) {}
  inline IntIntListEntryProto& operator=(const IntIntListEntryProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntIntListEntryProto& operator=(IntIntListEntryProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const IntIntListEntryProto& default_instance() {
    return *reinterpret_cast<const IntIntListEntryProto*>(
        &_IntIntListEntryProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(IntIntListEntryProto& a, IntIntListEntryProto& b) { a.Swap(&b); }
  inline void Swap(IntIntListEntryProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntIntListEntryProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] IntIntListEntryProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<IntIntListEntryProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IntIntListEntryProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const IntIntListEntryProto& from) { IntIntListEntryProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(IntIntListEntryProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.IntIntListEntryProto"; }

  explicit IntIntListEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  IntIntListEntryProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IntIntListEntryProto& from);
  IntIntListEntryProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IntIntListEntryProto&& from) noexcept
      : IntIntListEntryProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kValueFieldNumber = 2,
    kKeyFieldNumber = 1,
  };
  // repeated int64 value = 2;
  [[nodiscard]] int value_size()
      const;
  private:
  int _internal_value_size() const;

  public:
  void clear_value() ;
  [[nodiscard]] ::int64_t value(int index) const;
  void set_value(int index, ::int64_t value);
  void add_value(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& value() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_value();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_value() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_value();

  public:
  // optional int64 key = 1;
  [[nodiscard]] bool has_key()
      const;
  void clear_key() ;
  [[nodiscard]] ::int64_t key() const;
  void set_key(::int64_t value);

  private:
  ::int64_t _internal_key() const;
  void _internal_set_key(::int64_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const IntIntListEntryProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::int64_t> value_;
    ::int64_t key_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull IntIntListEntryProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DeviceConfigurationProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.DeviceConfigurationProto) */ {
 public:
  inline DeviceConfigurationProto() : DeviceConfigurationProto(nullptr) {}
  ~DeviceConfigurationProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DeviceConfigurationProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DeviceConfigurationProto));
  }
#endif

  template <typename = void>
  explicit constexpr DeviceConfigurationProto(::google::protobuf::internal::ConstantInitialized);

  inline DeviceConfigurationProto(const DeviceConfigurationProto& from) : DeviceConfigurationProto(nullptr, from) {}
  inline DeviceConfigurationProto(DeviceConfigurationProto&& from) noexcept
      : DeviceConfigurationProto(nullptr, ::std::move(from)) {}
  inline DeviceConfigurationProto& operator=(const DeviceConfigurationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceConfigurationProto& operator=(DeviceConfigurationProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DeviceConfigurationProto& default_instance() {
    return *reinterpret_cast<const DeviceConfigurationProto*>(
        &_DeviceConfigurationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(DeviceConfigurationProto& a, DeviceConfigurationProto& b) { a.Swap(&b); }
  inline void Swap(DeviceConfigurationProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeviceConfigurationProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] DeviceConfigurationProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<DeviceConfigurationProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DeviceConfigurationProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const DeviceConfigurationProto& from) { DeviceConfigurationProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DeviceConfigurationProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.DeviceConfigurationProto"; }

  explicit DeviceConfigurationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DeviceConfigurationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DeviceConfigurationProto& from);
  DeviceConfigurationProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DeviceConfigurationProto&& from) noexcept
      : DeviceConfigurationProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceFieldNumber = 3,
    kNameFieldNumber = 1,
    kNumDevicesFieldNumber = 2,
  };
  // repeated string device = 3;
  [[nodiscard]] int device_size()
      const;
  private:
  int _internal_device_size() const;

  public:
  void clear_device() ;
  [[nodiscard]] const ::std::string& device(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_device(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_device(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_device();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_device(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  device() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_device();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_device() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_device();

  public:
  // optional string name = 1;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional int32 num_devices = 2;
  [[nodiscard]] bool has_num_devices()
      const;
  void clear_num_devices() ;
  [[nodiscard]] ::int32_t num_devices() const;
  void set_num_devices(::int32_t value);

  private:
  ::int32_t _internal_num_devices() const;
  void _internal_set_num_devices(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DeviceConfigurationProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> device_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::int32_t num_devices_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull DeviceConfigurationProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TensorShapeProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
 public:
  inline TensorShapeProto() : TensorShapeProto(nullptr) {}
  ~TensorShapeProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TensorShapeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorShapeProto));
  }
#endif

  template <typename = void>
  explicit constexpr TensorShapeProto(::google::protobuf::internal::ConstantInitialized);

  inline TensorShapeProto(const TensorShapeProto& from) : TensorShapeProto(nullptr, from) {}
  inline TensorShapeProto(TensorShapeProto&& from) noexcept
      : TensorShapeProto(nullptr, ::std::move(from)) {}
  inline TensorShapeProto& operator=(const TensorShapeProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TensorShapeProto& default_instance() {
    return *reinterpret_cast<const TensorShapeProto*>(
        &_TensorShapeProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 18;
  friend void swap(TensorShapeProto& a, TensorShapeProto& b) { a.Swap(&b); }
  inline void Swap(TensorShapeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorShapeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TensorShapeProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TensorShapeProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TensorShapeProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TensorShapeProto& from) { TensorShapeProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TensorShapeProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TensorShapeProto"; }

  explicit TensorShapeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TensorShapeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorShapeProto& from);
  TensorShapeProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorShapeProto&& from) noexcept
      : TensorShapeProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Dimension = TensorShapeProto_Dimension;

  // accessors -------------------------------------------------------
  enum : int {
    kDimFieldNumber = 1,
  };
  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
  [[nodiscard]] int dim_size()
      const;
  private:
  int _internal_dim_size() const;

  public:
  void clear_dim() ;
  [[nodiscard]] ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL mutable_dim(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL
  mutable_dim();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& _internal_dim() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL _internal_mutable_dim();
  public:
  [[nodiscard]] const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
  ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL add_dim();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& dim()
      const;
  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 1,
                                   1, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TensorShapeProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TensorShapeProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TensorProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
 public:
  inline TensorProto() : TensorProto(nullptr) {}
  ~TensorProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TensorProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorProto));
  }
#endif

  template <typename = void>
  explicit constexpr TensorProto(::google::protobuf::internal::ConstantInitialized);

  inline TensorProto(const TensorProto& from) : TensorProto(nullptr, from) {}
  inline TensorProto(TensorProto&& from) noexcept
      : TensorProto(nullptr, ::std::move(from)) {}
  inline TensorProto& operator=(const TensorProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorProto& operator=(TensorProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TensorProto& default_instance() {
    return *reinterpret_cast<const TensorProto*>(
        &_TensorProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 15;
  friend void swap(TensorProto& a, TensorProto& b) { a.Swap(&b); }
  inline void Swap(TensorProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TensorProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TensorProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TensorProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TensorProto& from) { TensorProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TensorProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TensorProto"; }

  explicit TensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorProto& from);
  TensorProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorProto&& from) noexcept
      : TensorProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Segment = TensorProto_Segment;
  using DataType = TensorProto_DataType;
  static constexpr DataType UNDEFINED = TensorProto_DataType_UNDEFINED;
  static constexpr DataType FLOAT = TensorProto_DataType_FLOAT;
  static constexpr DataType UINT8 = TensorProto_DataType_UINT8;
  static constexpr DataType INT8 = TensorProto_DataType_INT8;
  static constexpr DataType UINT16 = TensorProto_DataType_UINT16;
  static constexpr DataType INT16 = TensorProto_DataType_INT16;
  static constexpr DataType INT32 = TensorProto_DataType_INT32;
  static constexpr DataType INT64 = TensorProto_DataType_INT64;
  static constexpr DataType STRING = TensorProto_DataType_STRING;
  static constexpr DataType BOOL = TensorProto_DataType_BOOL;
  static constexpr DataType FLOAT16 = TensorProto_DataType_FLOAT16;
  static constexpr DataType DOUBLE = TensorProto_DataType_DOUBLE;
  static constexpr DataType UINT32 = TensorProto_DataType_UINT32;
  static constexpr DataType UINT64 = TensorProto_DataType_UINT64;
  static constexpr DataType COMPLEX64 = TensorProto_DataType_COMPLEX64;
  static constexpr DataType COMPLEX128 = TensorProto_DataType_COMPLEX128;
  static constexpr DataType BFLOAT16 = TensorProto_DataType_BFLOAT16;
  static constexpr DataType FLOAT8E4M3FN = TensorProto_DataType_FLOAT8E4M3FN;
  static constexpr DataType FLOAT8E4M3FNUZ = TensorProto_DataType_FLOAT8E4M3FNUZ;
  static constexpr DataType FLOAT8E5M2 = TensorProto_DataType_FLOAT8E5M2;
  static constexpr DataType FLOAT8E5M2FNUZ = TensorProto_DataType_FLOAT8E5M2FNUZ;
  static constexpr DataType UINT4 = TensorProto_DataType_UINT4;
  static constexpr DataType INT4 = TensorProto_DataType_INT4;
  static constexpr DataType FLOAT4E2M1 = TensorProto_DataType_FLOAT4E2M1;
  static constexpr DataType FLOAT8E8M0 = TensorProto_DataType_FLOAT8E8M0;
  static constexpr DataType UINT2 = TensorProto_DataType_UINT2;
  static constexpr DataType INT2 = TensorProto_DataType_INT2;
  [[nodiscard]] static inline bool DataType_IsValid(int value) {
    return TensorProto_DataType_IsValid(value);
  }
  static constexpr DataType DataType_MIN = TensorProto_DataType_DataType_MIN;
  static constexpr DataType DataType_MAX = TensorProto_DataType_DataType_MAX;
  static constexpr int DataType_ARRAYSIZE = TensorProto_DataType_DataType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataType_descriptor() {
    return TensorProto_DataType_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& DataType_Name(T value) {
    return TensorProto_DataType_Name(value);
  }
  [[nodiscard]] static inline bool DataType_Parse(
      ::absl::string_view name, DataType* PROTOBUF_NONNULL value) {
    return TensorProto_DataType_Parse(name, value);
  }
  using DataLocation = TensorProto_DataLocation;
  static constexpr DataLocation DEFAULT = TensorProto_DataLocation_DEFAULT;
  static constexpr DataLocation EXTERNAL = TensorProto_DataLocation_EXTERNAL;
  [[nodiscard]] static inline bool DataLocation_IsValid(int value) {
    return TensorProto_DataLocation_IsValid(value);
  }
  static constexpr DataLocation DataLocation_MIN = TensorProto_DataLocation_DataLocation_MIN;
  static constexpr DataLocation DataLocation_MAX = TensorProto_DataLocation_DataLocation_MAX;
  static constexpr int DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataLocation_descriptor() {
    return TensorProto_DataLocation_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& DataLocation_Name(T value) {
    return TensorProto_DataLocation_Name(value);
  }
  [[nodiscard]] static inline bool DataLocation_Parse(
      ::absl::string_view name, DataLocation* PROTOBUF_NONNULL value) {
    return TensorProto_DataLocation_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kDimsFieldNumber = 1,
    kFloatDataFieldNumber = 4,
    kInt32DataFieldNumber = 5,
    kStringDataFieldNumber = 6,
    kInt64DataFieldNumber = 7,
    kDoubleDataFieldNumber = 10,
    kUint64DataFieldNumber = 11,
    kExternalDataFieldNumber = 13,
    kMetadataPropsFieldNumber = 16,
    kNameFieldNumber = 8,
    kRawDataFieldNumber = 9,
    kDocStringFieldNumber = 12,
    kSegmentFieldNumber = 3,
    kDataTypeFieldNumber = 2,
    kDataLocationFieldNumber = 14,
  };
  // repeated int64 dims = 1;
  [[nodiscard]] int dims_size()
      const;
  private:
  int _internal_dims_size() const;

  public:
  void clear_dims() ;
  [[nodiscard]] ::int64_t dims(int index) const;
  void set_dims(int index, ::int64_t value);
  void add_dims(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_dims();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_dims();

  public:
  // repeated float float_data = 4 [packed = true];
  [[nodiscard]] int float_data_size()
      const;
  private:
  int _internal_float_data_size() const;

  public:
  void clear_float_data() ;
  [[nodiscard]] float float_data(int index) const;
  void set_float_data(int index, float value);
  void add_float_data(float value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<float>& float_data() const;
  ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL mutable_float_data();

  private:
  const ::google::protobuf::RepeatedField<float>& _internal_float_data() const;
  ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL _internal_mutable_float_data();

  public:
  // repeated int32 int32_data = 5 [packed = true];
  [[nodiscard]] int int32_data_size()
      const;
  private:
  int _internal_int32_data_size() const;

  public:
  void clear_int32_data() ;
  [[nodiscard]] ::int32_t int32_data(int index) const;
  void set_int32_data(int index, ::int32_t value);
  void add_int32_data(::int32_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int32_t>& int32_data() const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL mutable_int32_data();

  private:
  const ::google::protobuf::RepeatedField<::int32_t>& _internal_int32_data() const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL _internal_mutable_int32_data();

  public:
  // repeated bytes string_data = 6;
  [[nodiscard]] int string_data_size()
      const;
  private:
  int _internal_string_data_size() const;

  public:
  void clear_string_data() ;
  [[nodiscard]] const ::std::string& string_data(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_string_data(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_string_data(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_string_data();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_string_data(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  string_data() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_string_data();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_string_data() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_string_data();

  public:
  // repeated int64 int64_data = 7 [packed = true];
  [[nodiscard]] int int64_data_size()
      const;
  private:
  int _internal_int64_data_size() const;

  public:
  void clear_int64_data() ;
  [[nodiscard]] ::int64_t int64_data(int index) const;
  void set_int64_data(int index, ::int64_t value);
  void add_int64_data(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& int64_data() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_int64_data();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_int64_data() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_int64_data();

  public:
  // repeated double double_data = 10 [packed = true];
  [[nodiscard]] int double_data_size()
      const;
  private:
  int _internal_double_data_size() const;

  public:
  void clear_double_data() ;
  [[nodiscard]] double double_data(int index) const;
  void set_double_data(int index, double value);
  void add_double_data(double value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<double>& double_data() const;
  ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL mutable_double_data();

  private:
  const ::google::protobuf::RepeatedField<double>& _internal_double_data() const;
  ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL _internal_mutable_double_data();

  public:
  // repeated uint64 uint64_data = 11 [packed = true];
  [[nodiscard]] int uint64_data_size()
      const;
  private:
  int _internal_uint64_data_size() const;

  public:
  void clear_uint64_data() ;
  [[nodiscard]] ::uint64_t uint64_data(int index) const;
  void set_uint64_data(int index, ::uint64_t value);
  void add_uint64_data(::uint64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::uint64_t>& uint64_data() const;
  ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL mutable_uint64_data();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_uint64_data() const;
  ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL _internal_mutable_uint64_data();

  public:
  // repeated .onnx.StringStringEntryProto external_data = 13;
  [[nodiscard]] int external_data_size()
      const;
  private:
  int _internal_external_data_size() const;

  public:
  void clear_external_data() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_external_data(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_external_data();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_external_data() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_external_data();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& external_data(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_external_data();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& external_data()
      const;
  // repeated .onnx.StringStringEntryProto metadata_props = 16;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // optional string name = 8;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional bytes raw_data = 9;
  [[nodiscard]] bool has_raw_data()
      const;
  void clear_raw_data() ;
  [[nodiscard]] const ::std::string& raw_data() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_raw_data(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_raw_data();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_raw_data();
  void set_allocated_raw_data(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_raw_data() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_raw_data();

  public:
  // optional string doc_string = 12;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional .onnx.TensorProto.Segment segment = 3;
  [[nodiscard]] bool has_segment()
      const;
  void clear_segment() ;
  [[nodiscard]] const ::onnx::TensorProto_Segment& segment() const;
  [[nodiscard]] ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE release_segment();
  ::onnx::TensorProto_Segment* PROTOBUF_NONNULL mutable_segment();
  void set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value);
  ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE unsafe_arena_release_segment();

  private:
  const ::onnx::TensorProto_Segment& _internal_segment() const;
  ::onnx::TensorProto_Segment* PROTOBUF_NONNULL _internal_mutable_segment();

  public:
  // optional int32 data_type = 2;
  [[nodiscard]] bool has_data_type()
      const;
  void clear_data_type() ;
  [[nodiscard]] ::int32_t data_type() const;
  void set_data_type(::int32_t value);

  private:
  ::int32_t _internal_data_type() const;
  void _internal_set_data_type(::int32_t value);

  public:
  // optional .onnx.TensorProto.DataLocation data_location = 14;
  [[nodiscard]] bool has_data_location()
      const;
  void clear_data_location() ;
  [[nodiscard]] ::onnx::TensorProto_DataLocation data_location() const;
  void set_data_location(::onnx::TensorProto_DataLocation value);

  private:
  ::onnx::TensorProto_DataLocation _internal_data_location() const;
  void _internal_set_data_location(::onnx::TensorProto_DataLocation value);

  public:
  // @@protoc_insertion_point(class_scope:onnx.TensorProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<4, 15,
                                   4, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TensorProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::int64_t> dims_;
    ::google::protobuf::RepeatedField<float> float_data_;
    ::google::protobuf::RepeatedField<::int32_t> int32_data_;
    ::google::protobuf::internal::CachedSize _int32_data_cached_byte_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> string_data_;
    ::google::protobuf::RepeatedField<::int64_t> int64_data_;
    ::google::protobuf::internal::CachedSize _int64_data_cached_byte_size_;
    ::google::protobuf::RepeatedField<double> double_data_;
    ::google::protobuf::RepeatedField<::uint64_t> uint64_data_;
    ::google::protobuf::internal::CachedSize _uint64_data_cached_byte_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr raw_data_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE segment_;
    ::int32_t data_type_;
    int data_location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TensorProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TensorAnnotation final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
 public:
  inline TensorAnnotation() : TensorAnnotation(nullptr) {}
  ~TensorAnnotation() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TensorAnnotation* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TensorAnnotation));
  }
#endif

  template <typename = void>
  explicit constexpr TensorAnnotation(::google::protobuf::internal::ConstantInitialized);

  inline TensorAnnotation(const TensorAnnotation& from) : TensorAnnotation(nullptr, from) {}
  inline TensorAnnotation(TensorAnnotation&& from) noexcept
      : TensorAnnotation(nullptr, ::std::move(from)) {}
  inline TensorAnnotation& operator=(const TensorAnnotation& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TensorAnnotation& default_instance() {
    return *reinterpret_cast<const TensorAnnotation*>(
        &_TensorAnnotation_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 12;
  friend void swap(TensorAnnotation& a, TensorAnnotation& b) { a.Swap(&b); }
  inline void Swap(TensorAnnotation* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorAnnotation* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TensorAnnotation* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TensorAnnotation>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TensorAnnotation& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TensorAnnotation& from) { TensorAnnotation::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TensorAnnotation* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TensorAnnotation"; }

  explicit TensorAnnotation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TensorAnnotation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TensorAnnotation& from);
  TensorAnnotation(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TensorAnnotation&& from) noexcept
      : TensorAnnotation(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kQuantParameterTensorNamesFieldNumber = 2,
    kTensorNameFieldNumber = 1,
  };
  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
  [[nodiscard]] int quant_parameter_tensor_names_size()
      const;
  private:
  int _internal_quant_parameter_tensor_names_size() const;

  public:
  void clear_quant_parameter_tensor_names() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_quant_parameter_tensor_names(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_quant_parameter_tensor_names();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_quant_parameter_tensor_names() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_quant_parameter_tensor_names();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_quant_parameter_tensor_names();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& quant_parameter_tensor_names()
      const;
  // optional string tensor_name = 1;
  [[nodiscard]] bool has_tensor_name()
      const;
  void clear_tensor_name() ;
  [[nodiscard]] const ::std::string& tensor_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_tensor_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_tensor_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tensor_name();
  void set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_tensor_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_tensor_name();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TensorAnnotation& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
    ::google::protobuf::internal::ArenaStringPtr tensor_name_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TensorAnnotation_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ShardedDimProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.ShardedDimProto) */ {
 public:
  inline ShardedDimProto() : ShardedDimProto(nullptr) {}
  ~ShardedDimProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ShardedDimProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ShardedDimProto));
  }
#endif

  template <typename = void>
  explicit constexpr ShardedDimProto(::google::protobuf::internal::ConstantInitialized);

  inline ShardedDimProto(const ShardedDimProto& from) : ShardedDimProto(nullptr, from) {}
  inline ShardedDimProto(ShardedDimProto&& from) noexcept
      : ShardedDimProto(nullptr, ::std::move(from)) {}
  inline ShardedDimProto& operator=(const ShardedDimProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShardedDimProto& operator=(ShardedDimProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ShardedDimProto& default_instance() {
    return *reinterpret_cast<const ShardedDimProto*>(
        &_ShardedDimProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(ShardedDimProto& a, ShardedDimProto& b) { a.Swap(&b); }
  inline void Swap(ShardedDimProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ShardedDimProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ShardedDimProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ShardedDimProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ShardedDimProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ShardedDimProto& from) { ShardedDimProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ShardedDimProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.ShardedDimProto"; }

  explicit ShardedDimProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ShardedDimProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ShardedDimProto& from);
  ShardedDimProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ShardedDimProto&& from) noexcept
      : ShardedDimProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kSimpleShardingFieldNumber = 2,
    kAxisFieldNumber = 1,
  };
  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
  [[nodiscard]] int simple_sharding_size()
      const;
  private:
  int _internal_simple_sharding_size() const;

  public:
  void clear_simple_sharding() ;
  [[nodiscard]] ::onnx::SimpleShardedDimProto* PROTOBUF_NONNULL mutable_simple_sharding(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>* PROTOBUF_NONNULL
  mutable_simple_sharding();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>& _internal_simple_sharding() const;
  ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>* PROTOBUF_NONNULL _internal_mutable_simple_sharding();
  public:
  [[nodiscard]] const ::onnx::SimpleShardedDimProto& simple_sharding(int index) const;
  ::onnx::SimpleShardedDimProto* PROTOBUF_NONNULL add_simple_sharding();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>& simple_sharding()
      const;
  // optional int64 axis = 1;
  [[nodiscard]] bool has_axis()
      const;
  void clear_axis() ;
  [[nodiscard]] ::int64_t axis() const;
  void set_axis(::int64_t value);

  private:
  ::int64_t _internal_axis() const;
  void _internal_set_axis(::int64_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ShardedDimProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::SimpleShardedDimProto > simple_sharding_;
    ::int64_t axis_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull ShardedDimProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_Tensor final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
 public:
  inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
  ~TypeProto_Tensor() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_Tensor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Tensor));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_Tensor(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_Tensor(const TypeProto_Tensor& from) : TypeProto_Tensor(nullptr, from) {}
  inline TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
      : TypeProto_Tensor(nullptr, ::std::move(from)) {}
  inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_Tensor& default_instance() {
    return *reinterpret_cast<const TypeProto_Tensor*>(
        &_TypeProto_Tensor_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 19;
  friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) { a.Swap(&b); }
  inline void Swap(TypeProto_Tensor* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_Tensor* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_Tensor* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_Tensor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_Tensor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_Tensor& from) { TypeProto_Tensor::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_Tensor* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Tensor"; }

  explicit TypeProto_Tensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_Tensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Tensor& from);
  TypeProto_Tensor(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Tensor&& from) noexcept
      : TypeProto_Tensor(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kShapeFieldNumber = 2,
    kElemTypeFieldNumber = 1,
  };
  // optional .onnx.TensorShapeProto shape = 2;
  [[nodiscard]] bool has_shape()
      const;
  void clear_shape() ;
  [[nodiscard]] const ::onnx::TensorShapeProto& shape() const;
  [[nodiscard]] ::onnx::TensorShapeProto* PROTOBUF_NULLABLE release_shape();
  ::onnx::TensorShapeProto* PROTOBUF_NONNULL mutable_shape();
  void set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
  ::onnx::TensorShapeProto* PROTOBUF_NULLABLE unsafe_arena_release_shape();

  private:
  const ::onnx::TensorShapeProto& _internal_shape() const;
  ::onnx::TensorShapeProto* PROTOBUF_NONNULL _internal_mutable_shape();

  public:
  // optional int32 elem_type = 1;
  [[nodiscard]] bool has_elem_type()
      const;
  void clear_elem_type() ;
  [[nodiscard]] ::int32_t elem_type() const;
  void set_elem_type(::int32_t value);

  private:
  ::int32_t _internal_elem_type() const;
  void _internal_set_elem_type(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_Tensor& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::onnx::TensorShapeProto* PROTOBUF_NULLABLE shape_;
    ::int32_t elem_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_Tensor_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_SparseTensor final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
 public:
  inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {}
  ~TypeProto_SparseTensor() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_SparseTensor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_SparseTensor));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_SparseTensor(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_SparseTensor(const TypeProto_SparseTensor& from) : TypeProto_SparseTensor(nullptr, from) {}
  inline TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
      : TypeProto_SparseTensor(nullptr, ::std::move(from)) {}
  inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_SparseTensor& default_instance() {
    return *reinterpret_cast<const TypeProto_SparseTensor*>(
        &_TypeProto_SparseTensor_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 23;
  friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) { a.Swap(&b); }
  inline void Swap(TypeProto_SparseTensor* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_SparseTensor* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_SparseTensor* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_SparseTensor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_SparseTensor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_SparseTensor& from) { TypeProto_SparseTensor::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_SparseTensor* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.SparseTensor"; }

  explicit TypeProto_SparseTensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_SparseTensor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_SparseTensor& from);
  TypeProto_SparseTensor(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_SparseTensor&& from) noexcept
      : TypeProto_SparseTensor(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kShapeFieldNumber = 2,
    kElemTypeFieldNumber = 1,
  };
  // optional .onnx.TensorShapeProto shape = 2;
  [[nodiscard]] bool has_shape()
      const;
  void clear_shape() ;
  [[nodiscard]] const ::onnx::TensorShapeProto& shape() const;
  [[nodiscard]] ::onnx::TensorShapeProto* PROTOBUF_NULLABLE release_shape();
  ::onnx::TensorShapeProto* PROTOBUF_NONNULL mutable_shape();
  void set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value);
  ::onnx::TensorShapeProto* PROTOBUF_NULLABLE unsafe_arena_release_shape();

  private:
  const ::onnx::TensorShapeProto& _internal_shape() const;
  ::onnx::TensorShapeProto* PROTOBUF_NONNULL _internal_mutable_shape();

  public:
  // optional int32 elem_type = 1;
  [[nodiscard]] bool has_elem_type()
      const;
  void clear_elem_type() ;
  [[nodiscard]] ::int32_t elem_type() const;
  void set_elem_type(::int32_t value);

  private:
  ::int32_t _internal_elem_type() const;
  void _internal_set_elem_type(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_SparseTensor& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::onnx::TensorShapeProto* PROTOBUF_NULLABLE shape_;
    ::int32_t elem_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_SparseTensor_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SparseTensorProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
 public:
  inline SparseTensorProto() : SparseTensorProto(nullptr) {}
  ~SparseTensorProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SparseTensorProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SparseTensorProto));
  }
#endif

  template <typename = void>
  explicit constexpr SparseTensorProto(::google::protobuf::internal::ConstantInitialized);

  inline SparseTensorProto(const SparseTensorProto& from) : SparseTensorProto(nullptr, from) {}
  inline SparseTensorProto(SparseTensorProto&& from) noexcept
      : SparseTensorProto(nullptr, ::std::move(from)) {}
  inline SparseTensorProto& operator=(const SparseTensorProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SparseTensorProto& operator=(SparseTensorProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const SparseTensorProto& default_instance() {
    return *reinterpret_cast<const SparseTensorProto*>(
        &_SparseTensorProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 16;
  friend void swap(SparseTensorProto& a, SparseTensorProto& b) { a.Swap(&b); }
  inline void Swap(SparseTensorProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SparseTensorProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SparseTensorProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SparseTensorProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SparseTensorProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SparseTensorProto& from) { SparseTensorProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SparseTensorProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.SparseTensorProto"; }

  explicit SparseTensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SparseTensorProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SparseTensorProto& from);
  SparseTensorProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SparseTensorProto&& from) noexcept
      : SparseTensorProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDimsFieldNumber = 3,
    kValuesFieldNumber = 1,
    kIndicesFieldNumber = 2,
  };
  // repeated int64 dims = 3;
  [[nodiscard]] int dims_size()
      const;
  private:
  int _internal_dims_size() const;

  public:
  void clear_dims() ;
  [[nodiscard]] ::int64_t dims(int index) const;
  void set_dims(int index, ::int64_t value);
  void add_dims(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& dims() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_dims();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_dims() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_dims();

  public:
  // optional .onnx.TensorProto values = 1;
  [[nodiscard]] bool has_values()
      const;
  void clear_values() ;
  [[nodiscard]] const ::onnx::TensorProto& values() const;
  [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_values();
  ::onnx::TensorProto* PROTOBUF_NONNULL mutable_values();
  void set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_values();

  private:
  const ::onnx::TensorProto& _internal_values() const;
  ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_values();

  public:
  // optional .onnx.TensorProto indices = 2;
  [[nodiscard]] bool has_indices()
      const;
  void clear_indices() ;
  [[nodiscard]] const ::onnx::TensorProto& indices() const;
  [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_indices();
  ::onnx::TensorProto* PROTOBUF_NONNULL mutable_indices();
  void set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_indices();

  private:
  const ::onnx::TensorProto& _internal_indices() const;
  ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_indices();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SparseTensorProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::int64_t> dims_;
    ::onnx::TensorProto* PROTOBUF_NULLABLE values_;
    ::onnx::TensorProto* PROTOBUF_NULLABLE indices_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull SparseTensorProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ShardingSpecProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.ShardingSpecProto) */ {
 public:
  inline ShardingSpecProto() : ShardingSpecProto(nullptr) {}
  ~ShardingSpecProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ShardingSpecProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ShardingSpecProto));
  }
#endif

  template <typename = void>
  explicit constexpr ShardingSpecProto(::google::protobuf::internal::ConstantInitialized);

  inline ShardingSpecProto(const ShardingSpecProto& from) : ShardingSpecProto(nullptr, from) {}
  inline ShardingSpecProto(ShardingSpecProto&& from) noexcept
      : ShardingSpecProto(nullptr, ::std::move(from)) {}
  inline ShardingSpecProto& operator=(const ShardingSpecProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ShardingSpecProto& operator=(ShardingSpecProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ShardingSpecProto& default_instance() {
    return *reinterpret_cast<const ShardingSpecProto*>(
        &_ShardingSpecProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(ShardingSpecProto& a, ShardingSpecProto& b) { a.Swap(&b); }
  inline void Swap(ShardingSpecProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ShardingSpecProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ShardingSpecProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ShardingSpecProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ShardingSpecProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ShardingSpecProto& from) { ShardingSpecProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ShardingSpecProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.ShardingSpecProto"; }

  explicit ShardingSpecProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ShardingSpecProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ShardingSpecProto& from);
  ShardingSpecProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ShardingSpecProto&& from) noexcept
      : ShardingSpecProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceFieldNumber = 2,
    kIndexToDeviceGroupMapFieldNumber = 3,
    kShardedDimFieldNumber = 4,
    kTensorNameFieldNumber = 1,
  };
  // repeated int64 device = 2;
  [[nodiscard]] int device_size()
      const;
  private:
  int _internal_device_size() const;

  public:
  void clear_device() ;
  [[nodiscard]] ::int64_t device(int index) const;
  void set_device(int index, ::int64_t value);
  void add_device(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& device() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_device();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_device() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_device();

  public:
  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
  [[nodiscard]] int index_to_device_group_map_size()
      const;
  private:
  int _internal_index_to_device_group_map_size() const;

  public:
  void clear_index_to_device_group_map() ;
  [[nodiscard]] ::onnx::IntIntListEntryProto* PROTOBUF_NONNULL mutable_index_to_device_group_map(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>* PROTOBUF_NONNULL
  mutable_index_to_device_group_map();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>& _internal_index_to_device_group_map() const;
  ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>* PROTOBUF_NONNULL _internal_mutable_index_to_device_group_map();
  public:
  [[nodiscard]] const ::onnx::IntIntListEntryProto& index_to_device_group_map(int index) const;
  ::onnx::IntIntListEntryProto* PROTOBUF_NONNULL add_index_to_device_group_map();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>& index_to_device_group_map()
      const;
  // repeated .onnx.ShardedDimProto sharded_dim = 4;
  [[nodiscard]] int sharded_dim_size()
      const;
  private:
  int _internal_sharded_dim_size() const;

  public:
  void clear_sharded_dim() ;
  [[nodiscard]] ::onnx::ShardedDimProto* PROTOBUF_NONNULL mutable_sharded_dim(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>* PROTOBUF_NONNULL
  mutable_sharded_dim();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>& _internal_sharded_dim() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>* PROTOBUF_NONNULL _internal_mutable_sharded_dim();
  public:
  [[nodiscard]] const ::onnx::ShardedDimProto& sharded_dim(int index) const;
  ::onnx::ShardedDimProto* PROTOBUF_NONNULL add_sharded_dim();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>& sharded_dim()
      const;
  // optional string tensor_name = 1;
  [[nodiscard]] bool has_tensor_name()
      const;
  void clear_tensor_name() ;
  [[nodiscard]] const ::std::string& tensor_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_tensor_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_tensor_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tensor_name();
  void set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_tensor_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_tensor_name();

  public:
  // @@protoc_insertion_point(class_scope:onnx.ShardingSpecProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 4,
                                   2, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ShardingSpecProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::int64_t> device_;
    ::google::protobuf::RepeatedPtrField< ::onnx::IntIntListEntryProto > index_to_device_group_map_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ShardedDimProto > sharded_dim_;
    ::google::protobuf::internal::ArenaStringPtr tensor_name_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull ShardingSpecProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
 public:
  inline TypeProto() : TypeProto(nullptr) {}
  ~TypeProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto(const TypeProto& from) : TypeProto(nullptr, from) {}
  inline TypeProto(TypeProto&& from) noexcept
      : TypeProto(nullptr, ::std::move(from)) {}
  inline TypeProto& operator=(const TypeProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto& operator=(TypeProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto& default_instance() {
    return *reinterpret_cast<const TypeProto*>(
        &_TypeProto_default_instance_);
  }
  enum ValueCase {
    kTensorType = 1,
    kSequenceType = 4,
    kMapType = 5,
    kOptionalType = 9,
    kSparseTensorType = 8,
    kOpaqueType = 7,
    VALUE_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 25;
  friend void swap(TypeProto& a, TypeProto& b) { a.Swap(&b); }
  inline void Swap(TypeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto& from) { TypeProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto"; }

  explicit TypeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto& from);
  TypeProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto&& from) noexcept
      : TypeProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using Tensor = TypeProto_Tensor;
  using Sequence = TypeProto_Sequence;
  using Map = TypeProto_Map;
  using Optional = TypeProto_Optional;
  using SparseTensor = TypeProto_SparseTensor;
  using Opaque = TypeProto_Opaque;

  // accessors -------------------------------------------------------
  enum : int {
    kDenotationFieldNumber = 6,
    kTensorTypeFieldNumber = 1,
    kSequenceTypeFieldNumber = 4,
    kMapTypeFieldNumber = 5,
    kOptionalTypeFieldNumber = 9,
    kSparseTensorTypeFieldNumber = 8,
    kOpaqueTypeFieldNumber = 7,
  };
  // optional string denotation = 6;
  [[nodiscard]] bool has_denotation()
      const;
  void clear_denotation() ;
  [[nodiscard]] const ::std::string& denotation() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_denotation(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_denotation();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_denotation();
  void set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_denotation() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_denotation();

  public:
  // .onnx.TypeProto.Tensor tensor_type = 1;
  [[nodiscard]] bool has_tensor_type()
      const;
  private:
  bool _internal_has_tensor_type() const;

  public:
  void clear_tensor_type() ;
  [[nodiscard]] const ::onnx::TypeProto_Tensor& tensor_type() const;
  [[nodiscard]] ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE release_tensor_type();
  ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL mutable_tensor_type();
  void set_allocated_tensor_type(::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE unsafe_arena_release_tensor_type();

  private:
  const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
  ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL _internal_mutable_tensor_type();

  public:
  // .onnx.TypeProto.Sequence sequence_type = 4;
  [[nodiscard]] bool has_sequence_type()
      const;
  private:
  bool _internal_has_sequence_type() const;

  public:
  void clear_sequence_type() ;
  [[nodiscard]] const ::onnx::TypeProto_Sequence& sequence_type() const;
  [[nodiscard]] ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE release_sequence_type();
  ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL mutable_sequence_type();
  void set_allocated_sequence_type(::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE unsafe_arena_release_sequence_type();

  private:
  const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
  ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL _internal_mutable_sequence_type();

  public:
  // .onnx.TypeProto.Map map_type = 5;
  [[nodiscard]] bool has_map_type()
      const;
  private:
  bool _internal_has_map_type() const;

  public:
  void clear_map_type() ;
  [[nodiscard]] const ::onnx::TypeProto_Map& map_type() const;
  [[nodiscard]] ::onnx::TypeProto_Map* PROTOBUF_NULLABLE release_map_type();
  ::onnx::TypeProto_Map* PROTOBUF_NONNULL mutable_map_type();
  void set_allocated_map_type(::onnx::TypeProto_Map* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_Map* PROTOBUF_NULLABLE unsafe_arena_release_map_type();

  private:
  const ::onnx::TypeProto_Map& _internal_map_type() const;
  ::onnx::TypeProto_Map* PROTOBUF_NONNULL _internal_mutable_map_type();

  public:
  // .onnx.TypeProto.Optional optional_type = 9;
  [[nodiscard]] bool has_optional_type()
      const;
  private:
  bool _internal_has_optional_type() const;

  public:
  void clear_optional_type() ;
  [[nodiscard]] const ::onnx::TypeProto_Optional& optional_type() const;
  [[nodiscard]] ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE release_optional_type();
  ::onnx::TypeProto_Optional* PROTOBUF_NONNULL mutable_optional_type();
  void set_allocated_optional_type(::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE unsafe_arena_release_optional_type();

  private:
  const ::onnx::TypeProto_Optional& _internal_optional_type() const;
  ::onnx::TypeProto_Optional* PROTOBUF_NONNULL _internal_mutable_optional_type();

  public:
  // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
  [[nodiscard]] bool has_sparse_tensor_type()
      const;
  private:
  bool _internal_has_sparse_tensor_type() const;

  public:
  void clear_sparse_tensor_type() ;
  [[nodiscard]] const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
  [[nodiscard]] ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE release_sparse_tensor_type();
  ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL mutable_sparse_tensor_type();
  void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE unsafe_arena_release_sparse_tensor_type();

  private:
  const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
  ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL _internal_mutable_sparse_tensor_type();

  public:
  // .onnx.TypeProto.Opaque opaque_type = 7;
  [[nodiscard]] bool has_opaque_type()
      const;
  private:
  bool _internal_has_opaque_type() const;

  public:
  void clear_opaque_type() ;
  [[nodiscard]] const ::onnx::TypeProto_Opaque& opaque_type() const;
  [[nodiscard]] ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE release_opaque_type();
  ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL mutable_opaque_type();
  void set_allocated_opaque_type(::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_opaque_type(::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE unsafe_arena_release_opaque_type();

  private:
  const ::onnx::TypeProto_Opaque& _internal_opaque_type() const;
  ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL _internal_mutable_opaque_type();

  public:
  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:onnx.TypeProto)
 private:
  class _Internal;
  void set_has_tensor_type();
  void set_has_sequence_type();
  void set_has_map_type();
  void set_has_optional_type();
  void set_has_sparse_tensor_type();
  void set_has_opaque_type();
  [[nodiscard]] inline bool has_value() const;
  inline void clear_has_value();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 7,
                                   6, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr denotation_;
    union ValueUnion {
      constexpr ValueUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE tensor_type_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE sequence_type_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE map_type_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE optional_type_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE sparse_tensor_type_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE opaque_type_;
    } value_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_Map final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
 public:
  inline TypeProto_Map() : TypeProto_Map(nullptr) {}
  ~TypeProto_Map() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_Map* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Map));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_Map(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_Map(const TypeProto_Map& from) : TypeProto_Map(nullptr, from) {}
  inline TypeProto_Map(TypeProto_Map&& from) noexcept
      : TypeProto_Map(nullptr, ::std::move(from)) {}
  inline TypeProto_Map& operator=(const TypeProto_Map& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_Map& default_instance() {
    return *reinterpret_cast<const TypeProto_Map*>(
        &_TypeProto_Map_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 21;
  friend void swap(TypeProto_Map& a, TypeProto_Map& b) { a.Swap(&b); }
  inline void Swap(TypeProto_Map* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_Map* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_Map* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_Map>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_Map& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_Map& from) { TypeProto_Map::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_Map* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Map"; }

  explicit TypeProto_Map(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_Map(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Map& from);
  TypeProto_Map(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Map&& from) noexcept
      : TypeProto_Map(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kValueTypeFieldNumber = 2,
    kKeyTypeFieldNumber = 1,
  };
  // optional .onnx.TypeProto value_type = 2;
  [[nodiscard]] bool has_value_type()
      const;
  void clear_value_type() ;
  [[nodiscard]] const ::onnx::TypeProto& value_type() const;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_value_type();
  ::onnx::TypeProto* PROTOBUF_NONNULL mutable_value_type();
  void set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_value_type();

  private:
  const ::onnx::TypeProto& _internal_value_type() const;
  ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_value_type();

  public:
  // optional int32 key_type = 1;
  [[nodiscard]] bool has_key_type()
      const;
  void clear_key_type() ;
  [[nodiscard]] ::int32_t key_type() const;
  void set_key_type(::int32_t value);

  private:
  ::int32_t _internal_key_type() const;
  void _internal_set_key_type(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_Map& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::onnx::TypeProto* PROTOBUF_NULLABLE value_type_;
    ::int32_t key_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_Map_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_Optional final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
 public:
  inline TypeProto_Optional() : TypeProto_Optional(nullptr) {}
  ~TypeProto_Optional() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_Optional* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Optional));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_Optional(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_Optional(const TypeProto_Optional& from) : TypeProto_Optional(nullptr, from) {}
  inline TypeProto_Optional(TypeProto_Optional&& from) noexcept
      : TypeProto_Optional(nullptr, ::std::move(from)) {}
  inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_Optional& operator=(TypeProto_Optional&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_Optional& default_instance() {
    return *reinterpret_cast<const TypeProto_Optional*>(
        &_TypeProto_Optional_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 22;
  friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) { a.Swap(&b); }
  inline void Swap(TypeProto_Optional* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_Optional* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_Optional* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_Optional>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_Optional& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_Optional& from) { TypeProto_Optional::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_Optional* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Optional"; }

  explicit TypeProto_Optional(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_Optional(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Optional& from);
  TypeProto_Optional(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Optional&& from) noexcept
      : TypeProto_Optional(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kElemTypeFieldNumber = 1,
  };
  // optional .onnx.TypeProto elem_type = 1;
  [[nodiscard]] bool has_elem_type()
      const;
  void clear_elem_type() ;
  [[nodiscard]] const ::onnx::TypeProto& elem_type() const;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_elem_type();
  ::onnx::TypeProto* PROTOBUF_NONNULL mutable_elem_type();
  void set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_elem_type();

  private:
  const ::onnx::TypeProto& _internal_elem_type() const;
  ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_elem_type();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_Optional& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::onnx::TypeProto* PROTOBUF_NULLABLE elem_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_Optional_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TypeProto_Sequence final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
 public:
  inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {}
  ~TypeProto_Sequence() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TypeProto_Sequence* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TypeProto_Sequence));
  }
#endif

  template <typename = void>
  explicit constexpr TypeProto_Sequence(::google::protobuf::internal::ConstantInitialized);

  inline TypeProto_Sequence(const TypeProto_Sequence& from) : TypeProto_Sequence(nullptr, from) {}
  inline TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
      : TypeProto_Sequence(nullptr, ::std::move(from)) {}
  inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TypeProto_Sequence& default_instance() {
    return *reinterpret_cast<const TypeProto_Sequence*>(
        &_TypeProto_Sequence_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 20;
  friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) { a.Swap(&b); }
  inline void Swap(TypeProto_Sequence* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeProto_Sequence* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TypeProto_Sequence* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TypeProto_Sequence>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeProto_Sequence& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TypeProto_Sequence& from) { TypeProto_Sequence::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TypeProto_Sequence* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TypeProto.Sequence"; }

  explicit TypeProto_Sequence(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TypeProto_Sequence(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TypeProto_Sequence& from);
  TypeProto_Sequence(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TypeProto_Sequence&& from) noexcept
      : TypeProto_Sequence(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kElemTypeFieldNumber = 1,
  };
  // optional .onnx.TypeProto elem_type = 1;
  [[nodiscard]] bool has_elem_type()
      const;
  void clear_elem_type() ;
  [[nodiscard]] const ::onnx::TypeProto& elem_type() const;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_elem_type();
  ::onnx::TypeProto* PROTOBUF_NONNULL mutable_elem_type();
  void set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_elem_type();

  private:
  const ::onnx::TypeProto& _internal_elem_type() const;
  ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_elem_type();

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TypeProto_Sequence& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::onnx::TypeProto* PROTOBUF_NULLABLE elem_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TypeProto_Sequence_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NodeDeviceConfigurationProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.NodeDeviceConfigurationProto) */ {
 public:
  inline NodeDeviceConfigurationProto() : NodeDeviceConfigurationProto(nullptr) {}
  ~NodeDeviceConfigurationProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NodeDeviceConfigurationProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NodeDeviceConfigurationProto));
  }
#endif

  template <typename = void>
  explicit constexpr NodeDeviceConfigurationProto(::google::protobuf::internal::ConstantInitialized);

  inline NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from) : NodeDeviceConfigurationProto(nullptr, from) {}
  inline NodeDeviceConfigurationProto(NodeDeviceConfigurationProto&& from) noexcept
      : NodeDeviceConfigurationProto(nullptr, ::std::move(from)) {}
  inline NodeDeviceConfigurationProto& operator=(const NodeDeviceConfigurationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeDeviceConfigurationProto& operator=(NodeDeviceConfigurationProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NodeDeviceConfigurationProto& default_instance() {
    return *reinterpret_cast<const NodeDeviceConfigurationProto*>(
        &_NodeDeviceConfigurationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(NodeDeviceConfigurationProto& a, NodeDeviceConfigurationProto& b) { a.Swap(&b); }
  inline void Swap(NodeDeviceConfigurationProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeDeviceConfigurationProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NodeDeviceConfigurationProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<NodeDeviceConfigurationProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NodeDeviceConfigurationProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NodeDeviceConfigurationProto& from) { NodeDeviceConfigurationProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NodeDeviceConfigurationProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.NodeDeviceConfigurationProto"; }

  explicit NodeDeviceConfigurationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NodeDeviceConfigurationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeDeviceConfigurationProto& from);
  NodeDeviceConfigurationProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NodeDeviceConfigurationProto&& from) noexcept
      : NodeDeviceConfigurationProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kShardingSpecFieldNumber = 2,
    kConfigurationIdFieldNumber = 1,
    kPipelineStageFieldNumber = 3,
  };
  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
  [[nodiscard]] int sharding_spec_size()
      const;
  private:
  int _internal_sharding_spec_size() const;

  public:
  void clear_sharding_spec() ;
  [[nodiscard]] ::onnx::ShardingSpecProto* PROTOBUF_NONNULL mutable_sharding_spec(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>* PROTOBUF_NONNULL
  mutable_sharding_spec();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>& _internal_sharding_spec() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>* PROTOBUF_NONNULL _internal_mutable_sharding_spec();
  public:
  [[nodiscard]] const ::onnx::ShardingSpecProto& sharding_spec(int index) const;
  ::onnx::ShardingSpecProto* PROTOBUF_NONNULL add_sharding_spec();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>& sharding_spec()
      const;
  // optional string configuration_id = 1;
  [[nodiscard]] bool has_configuration_id()
      const;
  void clear_configuration_id() ;
  [[nodiscard]] const ::std::string& configuration_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_configuration_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_configuration_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_configuration_id();
  void set_allocated_configuration_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_configuration_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_configuration_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_configuration_id();

  public:
  // optional int32 pipeline_stage = 3;
  [[nodiscard]] bool has_pipeline_stage()
      const;
  void clear_pipeline_stage() ;
  [[nodiscard]] ::int32_t pipeline_stage() const;
  void set_pipeline_stage(::int32_t value);

  private:
  ::int32_t _internal_pipeline_stage() const;
  void _internal_set_pipeline_stage(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NodeDeviceConfigurationProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ShardingSpecProto > sharding_spec_;
    ::google::protobuf::internal::ArenaStringPtr configuration_id_;
    ::int32_t pipeline_stage_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull NodeDeviceConfigurationProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ValueInfoProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
 public:
  inline ValueInfoProto() : ValueInfoProto(nullptr) {}
  ~ValueInfoProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ValueInfoProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ValueInfoProto));
  }
#endif

  template <typename = void>
  explicit constexpr ValueInfoProto(::google::protobuf::internal::ConstantInitialized);

  inline ValueInfoProto(const ValueInfoProto& from) : ValueInfoProto(nullptr, from) {}
  inline ValueInfoProto(ValueInfoProto&& from) noexcept
      : ValueInfoProto(nullptr, ::std::move(from)) {}
  inline ValueInfoProto& operator=(const ValueInfoProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ValueInfoProto& default_instance() {
    return *reinterpret_cast<const ValueInfoProto*>(
        &_ValueInfoProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(ValueInfoProto& a, ValueInfoProto& b) { a.Swap(&b); }
  inline void Swap(ValueInfoProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ValueInfoProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ValueInfoProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ValueInfoProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ValueInfoProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ValueInfoProto& from) { ValueInfoProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ValueInfoProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.ValueInfoProto"; }

  explicit ValueInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ValueInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ValueInfoProto& from);
  ValueInfoProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ValueInfoProto&& from) noexcept
      : ValueInfoProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kMetadataPropsFieldNumber = 4,
    kNameFieldNumber = 1,
    kDocStringFieldNumber = 3,
    kTypeFieldNumber = 2,
  };
  // repeated .onnx.StringStringEntryProto metadata_props = 4;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // optional string name = 1;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string doc_string = 3;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional .onnx.TypeProto type = 2;
  [[nodiscard]] bool has_type()
      const;
  void clear_type() ;
  [[nodiscard]] const ::onnx::TypeProto& type() const;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_type();
  ::onnx::TypeProto* PROTOBUF_NONNULL mutable_type();
  void set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_type();

  private:
  const ::onnx::TypeProto& _internal_type() const;
  ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_type();

  public:
  // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 4,
                                   2, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ValueInfoProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::onnx::TypeProto* PROTOBUF_NULLABLE type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull ValueInfoProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AttributeProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
 public:
  inline AttributeProto() : AttributeProto(nullptr) {}
  ~AttributeProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AttributeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AttributeProto));
  }
#endif

  template <typename = void>
  explicit constexpr AttributeProto(::google::protobuf::internal::ConstantInitialized);

  inline AttributeProto(const AttributeProto& from) : AttributeProto(nullptr, from) {}
  inline AttributeProto(AttributeProto&& from) noexcept
      : AttributeProto(nullptr, ::std::move(from)) {}
  inline AttributeProto& operator=(const AttributeProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttributeProto& operator=(AttributeProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const AttributeProto& default_instance() {
    return *reinterpret_cast<const AttributeProto*>(
        &_AttributeProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(AttributeProto& a, AttributeProto& b) { a.Swap(&b); }
  inline void Swap(AttributeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AttributeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AttributeProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AttributeProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AttributeProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AttributeProto& from) { AttributeProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AttributeProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.AttributeProto"; }

  explicit AttributeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AttributeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AttributeProto& from);
  AttributeProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AttributeProto&& from) noexcept
      : AttributeProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using AttributeType = AttributeProto_AttributeType;
  static constexpr AttributeType UNDEFINED = AttributeProto_AttributeType_UNDEFINED;
  static constexpr AttributeType FLOAT = AttributeProto_AttributeType_FLOAT;
  static constexpr AttributeType INT = AttributeProto_AttributeType_INT;
  static constexpr AttributeType STRING = AttributeProto_AttributeType_STRING;
  static constexpr AttributeType TENSOR = AttributeProto_AttributeType_TENSOR;
  static constexpr AttributeType GRAPH = AttributeProto_AttributeType_GRAPH;
  static constexpr AttributeType SPARSE_TENSOR = AttributeProto_AttributeType_SPARSE_TENSOR;
  static constexpr AttributeType TYPE_PROTO = AttributeProto_AttributeType_TYPE_PROTO;
  static constexpr AttributeType FLOATS = AttributeProto_AttributeType_FLOATS;
  static constexpr AttributeType INTS = AttributeProto_AttributeType_INTS;
  static constexpr AttributeType STRINGS = AttributeProto_AttributeType_STRINGS;
  static constexpr AttributeType TENSORS = AttributeProto_AttributeType_TENSORS;
  static constexpr AttributeType GRAPHS = AttributeProto_AttributeType_GRAPHS;
  static constexpr AttributeType SPARSE_TENSORS = AttributeProto_AttributeType_SPARSE_TENSORS;
  static constexpr AttributeType TYPE_PROTOS = AttributeProto_AttributeType_TYPE_PROTOS;
  [[nodiscard]] static inline bool AttributeType_IsValid(int value) {
    return AttributeProto_AttributeType_IsValid(value);
  }
  static constexpr AttributeType AttributeType_MIN = AttributeProto_AttributeType_AttributeType_MIN;
  static constexpr AttributeType AttributeType_MAX = AttributeProto_AttributeType_AttributeType_MAX;
  static constexpr int AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL AttributeType_descriptor() {
    return AttributeProto_AttributeType_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& AttributeType_Name(T value) {
    return AttributeProto_AttributeType_Name(value);
  }
  [[nodiscard]] static inline bool AttributeType_Parse(
      ::absl::string_view name, AttributeType* PROTOBUF_NONNULL value) {
    return AttributeProto_AttributeType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kFloatsFieldNumber = 7,
    kIntsFieldNumber = 8,
    kStringsFieldNumber = 9,
    kTensorsFieldNumber = 10,
    kGraphsFieldNumber = 11,
    kTypeProtosFieldNumber = 15,
    kSparseTensorsFieldNumber = 23,
    kNameFieldNumber = 1,
    kSFieldNumber = 4,
    kDocStringFieldNumber = 13,
    kRefAttrNameFieldNumber = 21,
    kTFieldNumber = 5,
    kGFieldNumber = 6,
    kTpFieldNumber = 14,
    kSparseTensorFieldNumber = 22,
    kIFieldNumber = 3,
    kFFieldNumber = 2,
    kTypeFieldNumber = 20,
  };
  // repeated float floats = 7;
  [[nodiscard]] int floats_size()
      const;
  private:
  int _internal_floats_size() const;

  public:
  void clear_floats() ;
  [[nodiscard]] float floats(int index) const;
  void set_floats(int index, float value);
  void add_floats(float value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<float>& floats() const;
  ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL mutable_floats();

  private:
  const ::google::protobuf::RepeatedField<float>& _internal_floats() const;
  ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL _internal_mutable_floats();

  public:
  // repeated int64 ints = 8;
  [[nodiscard]] int ints_size()
      const;
  private:
  int _internal_ints_size() const;

  public:
  void clear_ints() ;
  [[nodiscard]] ::int64_t ints(int index) const;
  void set_ints(int index, ::int64_t value);
  void add_ints(::int64_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int64_t>& ints() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_ints();

  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_ints() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_ints();

  public:
  // repeated bytes strings = 9;
  [[nodiscard]] int strings_size()
      const;
  private:
  int _internal_strings_size() const;

  public:
  void clear_strings() ;
  [[nodiscard]] const ::std::string& strings(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_strings(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_strings(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_strings();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_strings(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  strings() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_strings();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_strings() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_strings();

  public:
  // repeated .onnx.TensorProto tensors = 10;
  [[nodiscard]] int tensors_size()
      const;
  private:
  int _internal_tensors_size() const;

  public:
  void clear_tensors() ;
  [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NONNULL mutable_tensors(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
  mutable_tensors();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensors() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL _internal_mutable_tensors();
  public:
  [[nodiscard]] const ::onnx::TensorProto& tensors(int index) const;
  ::onnx::TensorProto* PROTOBUF_NONNULL add_tensors();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensors()
      const;
  // repeated .onnx.GraphProto graphs = 11;
  [[nodiscard]] int graphs_size()
      const;
  private:
  int _internal_graphs_size() const;

  public:
  void clear_graphs() ;
  [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NONNULL mutable_graphs(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL
  mutable_graphs();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& _internal_graphs() const;
  ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL _internal_mutable_graphs();
  public:
  [[nodiscard]] const ::onnx::GraphProto& graphs(int index) const;
  ::onnx::GraphProto* PROTOBUF_NONNULL add_graphs();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& graphs()
      const;
  // repeated .onnx.TypeProto type_protos = 15;
  [[nodiscard]] int type_protos_size()
      const;
  private:
  int _internal_type_protos_size() const;

  public:
  void clear_type_protos() ;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NONNULL mutable_type_protos(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL
  mutable_type_protos();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& _internal_type_protos() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL _internal_mutable_type_protos();
  public:
  [[nodiscard]] const ::onnx::TypeProto& type_protos(int index) const;
  ::onnx::TypeProto* PROTOBUF_NONNULL add_type_protos();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& type_protos()
      const;
  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
  [[nodiscard]] int sparse_tensors_size()
      const;
  private:
  int _internal_sparse_tensors_size() const;

  public:
  void clear_sparse_tensors() ;
  [[nodiscard]] ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensors(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
  mutable_sparse_tensors();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensors() const;
  ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL _internal_mutable_sparse_tensors();
  public:
  [[nodiscard]] const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
  ::onnx::SparseTensorProto* PROTOBUF_NONNULL add_sparse_tensors();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensors()
      const;
  // optional string name = 1;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional bytes s = 4;
  [[nodiscard]] bool has_s()
      const;
  void clear_s() ;
  [[nodiscard]] const ::std::string& s() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_s(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_s();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s();
  void set_allocated_s(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_s() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_s(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_s();

  public:
  // optional string doc_string = 13;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional string ref_attr_name = 21;
  [[nodiscard]] bool has_ref_attr_name()
      const;
  void clear_ref_attr_name() ;
  [[nodiscard]] const ::std::string& ref_attr_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_ref_attr_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_ref_attr_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ref_attr_name();
  void set_allocated_ref_attr_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_ref_attr_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_ref_attr_name();

  public:
  // optional .onnx.TensorProto t = 5;
  [[nodiscard]] bool has_t()
      const;
  void clear_t() ;
  [[nodiscard]] const ::onnx::TensorProto& t() const;
  [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NULLABLE release_t();
  ::onnx::TensorProto* PROTOBUF_NONNULL mutable_t();
  void set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value);
  ::onnx::TensorProto* PROTOBUF_NULLABLE unsafe_arena_release_t();

  private:
  const ::onnx::TensorProto& _internal_t() const;
  ::onnx::TensorProto* PROTOBUF_NONNULL _internal_mutable_t();

  public:
  // optional .onnx.GraphProto g = 6;
  [[nodiscard]] bool has_g()
      const;
  void clear_g() ;
  [[nodiscard]] const ::onnx::GraphProto& g() const;
  [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_g();
  ::onnx::GraphProto* PROTOBUF_NONNULL mutable_g();
  void set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_g();

  private:
  const ::onnx::GraphProto& _internal_g() const;
  ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_g();

  public:
  // optional .onnx.TypeProto tp = 14;
  [[nodiscard]] bool has_tp()
      const;
  void clear_tp() ;
  [[nodiscard]] const ::onnx::TypeProto& tp() const;
  [[nodiscard]] ::onnx::TypeProto* PROTOBUF_NULLABLE release_tp();
  ::onnx::TypeProto* PROTOBUF_NONNULL mutable_tp();
  void set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value);
  ::onnx::TypeProto* PROTOBUF_NULLABLE unsafe_arena_release_tp();

  private:
  const ::onnx::TypeProto& _internal_tp() const;
  ::onnx::TypeProto* PROTOBUF_NONNULL _internal_mutable_tp();

  public:
  // optional .onnx.SparseTensorProto sparse_tensor = 22;
  [[nodiscard]] bool has_sparse_tensor()
      const;
  void clear_sparse_tensor() ;
  [[nodiscard]] const ::onnx::SparseTensorProto& sparse_tensor() const;
  [[nodiscard]] ::onnx::SparseTensorProto* PROTOBUF_NULLABLE release_sparse_tensor();
  ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_tensor();
  void set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value);
  ::onnx::SparseTensorProto* PROTOBUF_NULLABLE unsafe_arena_release_sparse_tensor();

  private:
  const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
  ::onnx::SparseTensorProto* PROTOBUF_NONNULL _internal_mutable_sparse_tensor();

  public:
  // optional int64 i = 3;
  [[nodiscard]] bool has_i()
      const;
  void clear_i() ;
  [[nodiscard]] ::int64_t i() const;
  void set_i(::int64_t value);

  private:
  ::int64_t _internal_i() const;
  void _internal_set_i(::int64_t value);

  public:
  // optional float f = 2;
  [[nodiscard]] bool has_f()
      const;
  void clear_f() ;
  [[nodiscard]] float f() const;
  void set_f(float value);

  private:
  float _internal_f() const;
  void _internal_set_f(float value);

  public:
  // optional .onnx.AttributeProto.AttributeType type = 20;
  [[nodiscard]] bool has_type()
      const;
  void clear_type() ;
  [[nodiscard]] ::onnx::AttributeProto_AttributeType type() const;
  void set_type(::onnx::AttributeProto_AttributeType value);

  private:
  ::onnx::AttributeProto_AttributeType _internal_type() const;
  void _internal_set_type(::onnx::AttributeProto_AttributeType value);

  public:
  // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<5, 18,
                                   9, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AttributeProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<float> floats_;
    ::google::protobuf::RepeatedField<::int64_t> ints_;
    ::google::protobuf::RepeatedPtrField<::std::string> strings_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensors_;
    ::google::protobuf::RepeatedPtrField< ::onnx::GraphProto > graphs_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
    ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr s_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
    ::onnx::TensorProto* PROTOBUF_NULLABLE t_;
    ::onnx::GraphProto* PROTOBUF_NULLABLE g_;
    ::onnx::TypeProto* PROTOBUF_NULLABLE tp_;
    ::onnx::SparseTensorProto* PROTOBUF_NULLABLE sparse_tensor_;
    ::int64_t i_;
    float f_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull AttributeProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED GraphProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
 public:
  inline GraphProto() : GraphProto(nullptr) {}
  ~GraphProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(GraphProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(GraphProto));
  }
#endif

  template <typename = void>
  explicit constexpr GraphProto(::google::protobuf::internal::ConstantInitialized);

  inline GraphProto(const GraphProto& from) : GraphProto(nullptr, from) {}
  inline GraphProto(GraphProto&& from) noexcept
      : GraphProto(nullptr, ::std::move(from)) {}
  inline GraphProto& operator=(const GraphProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline GraphProto& operator=(GraphProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const GraphProto& default_instance() {
    return *reinterpret_cast<const GraphProto*>(
        &_GraphProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 13;
  friend void swap(GraphProto& a, GraphProto& b) { a.Swap(&b); }
  inline void Swap(GraphProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GraphProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] GraphProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<GraphProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GraphProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const GraphProto& from) { GraphProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(GraphProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.GraphProto"; }

  explicit GraphProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  GraphProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GraphProto& from);
  GraphProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GraphProto&& from) noexcept
      : GraphProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeFieldNumber = 1,
    kInitializerFieldNumber = 5,
    kInputFieldNumber = 11,
    kOutputFieldNumber = 12,
    kValueInfoFieldNumber = 13,
    kQuantizationAnnotationFieldNumber = 14,
    kSparseInitializerFieldNumber = 15,
    kMetadataPropsFieldNumber = 16,
    kNameFieldNumber = 2,
    kDocStringFieldNumber = 10,
  };
  // repeated .onnx.NodeProto node = 1;
  [[nodiscard]] int node_size()
      const;
  private:
  int _internal_node_size() const;

  public:
  void clear_node() ;
  [[nodiscard]] ::onnx::NodeProto* PROTOBUF_NONNULL mutable_node(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
  mutable_node();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
  ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL _internal_mutable_node();
  public:
  [[nodiscard]] const ::onnx::NodeProto& node(int index) const;
  ::onnx::NodeProto* PROTOBUF_NONNULL add_node();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node()
      const;
  // repeated .onnx.TensorProto initializer = 5;
  [[nodiscard]] int initializer_size()
      const;
  private:
  int _internal_initializer_size() const;

  public:
  void clear_initializer() ;
  [[nodiscard]] ::onnx::TensorProto* PROTOBUF_NONNULL mutable_initializer(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
  mutable_initializer();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_initializer() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL _internal_mutable_initializer();
  public:
  [[nodiscard]] const ::onnx::TensorProto& initializer(int index) const;
  ::onnx::TensorProto* PROTOBUF_NONNULL add_initializer();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& initializer()
      const;
  // repeated .onnx.ValueInfoProto input = 11;
  [[nodiscard]] int input_size()
      const;
  private:
  int _internal_input_size() const;

  public:
  void clear_input() ;
  [[nodiscard]] ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_input(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
  mutable_input();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_input() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_input();
  public:
  [[nodiscard]] const ::onnx::ValueInfoProto& input(int index) const;
  ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_input();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& input()
      const;
  // repeated .onnx.ValueInfoProto output = 12;
  [[nodiscard]] int output_size()
      const;
  private:
  int _internal_output_size() const;

  public:
  void clear_output() ;
  [[nodiscard]] ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_output(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
  mutable_output();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_output() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_output();
  public:
  [[nodiscard]] const ::onnx::ValueInfoProto& output(int index) const;
  ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_output();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& output()
      const;
  // repeated .onnx.ValueInfoProto value_info = 13;
  [[nodiscard]] int value_info_size()
      const;
  private:
  int _internal_value_info_size() const;

  public:
  void clear_value_info() ;
  [[nodiscard]] ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_value_info(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
  mutable_value_info();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_value_info();
  public:
  [[nodiscard]] const ::onnx::ValueInfoProto& value_info(int index) const;
  ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_value_info();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info()
      const;
  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
  [[nodiscard]] int quantization_annotation_size()
      const;
  private:
  int _internal_quantization_annotation_size() const;

  public:
  void clear_quantization_annotation() ;
  [[nodiscard]] ::onnx::TensorAnnotation* PROTOBUF_NONNULL mutable_quantization_annotation(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL
  mutable_quantization_annotation();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& _internal_quantization_annotation() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL _internal_mutable_quantization_annotation();
  public:
  [[nodiscard]] const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
  ::onnx::TensorAnnotation* PROTOBUF_NONNULL add_quantization_annotation();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& quantization_annotation()
      const;
  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
  [[nodiscard]] int sparse_initializer_size()
      const;
  private:
  int _internal_sparse_initializer_size() const;

  public:
  void clear_sparse_initializer() ;
  [[nodiscard]] ::onnx::SparseTensorProto* PROTOBUF_NONNULL mutable_sparse_initializer(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
  mutable_sparse_initializer();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_initializer() const;
  ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL _internal_mutable_sparse_initializer();
  public:
  [[nodiscard]] const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
  ::onnx::SparseTensorProto* PROTOBUF_NONNULL add_sparse_initializer();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_initializer()
      const;
  // repeated .onnx.StringStringEntryProto metadata_props = 16;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // optional string name = 2;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string doc_string = 10;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // @@protoc_insertion_point(class_scope:onnx.GraphProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<4, 10,
                                   8, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const GraphProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > initializer_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
    ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull GraphProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NodeProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
 public:
  inline NodeProto() : NodeProto(nullptr) {}
  ~NodeProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NodeProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NodeProto));
  }
#endif

  template <typename = void>
  explicit constexpr NodeProto(::google::protobuf::internal::ConstantInitialized);

  inline NodeProto(const NodeProto& from) : NodeProto(nullptr, from) {}
  inline NodeProto(NodeProto&& from) noexcept
      : NodeProto(nullptr, ::std::move(from)) {}
  inline NodeProto& operator=(const NodeProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeProto& operator=(NodeProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NodeProto& default_instance() {
    return *reinterpret_cast<const NodeProto*>(
        &_NodeProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(NodeProto& a, NodeProto& b) { a.Swap(&b); }
  inline void Swap(NodeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NodeProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<NodeProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NodeProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NodeProto& from) { NodeProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NodeProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.NodeProto"; }

  explicit NodeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NodeProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeProto& from);
  NodeProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NodeProto&& from) noexcept
      : NodeProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInputFieldNumber = 1,
    kOutputFieldNumber = 2,
    kAttributeFieldNumber = 5,
    kMetadataPropsFieldNumber = 9,
    kDeviceConfigurationsFieldNumber = 10,
    kNameFieldNumber = 3,
    kOpTypeFieldNumber = 4,
    kDocStringFieldNumber = 6,
    kDomainFieldNumber = 7,
    kOverloadFieldNumber = 8,
  };
  // repeated string input = 1;
  [[nodiscard]] int input_size()
      const;
  private:
  int _internal_input_size() const;

  public:
  void clear_input() ;
  [[nodiscard]] const ::std::string& input(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_input(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_input();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_input(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  input() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_input();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_input() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_input();

  public:
  // repeated string output = 2;
  [[nodiscard]] int output_size()
      const;
  private:
  int _internal_output_size() const;

  public:
  void clear_output() ;
  [[nodiscard]] const ::std::string& output(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_output(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_output();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_output(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  output() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_output();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_output() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_output();

  public:
  // repeated .onnx.AttributeProto attribute = 5;
  [[nodiscard]] int attribute_size()
      const;
  private:
  int _internal_attribute_size() const;

  public:
  void clear_attribute() ;
  [[nodiscard]] ::onnx::AttributeProto* PROTOBUF_NONNULL mutable_attribute(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
  mutable_attribute();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute() const;
  ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL _internal_mutable_attribute();
  public:
  [[nodiscard]] const ::onnx::AttributeProto& attribute(int index) const;
  ::onnx::AttributeProto* PROTOBUF_NONNULL add_attribute();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute()
      const;
  // repeated .onnx.StringStringEntryProto metadata_props = 9;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
  [[nodiscard]] int device_configurations_size()
      const;
  private:
  int _internal_device_configurations_size() const;

  public:
  void clear_device_configurations() ;
  [[nodiscard]] ::onnx::NodeDeviceConfigurationProto* PROTOBUF_NONNULL mutable_device_configurations(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>* PROTOBUF_NONNULL
  mutable_device_configurations();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>& _internal_device_configurations() const;
  ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>* PROTOBUF_NONNULL _internal_mutable_device_configurations();
  public:
  [[nodiscard]] const ::onnx::NodeDeviceConfigurationProto& device_configurations(int index) const;
  ::onnx::NodeDeviceConfigurationProto* PROTOBUF_NONNULL add_device_configurations();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>& device_configurations()
      const;
  // optional string name = 3;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string op_type = 4;
  [[nodiscard]] bool has_op_type()
      const;
  void clear_op_type() ;
  [[nodiscard]] const ::std::string& op_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_op_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_op_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_op_type();
  void set_allocated_op_type(::std::string* PROTOBUF_NULLABLE value);

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

  public:
  // optional string doc_string = 6;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional string domain = 7;
  [[nodiscard]] bool has_domain()
      const;
  void clear_domain() ;
  [[nodiscard]] const ::std::string& domain() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_domain(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_domain();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
  void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_domain() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // optional string overload = 8;
  [[nodiscard]] bool has_overload()
      const;
  void clear_overload() ;
  [[nodiscard]] const ::std::string& overload() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_overload(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_overload();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_overload();
  void set_allocated_overload(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_overload() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_overload();

  public:
  // @@protoc_insertion_point(class_scope:onnx.NodeProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<4, 10,
                                   3, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NodeProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> input_;
    ::google::protobuf::RepeatedPtrField<::std::string> output_;
    ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto > device_configurations_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr op_type_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::google::protobuf::internal::ArenaStringPtr domain_;
    ::google::protobuf::internal::ArenaStringPtr overload_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull NodeProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TrainingInfoProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
 public:
  inline TrainingInfoProto() : TrainingInfoProto(nullptr) {}
  ~TrainingInfoProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TrainingInfoProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TrainingInfoProto));
  }
#endif

  template <typename = void>
  explicit constexpr TrainingInfoProto(::google::protobuf::internal::ConstantInitialized);

  inline TrainingInfoProto(const TrainingInfoProto& from) : TrainingInfoProto(nullptr, from) {}
  inline TrainingInfoProto(TrainingInfoProto&& from) noexcept
      : TrainingInfoProto(nullptr, ::std::move(from)) {}
  inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TrainingInfoProto& operator=(TrainingInfoProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TrainingInfoProto& default_instance() {
    return *reinterpret_cast<const TrainingInfoProto*>(
        &_TrainingInfoProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) { a.Swap(&b); }
  inline void Swap(TrainingInfoProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TrainingInfoProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TrainingInfoProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TrainingInfoProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TrainingInfoProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TrainingInfoProto& from) { TrainingInfoProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TrainingInfoProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.TrainingInfoProto"; }

  explicit TrainingInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TrainingInfoProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TrainingInfoProto& from);
  TrainingInfoProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TrainingInfoProto&& from) noexcept
      : TrainingInfoProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInitializationBindingFieldNumber = 3,
    kUpdateBindingFieldNumber = 4,
    kInitializationFieldNumber = 1,
    kAlgorithmFieldNumber = 2,
  };
  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
  [[nodiscard]] int initialization_binding_size()
      const;
  private:
  int _internal_initialization_binding_size() const;

  public:
  void clear_initialization_binding() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_initialization_binding(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_initialization_binding();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_initialization_binding() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_initialization_binding();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_initialization_binding();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& initialization_binding()
      const;
  // repeated .onnx.StringStringEntryProto update_binding = 4;
  [[nodiscard]] int update_binding_size()
      const;
  private:
  int _internal_update_binding_size() const;

  public:
  void clear_update_binding() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_update_binding(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_update_binding();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_update_binding() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_update_binding();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& update_binding(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_update_binding();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& update_binding()
      const;
  // optional .onnx.GraphProto initialization = 1;
  [[nodiscard]] bool has_initialization()
      const;
  void clear_initialization() ;
  [[nodiscard]] const ::onnx::GraphProto& initialization() const;
  [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_initialization();
  ::onnx::GraphProto* PROTOBUF_NONNULL mutable_initialization();
  void set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_initialization();

  private:
  const ::onnx::GraphProto& _internal_initialization() const;
  ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_initialization();

  public:
  // optional .onnx.GraphProto algorithm = 2;
  [[nodiscard]] bool has_algorithm()
      const;
  void clear_algorithm() ;
  [[nodiscard]] const ::onnx::GraphProto& algorithm() const;
  [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_algorithm();
  ::onnx::GraphProto* PROTOBUF_NONNULL mutable_algorithm();
  void set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_algorithm();

  private:
  const ::onnx::GraphProto& _internal_algorithm() const;
  ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_algorithm();

  public:
  // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 4,
                                   4, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TrainingInfoProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
    ::onnx::GraphProto* PROTOBUF_NULLABLE initialization_;
    ::onnx::GraphProto* PROTOBUF_NULLABLE algorithm_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull TrainingInfoProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED FunctionProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
 public:
  inline FunctionProto() : FunctionProto(nullptr) {}
  ~FunctionProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(FunctionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(FunctionProto));
  }
#endif

  template <typename = void>
  explicit constexpr FunctionProto(::google::protobuf::internal::ConstantInitialized);

  inline FunctionProto(const FunctionProto& from) : FunctionProto(nullptr, from) {}
  inline FunctionProto(FunctionProto&& from) noexcept
      : FunctionProto(nullptr, ::std::move(from)) {}
  inline FunctionProto& operator=(const FunctionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionProto& operator=(FunctionProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const FunctionProto& default_instance() {
    return *reinterpret_cast<const FunctionProto*>(
        &_FunctionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 27;
  friend void swap(FunctionProto& a, FunctionProto& b) { a.Swap(&b); }
  inline void Swap(FunctionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] FunctionProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<FunctionProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FunctionProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const FunctionProto& from) { FunctionProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(FunctionProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.FunctionProto"; }

  explicit FunctionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FunctionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FunctionProto& from);
  FunctionProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FunctionProto&& from) noexcept
      : FunctionProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInputFieldNumber = 4,
    kOutputFieldNumber = 5,
    kAttributeFieldNumber = 6,
    kNodeFieldNumber = 7,
    kOpsetImportFieldNumber = 9,
    kAttributeProtoFieldNumber = 11,
    kValueInfoFieldNumber = 12,
    kMetadataPropsFieldNumber = 14,
    kNameFieldNumber = 1,
    kDocStringFieldNumber = 8,
    kDomainFieldNumber = 10,
    kOverloadFieldNumber = 13,
  };
  // repeated string input = 4;
  [[nodiscard]] int input_size()
      const;
  private:
  int _internal_input_size() const;

  public:
  void clear_input() ;
  [[nodiscard]] const ::std::string& input(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_input(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_input();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_input(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  input() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_input();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_input() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_input();

  public:
  // repeated string output = 5;
  [[nodiscard]] int output_size()
      const;
  private:
  int _internal_output_size() const;

  public:
  void clear_output() ;
  [[nodiscard]] const ::std::string& output(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_output(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_output();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_output(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  output() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_output();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_output() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_output();

  public:
  // repeated string attribute = 6;
  [[nodiscard]] int attribute_size()
      const;
  private:
  int _internal_attribute_size() const;

  public:
  void clear_attribute() ;
  [[nodiscard]] const ::std::string& attribute(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_attribute(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_attribute(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_attribute();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_attribute(Arg_&& value, Args_... args);
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::std::string>&
  attribute() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
  mutable_attribute();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_attribute() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_attribute();

  public:
  // repeated .onnx.NodeProto node = 7;
  [[nodiscard]] int node_size()
      const;
  private:
  int _internal_node_size() const;

  public:
  void clear_node() ;
  [[nodiscard]] ::onnx::NodeProto* PROTOBUF_NONNULL mutable_node(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
  mutable_node();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& _internal_node() const;
  ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL _internal_mutable_node();
  public:
  [[nodiscard]] const ::onnx::NodeProto& node(int index) const;
  ::onnx::NodeProto* PROTOBUF_NONNULL add_node();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& node()
      const;
  // repeated .onnx.OperatorSetIdProto opset_import = 9;
  [[nodiscard]] int opset_import_size()
      const;
  private:
  int _internal_opset_import_size() const;

  public:
  void clear_opset_import() ;
  [[nodiscard]] ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL mutable_opset_import(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
  mutable_opset_import();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
  ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL _internal_mutable_opset_import();
  public:
  [[nodiscard]] const ::onnx::OperatorSetIdProto& opset_import(int index) const;
  ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL add_opset_import();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import()
      const;
  // repeated .onnx.AttributeProto attribute_proto = 11;
  [[nodiscard]] int attribute_proto_size()
      const;
  private:
  int _internal_attribute_proto_size() const;

  public:
  void clear_attribute_proto() ;
  [[nodiscard]] ::onnx::AttributeProto* PROTOBUF_NONNULL mutable_attribute_proto(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
  mutable_attribute_proto();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& _internal_attribute_proto() const;
  ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL _internal_mutable_attribute_proto();
  public:
  [[nodiscard]] const ::onnx::AttributeProto& attribute_proto(int index) const;
  ::onnx::AttributeProto* PROTOBUF_NONNULL add_attribute_proto();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& attribute_proto()
      const;
  // repeated .onnx.ValueInfoProto value_info = 12;
  [[nodiscard]] int value_info_size()
      const;
  private:
  int _internal_value_info_size() const;

  public:
  void clear_value_info() ;
  [[nodiscard]] ::onnx::ValueInfoProto* PROTOBUF_NONNULL mutable_value_info(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
  mutable_value_info();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& _internal_value_info() const;
  ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL _internal_mutable_value_info();
  public:
  [[nodiscard]] const ::onnx::ValueInfoProto& value_info(int index) const;
  ::onnx::ValueInfoProto* PROTOBUF_NONNULL add_value_info();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& value_info()
      const;
  // repeated .onnx.StringStringEntryProto metadata_props = 14;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // optional string name = 1;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string doc_string = 8;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional string domain = 10;
  [[nodiscard]] bool has_domain()
      const;
  void clear_domain() ;
  [[nodiscard]] const ::std::string& domain() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_domain(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_domain();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
  void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_domain() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // optional string overload = 13;
  [[nodiscard]] bool has_overload()
      const;
  void clear_overload() ;
  [[nodiscard]] const ::std::string& overload() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_overload(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_overload();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_overload();
  void set_allocated_overload(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_overload() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_overload();

  public:
  // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<4, 12,
                                   5, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const FunctionProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> input_;
    ::google::protobuf::RepeatedPtrField<::std::string> output_;
    ::google::protobuf::RepeatedPtrField<::std::string> attribute_;
    ::google::protobuf::RepeatedPtrField< ::onnx::NodeProto > node_;
    ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
    ::google::protobuf::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
    ::google::protobuf::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::google::protobuf::internal::ArenaStringPtr domain_;
    ::google::protobuf::internal::ArenaStringPtr overload_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull FunctionProto_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ModelProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
 public:
  inline ModelProto() : ModelProto(nullptr) {}
  ~ModelProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ModelProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ModelProto));
  }
#endif

  template <typename = void>
  explicit constexpr ModelProto(::google::protobuf::internal::ConstantInitialized);

  inline ModelProto(const ModelProto& from) : ModelProto(nullptr, from) {}
  inline ModelProto(ModelProto&& from) noexcept
      : ModelProto(nullptr, ::std::move(from)) {}
  inline ModelProto& operator=(const ModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelProto& operator=(ModelProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ModelProto& default_instance() {
    return *reinterpret_cast<const ModelProto*>(
        &_ModelProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(ModelProto& a, ModelProto& b) { a.Swap(&b); }
  inline void Swap(ModelProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ModelProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ModelProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ModelProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ModelProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ModelProto& from) { ModelProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ModelProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "onnx.ModelProto"; }

  explicit ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ModelProto& from);
  ModelProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ModelProto&& from) noexcept
      : ModelProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kOpsetImportFieldNumber = 8,
    kMetadataPropsFieldNumber = 14,
    kFunctionsFieldNumber = 25,
    kConfigurationFieldNumber = 26,
    kProducerNameFieldNumber = 2,
    kProducerVersionFieldNumber = 3,
    kDomainFieldNumber = 4,
    kDocStringFieldNumber = 6,
    kGraphFieldNumber = 7,
    kIrVersionFieldNumber = 1,
    kModelVersionFieldNumber = 5,
    kTrainingInfoFieldNumber = 20,
  };
  // repeated .onnx.OperatorSetIdProto opset_import = 8;
  [[nodiscard]] int opset_import_size()
      const;
  private:
  int _internal_opset_import_size() const;

  public:
  void clear_opset_import() ;
  [[nodiscard]] ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL mutable_opset_import(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
  mutable_opset_import();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& _internal_opset_import() const;
  ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL _internal_mutable_opset_import();
  public:
  [[nodiscard]] const ::onnx::OperatorSetIdProto& opset_import(int index) const;
  ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL add_opset_import();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& opset_import()
      const;
  // repeated .onnx.StringStringEntryProto metadata_props = 14;
  [[nodiscard]] int metadata_props_size()
      const;
  private:
  int _internal_metadata_props_size() const;

  public:
  void clear_metadata_props() ;
  [[nodiscard]] ::onnx::StringStringEntryProto* PROTOBUF_NONNULL mutable_metadata_props(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
  mutable_metadata_props();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& _internal_metadata_props() const;
  ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL _internal_mutable_metadata_props();
  public:
  [[nodiscard]] const ::onnx::StringStringEntryProto& metadata_props(int index) const;
  ::onnx::StringStringEntryProto* PROTOBUF_NONNULL add_metadata_props();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& metadata_props()
      const;
  // repeated .onnx.FunctionProto functions = 25;
  [[nodiscard]] int functions_size()
      const;
  private:
  int _internal_functions_size() const;

  public:
  void clear_functions() ;
  [[nodiscard]] ::onnx::FunctionProto* PROTOBUF_NONNULL mutable_functions(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL
  mutable_functions();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& _internal_functions() const;
  ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL _internal_mutable_functions();
  public:
  [[nodiscard]] const ::onnx::FunctionProto& functions(int index) const;
  ::onnx::FunctionProto* PROTOBUF_NONNULL add_functions();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& functions()
      const;
  // repeated .onnx.DeviceConfigurationProto configuration = 26;
  [[nodiscard]] int configuration_size()
      const;
  private:
  int _internal_configuration_size() const;

  public:
  void clear_configuration() ;
  [[nodiscard]] ::onnx::DeviceConfigurationProto* PROTOBUF_NONNULL mutable_configuration(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>* PROTOBUF_NONNULL
  mutable_configuration();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>& _internal_configuration() const;
  ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>* PROTOBUF_NONNULL _internal_mutable_configuration();
  public:
  [[nodiscard]] const ::onnx::DeviceConfigurationProto& configuration(int index) const;
  ::onnx::DeviceConfigurationProto* PROTOBUF_NONNULL add_configuration();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>& configuration()
      const;
  // optional string producer_name = 2;
  [[nodiscard]] bool has_producer_name()
      const;
  void clear_producer_name() ;
  [[nodiscard]] const ::std::string& producer_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_producer_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_producer_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_producer_name();
  void set_allocated_producer_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_producer_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_producer_name();

  public:
  // optional string producer_version = 3;
  [[nodiscard]] bool has_producer_version()
      const;
  void clear_producer_version() ;
  [[nodiscard]] const ::std::string& producer_version() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_producer_version(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_producer_version();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_producer_version();
  void set_allocated_producer_version(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_producer_version() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_producer_version();

  public:
  // optional string domain = 4;
  [[nodiscard]] bool has_domain()
      const;
  void clear_domain() ;
  [[nodiscard]] const ::std::string& domain() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_domain(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_domain();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_domain();
  void set_allocated_domain(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_domain() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_domain();

  public:
  // optional string doc_string = 6;
  [[nodiscard]] bool has_doc_string()
      const;
  void clear_doc_string() ;
  [[nodiscard]] const ::std::string& doc_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_doc_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_doc_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_doc_string();
  void set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_doc_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_doc_string();

  public:
  // optional .onnx.GraphProto graph = 7;
  [[nodiscard]] bool has_graph()
      const;
  void clear_graph() ;
  [[nodiscard]] const ::onnx::GraphProto& graph() const;
  [[nodiscard]] ::onnx::GraphProto* PROTOBUF_NULLABLE release_graph();
  ::onnx::GraphProto* PROTOBUF_NONNULL mutable_graph();
  void set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value);
  ::onnx::GraphProto* PROTOBUF_NULLABLE unsafe_arena_release_graph();

  private:
  const ::onnx::GraphProto& _internal_graph() const;
  ::onnx::GraphProto* PROTOBUF_NONNULL _internal_mutable_graph();

  public:
  // optional int64 ir_version = 1;
  [[nodiscard]] bool has_ir_version()
      const;
  void clear_ir_version() ;
  [[nodiscard]] ::int64_t ir_version() const;
  void set_ir_version(::int64_t value);

  private:
  ::int64_t _internal_ir_version() const;
  void _internal_set_ir_version(::int64_t value);

  public:
  // optional int64 model_version = 5;
  [[nodiscard]] bool has_model_version()
      const;
  void clear_model_version() ;
  [[nodiscard]] ::int64_t model_version() const;
  void set_model_version(::int64_t value);

  private:
  ::int64_t _internal_model_version() const;
  void _internal_set_model_version(::int64_t value);

  public:
  // repeated .onnx.TrainingInfoProto training_info = 20;
  [[nodiscard]] int training_info_size()
      const;
  private:
  int _internal_training_info_size() const;

  public:
  void clear_training_info() ;
  [[nodiscard]] ::onnx::TrainingInfoProto* PROTOBUF_NONNULL mutable_training_info(int index);
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL
  mutable_training_info();

  private:
  const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& _internal_training_info() const;
  ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL _internal_mutable_training_info();
  public:
  [[nodiscard]] const ::onnx::TrainingInfoProto& training_info(int index) const;
  ::onnx::TrainingInfoProto* PROTOBUF_NONNULL add_training_info();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& training_info()
      const;
  // @@protoc_insertion_point(class_scope:onnx.ModelProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<4, 12,
                                   6, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ModelProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
    ::google::protobuf::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
    ::google::protobuf::RepeatedPtrField< ::onnx::FunctionProto > functions_;
    ::google::protobuf::RepeatedPtrField< ::onnx::DeviceConfigurationProto > configuration_;
    ::google::protobuf::internal::ArenaStringPtr producer_name_;
    ::google::protobuf::internal::ArenaStringPtr producer_version_;
    ::google::protobuf::internal::ArenaStringPtr domain_;
    ::google::protobuf::internal::ArenaStringPtr doc_string_;
    ::onnx::GraphProto* PROTOBUF_NULLABLE graph_;
    ::int64_t ir_version_;
    ::int64_t model_version_;
    ::google::protobuf::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_onnx_2fonnx_2dml_2eproto;
};

extern const ::google::protobuf::internal::ClassDataFull ModelProto_class_data_;

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




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


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

// AttributeProto

// optional string name = 1;
inline bool AttributeProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void AttributeProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
inline const ::std::string& AttributeProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AttributeProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
  return _s;
}
inline const ::std::string& AttributeProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void AttributeProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void AttributeProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
}

// optional string ref_attr_name = 21;
inline bool AttributeProto::has_ref_attr_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void AttributeProto::clear_ref_attr_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ref_attr_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
inline const ::std::string& AttributeProto::ref_attr_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
  return _internal_ref_attr_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AttributeProto::set_ref_attr_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.ref_attr_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_ref_attr_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_ref_attr_name();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
  return _s;
}
inline const ::std::string& AttributeProto::_internal_ref_attr_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ref_attr_name_.Get();
}
inline void AttributeProto::_internal_set_ref_attr_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ref_attr_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_ref_attr_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.ref_attr_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_ref_attr_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.ref_attr_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.ref_attr_name_.Set("", GetArena());
  }
  return released;
}
inline void AttributeProto::set_allocated_ref_attr_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  _impl_.ref_attr_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.ref_attr_name_.IsDefault()) {
    _impl_.ref_attr_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
}

// optional string doc_string = 13;
inline bool AttributeProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void AttributeProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline const ::std::string& AttributeProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AttributeProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
  return _s;
}
inline const ::std::string& AttributeProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void AttributeProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void AttributeProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
}

// optional .onnx.AttributeProto.AttributeType type = 20;
inline bool AttributeProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void AttributeProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00020000U);
}
inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
  return _internal_type();
}
inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
}
inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::onnx::AttributeProto_AttributeType>(_impl_.type_);
}
inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::onnx::AttributeProto_AttributeType_internal_data_));
                                          _impl_.type_ = value;
}

// optional float f = 2;
inline bool AttributeProto::has_f() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void AttributeProto::clear_f() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.f_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00010000U);
}
inline float AttributeProto::f() const {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
  return _internal_f();
}
inline void AttributeProto::set_f(float value) {
  _internal_set_f(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
}
inline float AttributeProto::_internal_f() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.f_;
}
inline void AttributeProto::_internal_set_f(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.f_ = value;
}

// optional int64 i = 3;
inline bool AttributeProto::has_i() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void AttributeProto::clear_i() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.i_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00008000U);
}
inline ::int64_t AttributeProto::i() const {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
  return _internal_i();
}
inline void AttributeProto::set_i(::int64_t value) {
  _internal_set_i(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
}
inline ::int64_t AttributeProto::_internal_i() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.i_;
}
inline void AttributeProto::_internal_set_i(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.i_ = value;
}

// optional bytes s = 4;
inline bool AttributeProto::has_s() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void AttributeProto::clear_s() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.s_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
inline const ::std::string& AttributeProto::s() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
  return _internal_s();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AttributeProto::set_s(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.s_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_s()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_s();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
  return _s;
}
inline const ::std::string& AttributeProto::_internal_s() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.s_.Get();
}
inline void AttributeProto::_internal_set_s(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.s_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::_internal_mutable_s() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.s_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AttributeProto::release_s() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.s_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.s_.Set("", GetArena());
  }
  return released;
}
inline void AttributeProto::set_allocated_s(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.s_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s_.IsDefault()) {
    _impl_.s_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
}

// optional .onnx.TensorProto t = 5;
inline bool AttributeProto::has_t() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.t_ != nullptr);
  return value;
}
inline void AttributeProto::clear_t() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.t_ != nullptr) _impl_.t_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000800U);
}
inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorProto* p = _impl_.t_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
}
inline const ::onnx::TensorProto& AttributeProto::t() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
  return _internal_t();
}
inline void AttributeProto::unsafe_arena_set_allocated_t(
    ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
  }
  _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE AttributeProto::release_t() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::onnx::TensorProto* released = _impl_.t_;
  _impl_.t_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_t() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::onnx::TensorProto* temp = _impl_.t_;
  _impl_.t_ = nullptr;
  return temp;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_t() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.t_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
    _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(p);
  }
  return _impl_.t_;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::mutable_t()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::onnx::TensorProto* _msg = _internal_mutable_t();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
  return _msg;
}
inline void AttributeProto::set_allocated_t(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.t_);
  }

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

  _impl_.t_ = reinterpret_cast<::onnx::TensorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
}

// optional .onnx.GraphProto g = 6;
inline bool AttributeProto::has_g() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.g_ != nullptr);
  return value;
}
inline void AttributeProto::clear_g() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.g_ != nullptr) _impl_.g_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00001000U);
}
inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::GraphProto* p = _impl_.g_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
}
inline const ::onnx::GraphProto& AttributeProto::g() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
  return _internal_g();
}
inline void AttributeProto::unsafe_arena_set_allocated_g(
    ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
  }
  _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE AttributeProto::release_g() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::GraphProto* released = _impl_.g_;
  _impl_.g_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_g() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::GraphProto* temp = _impl_.g_;
  _impl_.g_ = nullptr;
  return temp;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_g() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.g_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
    _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(p);
  }
  return _impl_.g_;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::mutable_g()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::GraphProto* _msg = _internal_mutable_g();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
  return _msg;
}
inline void AttributeProto::set_allocated_g(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.g_);
  }

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

  _impl_.g_ = reinterpret_cast<::onnx::GraphProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
}

// optional .onnx.SparseTensorProto sparse_tensor = 22;
inline bool AttributeProto::has_sparse_tensor() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_ != nullptr);
  return value;
}
inline void AttributeProto::clear_sparse_tensor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.sparse_tensor_ != nullptr) _impl_.sparse_tensor_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00004000U);
}
inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
}
inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
  return _internal_sparse_tensor();
}
inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(
    ::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
  }
  _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
}
inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE AttributeProto::release_sparse_tensor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_;
  _impl_.sparse_tensor_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::SparseTensorProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_sparse_tensor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_;
  _impl_.sparse_tensor_ = nullptr;
  return temp;
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_sparse_tensor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.sparse_tensor_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
    _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
  }
  return _impl_.sparse_tensor_;
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensor()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
  return _msg;
}
inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_);
  }

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

  _impl_.sparse_tensor_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
}

// optional .onnx.TypeProto tp = 14;
inline bool AttributeProto::has_tp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  PROTOBUF_ASSUME(!value || _impl_.tp_ != nullptr);
  return value;
}
inline void AttributeProto::clear_tp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.tp_ != nullptr) _impl_.tp_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00002000U);
}
inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TypeProto* p = _impl_.tp_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
}
inline const ::onnx::TypeProto& AttributeProto::tp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
  return _internal_tp();
}
inline void AttributeProto::unsafe_arena_set_allocated_tp(
    ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
  }
  _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE AttributeProto::release_tp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::onnx::TypeProto* released = _impl_.tp_;
  _impl_.tp_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE AttributeProto::unsafe_arena_release_tp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::onnx::TypeProto* temp = _impl_.tp_;
  _impl_.tp_ = nullptr;
  return temp;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::_internal_mutable_tp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.tp_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
    _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(p);
  }
  return _impl_.tp_;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::mutable_tp()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::onnx::TypeProto* _msg = _internal_mutable_tp();
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
  return _msg;
}
inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tp_);
  }

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

  _impl_.tp_ = reinterpret_cast<::onnx::TypeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
}

// repeated float floats = 7;
inline int AttributeProto::_internal_floats_size() const {
  return _internal_floats().size();
}
inline int AttributeProto::floats_size() const {
  return _internal_floats_size();
}
inline void AttributeProto::clear_floats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.floats_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline float AttributeProto::floats(int index) const {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
  return _internal_floats().Get(index);
}
inline void AttributeProto::set_floats(int index, float value) {
  _internal_mutable_floats()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
}
inline void AttributeProto::add_floats(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_floats()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
}
inline const ::google::protobuf::RepeatedField<float>& AttributeProto::floats() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
  return _internal_floats();
}
inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL AttributeProto::mutable_floats()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_floats();
}
inline const ::google::protobuf::RepeatedField<float>&
AttributeProto::_internal_floats() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.floats_;
}
inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_floats() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.floats_;
}

// repeated int64 ints = 8;
inline int AttributeProto::_internal_ints_size() const {
  return _internal_ints().size();
}
inline int AttributeProto::ints_size() const {
  return _internal_ints_size();
}
inline void AttributeProto::clear_ints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ints_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int64_t AttributeProto::ints(int index) const {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
  return _internal_ints().Get(index);
}
inline void AttributeProto::set_ints(int index, ::int64_t value) {
  _internal_mutable_ints()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
}
inline void AttributeProto::add_ints(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_ints()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& AttributeProto::ints() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
  return _internal_ints();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL AttributeProto::mutable_ints()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_ints();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
AttributeProto::_internal_ints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ints_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_ints() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.ints_;
}

// repeated bytes strings = 9;
inline int AttributeProto::_internal_strings_size() const {
  return _internal_strings().size();
}
inline int AttributeProto::strings_size() const {
  return _internal_strings_size();
}
inline void AttributeProto::clear_strings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.strings_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::add_strings()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_strings()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
  return _s;
}
inline const ::std::string& AttributeProto::strings(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
  return _internal_strings().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL AttributeProto::mutable_strings(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
  return _internal_mutable_strings()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void AttributeProto::set_strings(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_strings()->Mutable(index), ::std::forward<Arg_>(value),
                        args... , ::google::protobuf::internal::BytesTag{});
  // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
}
template <typename Arg_, typename... Args_>
inline void AttributeProto::add_strings(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_strings(), ::std::forward<Arg_>(value),
      args... , ::google::protobuf::internal::BytesTag{});
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& AttributeProto::strings()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
  return _internal_strings();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
AttributeProto::mutable_strings() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_strings();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
AttributeProto::_internal_strings() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.strings_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_strings() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.strings_;
}

// repeated .onnx.TensorProto tensors = 10;
inline int AttributeProto::_internal_tensors_size() const {
  return _internal_tensors().size();
}
inline int AttributeProto::tensors_size() const {
  return _internal_tensors_size();
}
inline void AttributeProto::clear_tensors() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensors_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::mutable_tensors(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
  return _internal_mutable_tensors()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL AttributeProto::mutable_tensors()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_tensors();
}
inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
  return _internal_tensors().Get(index);
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL AttributeProto::add_tensors()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TensorProto* _add =
      _internal_mutable_tensors()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& AttributeProto::tensors() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
  return _internal_tensors();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
AttributeProto::_internal_tensors() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tensors_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_tensors() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.tensors_;
}

// repeated .onnx.GraphProto graphs = 11;
inline int AttributeProto::_internal_graphs_size() const {
  return _internal_graphs().size();
}
inline int AttributeProto::graphs_size() const {
  return _internal_graphs_size();
}
inline void AttributeProto::clear_graphs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.graphs_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::mutable_graphs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
  return _internal_mutable_graphs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL AttributeProto::mutable_graphs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_graphs();
}
inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
  return _internal_graphs().Get(index);
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL AttributeProto::add_graphs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::GraphProto* _add =
      _internal_mutable_graphs()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>& AttributeProto::graphs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
  return _internal_graphs();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>&
AttributeProto::_internal_graphs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.graphs_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::GraphProto>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_graphs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.graphs_;
}

// repeated .onnx.SparseTensorProto sparse_tensors = 23;
inline int AttributeProto::_internal_sparse_tensors_size() const {
  return _internal_sparse_tensors().size();
}
inline int AttributeProto::sparse_tensors_size() const {
  return _internal_sparse_tensors_size();
}
inline void AttributeProto::clear_sparse_tensors() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sparse_tensors_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensors(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
  return _internal_mutable_sparse_tensors()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL AttributeProto::mutable_sparse_tensors()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_sparse_tensors();
}
inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
  return _internal_sparse_tensors().Get(index);
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL AttributeProto::add_sparse_tensors()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::SparseTensorProto* _add =
      _internal_mutable_sparse_tensors()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& AttributeProto::sparse_tensors() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
  return _internal_sparse_tensors();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
AttributeProto::_internal_sparse_tensors() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sparse_tensors_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_sparse_tensors() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.sparse_tensors_;
}

// repeated .onnx.TypeProto type_protos = 15;
inline int AttributeProto::_internal_type_protos_size() const {
  return _internal_type_protos().size();
}
inline int AttributeProto::type_protos_size() const {
  return _internal_type_protos_size();
}
inline void AttributeProto::clear_type_protos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_protos_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000020U);
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::mutable_type_protos(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
  return _internal_mutable_type_protos()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL AttributeProto::mutable_type_protos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_type_protos();
}
inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
  return _internal_type_protos().Get(index);
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL AttributeProto::add_type_protos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TypeProto* _add =
      _internal_mutable_type_protos()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>& AttributeProto::type_protos() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
  return _internal_type_protos();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>&
AttributeProto::_internal_type_protos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.type_protos_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TypeProto>* PROTOBUF_NONNULL
AttributeProto::_internal_mutable_type_protos() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.type_protos_;
}

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

// ValueInfoProto

// optional string name = 1;
inline bool ValueInfoProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ValueInfoProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& ValueInfoProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
}
inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
  return _s;
}
inline const ::std::string& ValueInfoProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void ValueInfoProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ValueInfoProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void ValueInfoProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
}

// optional .onnx.TypeProto type = 2;
inline bool ValueInfoProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.type_ != nullptr);
  return value;
}
inline void ValueInfoProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.type_ != nullptr) _impl_.type_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TypeProto* p = _impl_.type_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
}
inline const ::onnx::TypeProto& ValueInfoProto::type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
  return _internal_type();
}
inline void ValueInfoProto::unsafe_arena_set_allocated_type(
    ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
  }
  _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE ValueInfoProto::release_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::TypeProto* released = _impl_.type_;
  _impl_.type_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE ValueInfoProto::unsafe_arena_release_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::TypeProto* temp = _impl_.type_;
  _impl_.type_ = nullptr;
  return temp;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.type_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
    _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(p);
  }
  return _impl_.type_;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL ValueInfoProto::mutable_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::TypeProto* _msg = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
  return _msg;
}
inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_);
  }

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

  _impl_.type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
}

// optional string doc_string = 3;
inline bool ValueInfoProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void ValueInfoProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::std::string& ValueInfoProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
  return _s;
}
inline const ::std::string& ValueInfoProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void ValueInfoProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ValueInfoProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ValueInfoProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void ValueInfoProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
}

// repeated .onnx.StringStringEntryProto metadata_props = 4;
inline int ValueInfoProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int ValueInfoProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void ValueInfoProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ValueInfoProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL ValueInfoProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ValueInfoProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ValueInfoProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
ValueInfoProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
ValueInfoProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

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

// NodeProto

// repeated string input = 1;
inline int NodeProto::_internal_input_size() const {
  return _internal_input().size();
}
inline int NodeProto::input_size() const {
  return _internal_input_size();
}
inline void NodeProto::clear_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::add_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_input()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
  return _s;
}
inline const ::std::string& NodeProto::input(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
  return _internal_input().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_input(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
  return _internal_mutable_input()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NodeProto::set_input(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_input()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
}
template <typename Arg_, typename... Args_>
inline void NodeProto::add_input(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_input(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NodeProto::input()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
  return _internal_input();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NodeProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_input();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NodeProto::_internal_input() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NodeProto::_internal_mutable_input() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.input_;
}

// repeated string output = 2;
inline int NodeProto::_internal_output_size() const {
  return _internal_output().size();
}
inline int NodeProto::output_size() const {
  return _internal_output_size();
}
inline void NodeProto::clear_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::add_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_output()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
  return _s;
}
inline const ::std::string& NodeProto::output(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
  return _internal_output().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_output(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
  return _internal_mutable_output()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void NodeProto::set_output(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_output()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
}
template <typename Arg_, typename... Args_>
inline void NodeProto::add_output(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_output(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& NodeProto::output()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
  return _internal_output();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NodeProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_output();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
NodeProto::_internal_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
NodeProto::_internal_mutable_output() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.output_;
}

// optional string name = 3;
inline bool NodeProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void NodeProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000020U);
}
inline const ::std::string& NodeProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
  return _s;
}
inline const ::std::string& NodeProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void NodeProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void NodeProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
}

// optional string op_type = 4;
inline bool NodeProto::has_op_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void NodeProto::clear_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000040U);
}
inline const ::std::string& NodeProto::op_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
  return _internal_op_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeProto::set_op_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_op_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_op_type();
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
  return _s;
}
inline const ::std::string& NodeProto::_internal_op_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.op_type_.Get();
}
inline void NodeProto::_internal_set_op_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.op_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.op_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_op_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.op_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.op_type_.Set("", GetArena());
  }
  return released;
}
inline void NodeProto::set_allocated_op_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.op_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.op_type_.IsDefault()) {
    _impl_.op_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type)
}

// optional string domain = 7;
inline bool NodeProto::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void NodeProto::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
inline const ::std::string& NodeProto::domain() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
  return _internal_domain();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeProto::set_domain(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
  return _s;
}
inline const ::std::string& NodeProto::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.domain_.Get();
}
inline void NodeProto::_internal_set_domain(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.domain_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.domain_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.domain_.Set("", GetArena());
  }
  return released;
}
inline void NodeProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.domain_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
    _impl_.domain_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
}

// optional string overload = 8;
inline bool NodeProto::has_overload() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void NodeProto::clear_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.overload_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline const ::std::string& NodeProto::overload() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.overload)
  return _internal_overload();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeProto::set_overload(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeProto.overload)
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_overload()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_overload();
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload)
  return _s;
}
inline const ::std::string& NodeProto::_internal_overload() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.overload_.Get();
}
inline void NodeProto::_internal_set_overload(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.overload_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.overload_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeProto.overload)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.overload_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.overload_.Set("", GetArena());
  }
  return released;
}
inline void NodeProto::set_allocated_overload(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.overload_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.overload_.IsDefault()) {
    _impl_.overload_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload)
}

// repeated .onnx.AttributeProto attribute = 5;
inline int NodeProto::_internal_attribute_size() const {
  return _internal_attribute().size();
}
inline int NodeProto::attribute_size() const {
  return _internal_attribute_size();
}
inline void NodeProto::clear_attribute() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.attribute_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::onnx::AttributeProto* PROTOBUF_NONNULL NodeProto::mutable_attribute(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
  return _internal_mutable_attribute()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL NodeProto::mutable_attribute()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_attribute();
}
inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
  return _internal_attribute().Get(index);
}
inline ::onnx::AttributeProto* PROTOBUF_NONNULL NodeProto::add_attribute()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::AttributeProto* _add =
      _internal_mutable_attribute()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& NodeProto::attribute() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
  return _internal_attribute();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
NodeProto::_internal_attribute() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.attribute_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
NodeProto::_internal_mutable_attribute() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.attribute_;
}

// optional string doc_string = 6;
inline bool NodeProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void NodeProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
inline const ::std::string& NodeProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
  return _s;
}
inline const ::std::string& NodeProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void NodeProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void NodeProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
}

// repeated .onnx.StringStringEntryProto metadata_props = 9;
inline int NodeProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int NodeProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void NodeProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL NodeProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL NodeProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL NodeProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& NodeProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
NodeProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
NodeProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

// repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
inline int NodeProto::_internal_device_configurations_size() const {
  return _internal_device_configurations().size();
}
inline int NodeProto::device_configurations_size() const {
  return _internal_device_configurations_size();
}
inline void NodeProto::clear_device_configurations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_configurations_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::onnx::NodeDeviceConfigurationProto* PROTOBUF_NONNULL NodeProto::mutable_device_configurations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.device_configurations)
  return _internal_mutable_device_configurations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>* PROTOBUF_NONNULL NodeProto::mutable_device_configurations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.device_configurations)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_device_configurations();
}
inline const ::onnx::NodeDeviceConfigurationProto& NodeProto::device_configurations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeProto.device_configurations)
  return _internal_device_configurations().Get(index);
}
inline ::onnx::NodeDeviceConfigurationProto* PROTOBUF_NONNULL NodeProto::add_device_configurations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::NodeDeviceConfigurationProto* _add =
      _internal_mutable_device_configurations()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_add:onnx.NodeProto.device_configurations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>& NodeProto::device_configurations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeProto.device_configurations)
  return _internal_device_configurations();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>&
NodeProto::_internal_device_configurations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_configurations_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeDeviceConfigurationProto>* PROTOBUF_NONNULL
NodeProto::_internal_mutable_device_configurations() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.device_configurations_;
}

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

// IntIntListEntryProto

// optional int64 key = 1;
inline bool IntIntListEntryProto::has_key() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void IntIntListEntryProto::clear_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int64_t IntIntListEntryProto::key() const {
  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.key)
  return _internal_key();
}
inline void IntIntListEntryProto::set_key(::int64_t value) {
  _internal_set_key(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.key)
}
inline ::int64_t IntIntListEntryProto::_internal_key() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.key_;
}
inline void IntIntListEntryProto::_internal_set_key(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_ = value;
}

// repeated int64 value = 2;
inline int IntIntListEntryProto::_internal_value_size() const {
  return _internal_value().size();
}
inline int IntIntListEntryProto::value_size() const {
  return _internal_value_size();
}
inline void IntIntListEntryProto::clear_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t IntIntListEntryProto::value(int index) const {
  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.value)
  return _internal_value().Get(index);
}
inline void IntIntListEntryProto::set_value(int index, ::int64_t value) {
  _internal_mutable_value()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.value)
}
inline void IntIntListEntryProto::add_value(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_value()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.IntIntListEntryProto.value)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& IntIntListEntryProto::value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.IntIntListEntryProto.value)
  return _internal_value();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL IntIntListEntryProto::mutable_value()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.IntIntListEntryProto.value)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_value();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
IntIntListEntryProto::_internal_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
IntIntListEntryProto::_internal_mutable_value() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.value_;
}

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

// NodeDeviceConfigurationProto

// optional string configuration_id = 1;
inline bool NodeDeviceConfigurationProto::has_configuration_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void NodeDeviceConfigurationProto::clear_configuration_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.configuration_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& NodeDeviceConfigurationProto::configuration_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.configuration_id)
  return _internal_configuration_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NodeDeviceConfigurationProto::set_configuration_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.configuration_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.configuration_id)
}
inline ::std::string* PROTOBUF_NONNULL NodeDeviceConfigurationProto::mutable_configuration_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_configuration_id();
  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.configuration_id)
  return _s;
}
inline const ::std::string& NodeDeviceConfigurationProto::_internal_configuration_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.configuration_id_.Get();
}
inline void NodeDeviceConfigurationProto::_internal_set_configuration_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.configuration_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NodeDeviceConfigurationProto::_internal_mutable_configuration_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.configuration_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NodeDeviceConfigurationProto::release_configuration_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.NodeDeviceConfigurationProto.configuration_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.configuration_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.configuration_id_.Set("", GetArena());
  }
  return released;
}
inline void NodeDeviceConfigurationProto::set_allocated_configuration_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.configuration_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.configuration_id_.IsDefault()) {
    _impl_.configuration_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.NodeDeviceConfigurationProto.configuration_id)
}

// repeated .onnx.ShardingSpecProto sharding_spec = 2;
inline int NodeDeviceConfigurationProto::_internal_sharding_spec_size() const {
  return _internal_sharding_spec().size();
}
inline int NodeDeviceConfigurationProto::sharding_spec_size() const {
  return _internal_sharding_spec_size();
}
inline void NodeDeviceConfigurationProto::clear_sharding_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sharding_spec_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::ShardingSpecProto* PROTOBUF_NONNULL NodeDeviceConfigurationProto::mutable_sharding_spec(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.sharding_spec)
  return _internal_mutable_sharding_spec()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>* PROTOBUF_NONNULL NodeDeviceConfigurationProto::mutable_sharding_spec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_sharding_spec();
}
inline const ::onnx::ShardingSpecProto& NodeDeviceConfigurationProto::sharding_spec(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.sharding_spec)
  return _internal_sharding_spec().Get(index);
}
inline ::onnx::ShardingSpecProto* PROTOBUF_NONNULL NodeDeviceConfigurationProto::add_sharding_spec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ShardingSpecProto* _add =
      _internal_mutable_sharding_spec()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.NodeDeviceConfigurationProto.sharding_spec)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>& NodeDeviceConfigurationProto::sharding_spec() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
  return _internal_sharding_spec();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>&
NodeDeviceConfigurationProto::_internal_sharding_spec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sharding_spec_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ShardingSpecProto>* PROTOBUF_NONNULL
NodeDeviceConfigurationProto::_internal_mutable_sharding_spec() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.sharding_spec_;
}

// optional int32 pipeline_stage = 3;
inline bool NodeDeviceConfigurationProto::has_pipeline_stage() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void NodeDeviceConfigurationProto::clear_pipeline_stage() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pipeline_stage_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::int32_t NodeDeviceConfigurationProto::pipeline_stage() const {
  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.pipeline_stage)
  return _internal_pipeline_stage();
}
inline void NodeDeviceConfigurationProto::set_pipeline_stage(::int32_t value) {
  _internal_set_pipeline_stage(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.pipeline_stage)
}
inline ::int32_t NodeDeviceConfigurationProto::_internal_pipeline_stage() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pipeline_stage_;
}
inline void NodeDeviceConfigurationProto::_internal_set_pipeline_stage(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pipeline_stage_ = value;
}

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

// ShardingSpecProto

// optional string tensor_name = 1;
inline bool ShardingSpecProto::has_tensor_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void ShardingSpecProto::clear_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::std::string& ShardingSpecProto::tensor_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.tensor_name)
  return _internal_tensor_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ShardingSpecProto::set_tensor_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.tensor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.tensor_name)
}
inline ::std::string* PROTOBUF_NONNULL ShardingSpecProto::mutable_tensor_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_tensor_name();
  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.tensor_name)
  return _s;
}
inline const ::std::string& ShardingSpecProto::_internal_tensor_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tensor_name_.Get();
}
inline void ShardingSpecProto::_internal_set_tensor_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ShardingSpecProto::_internal_mutable_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tensor_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ShardingSpecProto::release_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ShardingSpecProto.tensor_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.tensor_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.tensor_name_.Set("", GetArena());
  }
  return released;
}
inline void ShardingSpecProto::set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.tensor_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tensor_name_.IsDefault()) {
    _impl_.tensor_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ShardingSpecProto.tensor_name)
}

// repeated int64 device = 2;
inline int ShardingSpecProto::_internal_device_size() const {
  return _internal_device().size();
}
inline int ShardingSpecProto::device_size() const {
  return _internal_device_size();
}
inline void ShardingSpecProto::clear_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t ShardingSpecProto::device(int index) const {
  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.device)
  return _internal_device().Get(index);
}
inline void ShardingSpecProto::set_device(int index, ::int64_t value) {
  _internal_mutable_device()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.device)
}
inline void ShardingSpecProto::add_device(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_device()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.device)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& ShardingSpecProto::device() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.device)
  return _internal_device();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL ShardingSpecProto::mutable_device()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.device)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_device();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
ShardingSpecProto::_internal_device() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
ShardingSpecProto::_internal_mutable_device() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.device_;
}

// repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
inline int ShardingSpecProto::_internal_index_to_device_group_map_size() const {
  return _internal_index_to_device_group_map().size();
}
inline int ShardingSpecProto::index_to_device_group_map_size() const {
  return _internal_index_to_device_group_map_size();
}
inline void ShardingSpecProto::clear_index_to_device_group_map() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.index_to_device_group_map_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::onnx::IntIntListEntryProto* PROTOBUF_NONNULL ShardingSpecProto::mutable_index_to_device_group_map(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.index_to_device_group_map)
  return _internal_mutable_index_to_device_group_map()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>* PROTOBUF_NONNULL ShardingSpecProto::mutable_index_to_device_group_map()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.index_to_device_group_map)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_index_to_device_group_map();
}
inline const ::onnx::IntIntListEntryProto& ShardingSpecProto::index_to_device_group_map(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.index_to_device_group_map)
  return _internal_index_to_device_group_map().Get(index);
}
inline ::onnx::IntIntListEntryProto* PROTOBUF_NONNULL ShardingSpecProto::add_index_to_device_group_map()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::IntIntListEntryProto* _add =
      _internal_mutable_index_to_device_group_map()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.index_to_device_group_map)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>& ShardingSpecProto::index_to_device_group_map() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.index_to_device_group_map)
  return _internal_index_to_device_group_map();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>&
ShardingSpecProto::_internal_index_to_device_group_map() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.index_to_device_group_map_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::IntIntListEntryProto>* PROTOBUF_NONNULL
ShardingSpecProto::_internal_mutable_index_to_device_group_map() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.index_to_device_group_map_;
}

// repeated .onnx.ShardedDimProto sharded_dim = 4;
inline int ShardingSpecProto::_internal_sharded_dim_size() const {
  return _internal_sharded_dim().size();
}
inline int ShardingSpecProto::sharded_dim_size() const {
  return _internal_sharded_dim_size();
}
inline void ShardingSpecProto::clear_sharded_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sharded_dim_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::onnx::ShardedDimProto* PROTOBUF_NONNULL ShardingSpecProto::mutable_sharded_dim(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.sharded_dim)
  return _internal_mutable_sharded_dim()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>* PROTOBUF_NONNULL ShardingSpecProto::mutable_sharded_dim()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.sharded_dim)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_sharded_dim();
}
inline const ::onnx::ShardedDimProto& ShardingSpecProto::sharded_dim(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.sharded_dim)
  return _internal_sharded_dim().Get(index);
}
inline ::onnx::ShardedDimProto* PROTOBUF_NONNULL ShardingSpecProto::add_sharded_dim()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ShardedDimProto* _add =
      _internal_mutable_sharded_dim()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.sharded_dim)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>& ShardingSpecProto::sharded_dim() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.sharded_dim)
  return _internal_sharded_dim();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>&
ShardingSpecProto::_internal_sharded_dim() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sharded_dim_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ShardedDimProto>* PROTOBUF_NONNULL
ShardingSpecProto::_internal_mutable_sharded_dim() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.sharded_dim_;
}

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

// ShardedDimProto

// optional int64 axis = 1;
inline bool ShardedDimProto::has_axis() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ShardedDimProto::clear_axis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.axis_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int64_t ShardedDimProto::axis() const {
  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.axis)
  return _internal_axis();
}
inline void ShardedDimProto::set_axis(::int64_t value) {
  _internal_set_axis(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.ShardedDimProto.axis)
}
inline ::int64_t ShardedDimProto::_internal_axis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.axis_;
}
inline void ShardedDimProto::_internal_set_axis(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.axis_ = value;
}

// repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
inline int ShardedDimProto::_internal_simple_sharding_size() const {
  return _internal_simple_sharding().size();
}
inline int ShardedDimProto::simple_sharding_size() const {
  return _internal_simple_sharding_size();
}
inline void ShardedDimProto::clear_simple_sharding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.simple_sharding_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::SimpleShardedDimProto* PROTOBUF_NONNULL ShardedDimProto::mutable_simple_sharding(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ShardedDimProto.simple_sharding)
  return _internal_mutable_simple_sharding()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>* PROTOBUF_NONNULL ShardedDimProto::mutable_simple_sharding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ShardedDimProto.simple_sharding)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_simple_sharding();
}
inline const ::onnx::SimpleShardedDimProto& ShardedDimProto::simple_sharding(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.simple_sharding)
  return _internal_simple_sharding().Get(index);
}
inline ::onnx::SimpleShardedDimProto* PROTOBUF_NONNULL ShardedDimProto::add_simple_sharding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::SimpleShardedDimProto* _add =
      _internal_mutable_simple_sharding()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.ShardedDimProto.simple_sharding)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>& ShardedDimProto::simple_sharding() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ShardedDimProto.simple_sharding)
  return _internal_simple_sharding();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>&
ShardedDimProto::_internal_simple_sharding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.simple_sharding_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SimpleShardedDimProto>* PROTOBUF_NONNULL
ShardedDimProto::_internal_mutable_simple_sharding() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.simple_sharding_;
}

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

// SimpleShardedDimProto

// int64 dim_value = 1;
inline bool SimpleShardedDimProto::has_dim_value() const {
  return dim_case() == kDimValue;
}
inline void SimpleShardedDimProto::set_has_dim_value() {
  _impl_._oneof_case_[0] = kDimValue;
}
inline void SimpleShardedDimProto::clear_dim_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dim_case() == kDimValue) {
    _impl_.dim_.dim_value_ = ::int64_t{0};
    clear_has_dim();
  }
}
inline ::int64_t SimpleShardedDimProto::dim_value() const {
  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_value)
  return _internal_dim_value();
}
inline void SimpleShardedDimProto::set_dim_value(::int64_t value) {
  if (dim_case() != kDimValue) {
    clear_dim();
    set_has_dim_value();
  }
  _impl_.dim_.dim_value_ = value;
  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_value)
}
inline ::int64_t SimpleShardedDimProto::_internal_dim_value() const {
  if (dim_case() == kDimValue) {
    return _impl_.dim_.dim_value_;
  }
  return ::int64_t{0};
}

// string dim_param = 2;
inline bool SimpleShardedDimProto::has_dim_param() const {
  return dim_case() == kDimParam;
}
inline void SimpleShardedDimProto::set_has_dim_param() {
  _impl_._oneof_case_[0] = kDimParam;
}
inline void SimpleShardedDimProto::clear_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dim_case() == kDimParam) {
    _impl_.dim_.dim_param_.Destroy();
    clear_has_dim();
  }
}
inline const ::std::string& SimpleShardedDimProto::dim_param() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_param)
  return _internal_dim_param();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SimpleShardedDimProto::set_dim_param(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (dim_case() != kDimParam) {
    clear_dim();

    set_has_dim_param();
    _impl_.dim_.dim_param_.InitDefault();
  }
  _impl_.dim_.dim_param_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_param)
}
inline ::std::string* PROTOBUF_NONNULL SimpleShardedDimProto::mutable_dim_param()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (dim_case() != kDimParam) {
    clear_dim();

    set_has_dim_param();
    _impl_.dim_.dim_param_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_dim_param();
  // @@protoc_insertion_point(field_mutable:onnx.SimpleShardedDimProto.dim_param)
  return _s;
}
inline const ::std::string& SimpleShardedDimProto::_internal_dim_param() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (dim_case() != kDimParam) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.dim_.dim_param_.Get();
}
inline void SimpleShardedDimProto::_internal_set_dim_param(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dim_.dim_param_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SimpleShardedDimProto::_internal_mutable_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.dim_.dim_param_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SimpleShardedDimProto::release_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.SimpleShardedDimProto.dim_param)
  if (dim_case() != kDimParam) {
    return nullptr;
  }
  clear_has_dim();
  return _impl_.dim_.dim_param_.Release();
}
inline void SimpleShardedDimProto::set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_dim()) {
    clear_dim();
  }
  if (value != nullptr) {
    set_has_dim_param();
    _impl_.dim_.dim_param_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.SimpleShardedDimProto.dim_param)
}

// optional int64 num_shards = 3;
inline bool SimpleShardedDimProto::has_num_shards() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void SimpleShardedDimProto::clear_num_shards() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_shards_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t SimpleShardedDimProto::num_shards() const {
  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.num_shards)
  return _internal_num_shards();
}
inline void SimpleShardedDimProto::set_num_shards(::int64_t value) {
  _internal_set_num_shards(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.num_shards)
}
inline ::int64_t SimpleShardedDimProto::_internal_num_shards() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_shards_;
}
inline void SimpleShardedDimProto::_internal_set_num_shards(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_shards_ = value;
}

inline bool SimpleShardedDimProto::has_dim() const {
  return dim_case() != DIM_NOT_SET;
}
inline void SimpleShardedDimProto::clear_has_dim() {
  _impl_._oneof_case_[0] = DIM_NOT_SET;
}
inline SimpleShardedDimProto::DimCase SimpleShardedDimProto::dim_case() const {
  return SimpleShardedDimProto::DimCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// TrainingInfoProto

// optional .onnx.GraphProto initialization = 1;
inline bool TrainingInfoProto::has_initialization() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.initialization_ != nullptr);
  return value;
}
inline void TrainingInfoProto::clear_initialization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.initialization_ != nullptr) _impl_.initialization_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::GraphProto* p = _impl_.initialization_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
}
inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
  return _internal_initialization();
}
inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(
    ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
  }
  _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::release_initialization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::GraphProto* released = _impl_.initialization_;
  _impl_.initialization_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::unsafe_arena_release_initialization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::GraphProto* temp = _impl_.initialization_;
  _impl_.initialization_ = nullptr;
  return temp;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::_internal_mutable_initialization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.initialization_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
    _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(p);
  }
  return _impl_.initialization_;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::GraphProto* _msg = _internal_mutable_initialization();
  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
  return _msg;
}
inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.initialization_);
  }

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

  _impl_.initialization_ = reinterpret_cast<::onnx::GraphProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
}

// optional .onnx.GraphProto algorithm = 2;
inline bool TrainingInfoProto::has_algorithm() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.algorithm_ != nullptr);
  return value;
}
inline void TrainingInfoProto::clear_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.algorithm_ != nullptr) _impl_.algorithm_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::GraphProto* p = _impl_.algorithm_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
}
inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
  return _internal_algorithm();
}
inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(
    ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
  }
  _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::release_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::GraphProto* released = _impl_.algorithm_;
  _impl_.algorithm_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE TrainingInfoProto::unsafe_arena_release_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::GraphProto* temp = _impl_.algorithm_;
  _impl_.algorithm_ = nullptr;
  return temp;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::_internal_mutable_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.algorithm_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
    _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(p);
  }
  return _impl_.algorithm_;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_algorithm()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::onnx::GraphProto* _msg = _internal_mutable_algorithm();
  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
  return _msg;
}
inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.algorithm_);
  }

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

  _impl_.algorithm_ = reinterpret_cast<::onnx::GraphProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
}

// repeated .onnx.StringStringEntryProto initialization_binding = 3;
inline int TrainingInfoProto::_internal_initialization_binding_size() const {
  return _internal_initialization_binding().size();
}
inline int TrainingInfoProto::initialization_binding_size() const {
  return _internal_initialization_binding_size();
}
inline void TrainingInfoProto::clear_initialization_binding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initialization_binding_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization_binding(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
  return _internal_mutable_initialization_binding()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TrainingInfoProto::mutable_initialization_binding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_initialization_binding();
}
inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
  return _internal_initialization_binding().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::add_initialization_binding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_initialization_binding()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::initialization_binding() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
  return _internal_initialization_binding();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
TrainingInfoProto::_internal_initialization_binding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.initialization_binding_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
TrainingInfoProto::_internal_mutable_initialization_binding() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.initialization_binding_;
}

// repeated .onnx.StringStringEntryProto update_binding = 4;
inline int TrainingInfoProto::_internal_update_binding_size() const {
  return _internal_update_binding().size();
}
inline int TrainingInfoProto::update_binding_size() const {
  return _internal_update_binding_size();
}
inline void TrainingInfoProto::clear_update_binding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.update_binding_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::mutable_update_binding(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
  return _internal_mutable_update_binding()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TrainingInfoProto::mutable_update_binding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_update_binding();
}
inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
  return _internal_update_binding().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TrainingInfoProto::add_update_binding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_update_binding()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TrainingInfoProto::update_binding() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
  return _internal_update_binding();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
TrainingInfoProto::_internal_update_binding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.update_binding_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
TrainingInfoProto::_internal_mutable_update_binding() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.update_binding_;
}

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

// ModelProto

// optional int64 ir_version = 1;
inline bool ModelProto::has_ir_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void ModelProto::clear_ir_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ir_version_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline ::int64_t ModelProto::ir_version() const {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
  return _internal_ir_version();
}
inline void ModelProto::set_ir_version(::int64_t value) {
  _internal_set_ir_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
}
inline ::int64_t ModelProto::_internal_ir_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ir_version_;
}
inline void ModelProto::_internal_set_ir_version(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ir_version_ = value;
}

// repeated .onnx.OperatorSetIdProto opset_import = 8;
inline int ModelProto::_internal_opset_import_size() const {
  return _internal_opset_import().size();
}
inline int ModelProto::opset_import_size() const {
  return _internal_opset_import_size();
}
inline void ModelProto::clear_opset_import() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.opset_import_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL ModelProto::mutable_opset_import(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
  return _internal_mutable_opset_import()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL ModelProto::mutable_opset_import()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_opset_import();
}
inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
  return _internal_opset_import().Get(index);
}
inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL ModelProto::add_opset_import()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::OperatorSetIdProto* _add =
      _internal_mutable_opset_import()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& ModelProto::opset_import() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
  return _internal_opset_import();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
ModelProto::_internal_opset_import() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.opset_import_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_opset_import() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.opset_import_;
}

// optional string producer_name = 2;
inline bool ModelProto::has_producer_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void ModelProto::clear_producer_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.producer_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline const ::std::string& ModelProto::producer_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
  return _internal_producer_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.producer_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_producer_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_producer_name();
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
  return _s;
}
inline const ::std::string& ModelProto::_internal_producer_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.producer_name_.Get();
}
inline void ModelProto::_internal_set_producer_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.producer_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_producer_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.producer_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_producer_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.producer_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.producer_name_.Set("", GetArena());
  }
  return released;
}
inline void ModelProto::set_allocated_producer_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.producer_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.producer_name_.IsDefault()) {
    _impl_.producer_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
}

// optional string producer_version = 3;
inline bool ModelProto::has_producer_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void ModelProto::clear_producer_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.producer_version_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000020U);
}
inline const ::std::string& ModelProto::producer_version() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
  return _internal_producer_version();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_version(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.producer_version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_producer_version()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_producer_version();
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
  return _s;
}
inline const ::std::string& ModelProto::_internal_producer_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.producer_version_.Get();
}
inline void ModelProto::_internal_set_producer_version(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.producer_version_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_producer_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.producer_version_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_producer_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.producer_version_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.producer_version_.Set("", GetArena());
  }
  return released;
}
inline void ModelProto::set_allocated_producer_version(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.producer_version_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.producer_version_.IsDefault()) {
    _impl_.producer_version_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
}

// optional string domain = 4;
inline bool ModelProto::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void ModelProto::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000040U);
}
inline const ::std::string& ModelProto::domain() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
  return _internal_domain();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ModelProto::set_domain(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
  return _s;
}
inline const ::std::string& ModelProto::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.domain_.Get();
}
inline void ModelProto::_internal_set_domain(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.domain_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.domain_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.domain_.Set("", GetArena());
  }
  return released;
}
inline void ModelProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.domain_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
    _impl_.domain_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
}

// optional int64 model_version = 5;
inline bool ModelProto::has_model_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void ModelProto::clear_model_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.model_version_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
inline ::int64_t ModelProto::model_version() const {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
  return _internal_model_version();
}
inline void ModelProto::set_model_version(::int64_t value) {
  _internal_set_model_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
}
inline ::int64_t ModelProto::_internal_model_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.model_version_;
}
inline void ModelProto::_internal_set_model_version(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.model_version_ = value;
}

// optional string doc_string = 6;
inline bool ModelProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void ModelProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
inline const ::std::string& ModelProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ModelProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
  return _s;
}
inline const ::std::string& ModelProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void ModelProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ModelProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ModelProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void ModelProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
}

// optional .onnx.GraphProto graph = 7;
inline bool ModelProto::has_graph() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.graph_ != nullptr);
  return value;
}
inline void ModelProto::clear_graph() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.graph_ != nullptr) _impl_.graph_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::GraphProto* p = _impl_.graph_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::GraphProto&>(::onnx::_GraphProto_default_instance_);
}
inline const ::onnx::GraphProto& ModelProto::graph() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
  return _internal_graph();
}
inline void ModelProto::unsafe_arena_set_allocated_graph(
    ::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
  }
  _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE ModelProto::release_graph() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::onnx::GraphProto* released = _impl_.graph_;
  _impl_.graph_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::GraphProto* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_graph() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::onnx::GraphProto* temp = _impl_.graph_;
  _impl_.graph_ = nullptr;
  return temp;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL ModelProto::_internal_mutable_graph() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.graph_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::GraphProto>(GetArena());
    _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(p);
  }
  return _impl_.graph_;
}
inline ::onnx::GraphProto* PROTOBUF_NONNULL ModelProto::mutable_graph()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::onnx::GraphProto* _msg = _internal_mutable_graph();
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
  return _msg;
}
inline void ModelProto::set_allocated_graph(::onnx::GraphProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.graph_);
  }

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

  _impl_.graph_ = reinterpret_cast<::onnx::GraphProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
}

// repeated .onnx.StringStringEntryProto metadata_props = 14;
inline int ModelProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int ModelProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void ModelProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ModelProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL ModelProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL ModelProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& ModelProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
ModelProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

// repeated .onnx.TrainingInfoProto training_info = 20;
inline int ModelProto::_internal_training_info_size() const {
  return _internal_training_info().size();
}
inline int ModelProto::training_info_size() const {
  return _internal_training_info_size();
}
inline void ModelProto::clear_training_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.training_info_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000800U);
}
inline ::onnx::TrainingInfoProto* PROTOBUF_NONNULL ModelProto::mutable_training_info(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
  return _internal_mutable_training_info()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL ModelProto::mutable_training_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_training_info();
}
inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
  return _internal_training_info().Get(index);
}
inline ::onnx::TrainingInfoProto* PROTOBUF_NONNULL ModelProto::add_training_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TrainingInfoProto* _add =
      _internal_mutable_training_info()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>& ModelProto::training_info() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
  return _internal_training_info();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>&
ModelProto::_internal_training_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.training_info_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TrainingInfoProto>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_training_info() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.training_info_;
}

// repeated .onnx.FunctionProto functions = 25;
inline int ModelProto::_internal_functions_size() const {
  return _internal_functions().size();
}
inline int ModelProto::functions_size() const {
  return _internal_functions_size();
}
inline void ModelProto::clear_functions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.functions_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::onnx::FunctionProto* PROTOBUF_NONNULL ModelProto::mutable_functions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
  return _internal_mutable_functions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL ModelProto::mutable_functions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_functions();
}
inline const ::onnx::FunctionProto& ModelProto::functions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
  return _internal_functions().Get(index);
}
inline ::onnx::FunctionProto* PROTOBUF_NONNULL ModelProto::add_functions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::FunctionProto* _add =
      _internal_mutable_functions()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& ModelProto::functions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
  return _internal_functions();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>&
ModelProto::_internal_functions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.functions_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_functions() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.functions_;
}

// repeated .onnx.DeviceConfigurationProto configuration = 26;
inline int ModelProto::_internal_configuration_size() const {
  return _internal_configuration().size();
}
inline int ModelProto::configuration_size() const {
  return _internal_configuration_size();
}
inline void ModelProto::clear_configuration() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.configuration_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::onnx::DeviceConfigurationProto* PROTOBUF_NONNULL ModelProto::mutable_configuration(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.configuration)
  return _internal_mutable_configuration()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>* PROTOBUF_NONNULL ModelProto::mutable_configuration()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.configuration)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_configuration();
}
inline const ::onnx::DeviceConfigurationProto& ModelProto::configuration(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.ModelProto.configuration)
  return _internal_configuration().Get(index);
}
inline ::onnx::DeviceConfigurationProto* PROTOBUF_NONNULL ModelProto::add_configuration()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::DeviceConfigurationProto* _add =
      _internal_mutable_configuration()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.ModelProto.configuration)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>& ModelProto::configuration() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.ModelProto.configuration)
  return _internal_configuration();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>&
ModelProto::_internal_configuration() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.configuration_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::DeviceConfigurationProto>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_configuration() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.configuration_;
}

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

// DeviceConfigurationProto

// optional string name = 1;
inline bool DeviceConfigurationProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void DeviceConfigurationProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& DeviceConfigurationProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DeviceConfigurationProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.name)
}
inline ::std::string* PROTOBUF_NONNULL DeviceConfigurationProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.name)
  return _s;
}
inline const ::std::string& DeviceConfigurationProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void DeviceConfigurationProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DeviceConfigurationProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DeviceConfigurationProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.DeviceConfigurationProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void DeviceConfigurationProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.DeviceConfigurationProto.name)
}

// optional int32 num_devices = 2;
inline bool DeviceConfigurationProto::has_num_devices() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void DeviceConfigurationProto::clear_num_devices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_devices_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::int32_t DeviceConfigurationProto::num_devices() const {
  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.num_devices)
  return _internal_num_devices();
}
inline void DeviceConfigurationProto::set_num_devices(::int32_t value) {
  _internal_set_num_devices(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.num_devices)
}
inline ::int32_t DeviceConfigurationProto::_internal_num_devices() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_devices_;
}
inline void DeviceConfigurationProto::_internal_set_num_devices(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_devices_ = value;
}

// repeated string device = 3;
inline int DeviceConfigurationProto::_internal_device_size() const {
  return _internal_device().size();
}
inline int DeviceConfigurationProto::device_size() const {
  return _internal_device_size();
}
inline void DeviceConfigurationProto::clear_device() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL DeviceConfigurationProto::add_device()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_device()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:onnx.DeviceConfigurationProto.device)
  return _s;
}
inline const ::std::string& DeviceConfigurationProto::device(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.device)
  return _internal_device().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL DeviceConfigurationProto::mutable_device(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.device)
  return _internal_mutable_device()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void DeviceConfigurationProto::set_device(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_device()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.device)
}
template <typename Arg_, typename... Args_>
inline void DeviceConfigurationProto::add_device(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_device(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.DeviceConfigurationProto.device)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& DeviceConfigurationProto::device()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.DeviceConfigurationProto.device)
  return _internal_device();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
DeviceConfigurationProto::mutable_device() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.DeviceConfigurationProto.device)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_device();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
DeviceConfigurationProto::_internal_device() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
DeviceConfigurationProto::_internal_mutable_device() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.device_;
}

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

// StringStringEntryProto

// optional string key = 1;
inline bool StringStringEntryProto::has_key() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void StringStringEntryProto::clear_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& StringStringEntryProto::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_key(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
}
inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::mutable_key()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
  return _s;
}
inline const ::std::string& StringStringEntryProto::_internal_key() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.key_.Get();
}
inline void StringStringEntryProto::_internal_set_key(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::_internal_mutable_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.key_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE StringStringEntryProto::release_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.key_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.key_.Set("", GetArena());
  }
  return released;
}
inline void StringStringEntryProto::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.key_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
}

// optional string value = 2;
inline bool StringStringEntryProto::has_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void StringStringEntryProto::clear_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& StringStringEntryProto::value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
  return _internal_value();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void StringStringEntryProto::set_value(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
}
inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::mutable_value()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
  return _s;
}
inline const ::std::string& StringStringEntryProto::_internal_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_.Get();
}
inline void StringStringEntryProto::_internal_set_value(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL StringStringEntryProto::_internal_mutable_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.value_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE StringStringEntryProto::release_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.value_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.value_.Set("", GetArena());
  }
  return released;
}
inline void StringStringEntryProto::set_allocated_value(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.value_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
}

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

// TensorAnnotation

// optional string tensor_name = 1;
inline bool TensorAnnotation::has_tensor_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TensorAnnotation::clear_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& TensorAnnotation::tensor_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
  return _internal_tensor_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorAnnotation::set_tensor_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.tensor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
}
inline ::std::string* PROTOBUF_NONNULL TensorAnnotation::mutable_tensor_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_tensor_name();
  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
  return _s;
}
inline const ::std::string& TensorAnnotation::_internal_tensor_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tensor_name_.Get();
}
inline void TensorAnnotation::_internal_set_tensor_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tensor_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorAnnotation::_internal_mutable_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tensor_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorAnnotation::release_tensor_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.tensor_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.tensor_name_.Set("", GetArena());
  }
  return released;
}
inline void TensorAnnotation::set_allocated_tensor_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.tensor_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tensor_name_.IsDefault()) {
    _impl_.tensor_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
}

// repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
  return _internal_quant_parameter_tensor_names().size();
}
inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
  return _internal_quant_parameter_tensor_names_size();
}
inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quant_parameter_tensor_names_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorAnnotation::mutable_quant_parameter_tensor_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
  return _internal_mutable_quant_parameter_tensor_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorAnnotation::mutable_quant_parameter_tensor_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_quant_parameter_tensor_names();
}
inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
  return _internal_quant_parameter_tensor_names().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorAnnotation::add_quant_parameter_tensor_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_quant_parameter_tensor_names()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorAnnotation::quant_parameter_tensor_names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
  return _internal_quant_parameter_tensor_names();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
TensorAnnotation::_internal_quant_parameter_tensor_names() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.quant_parameter_tensor_names_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
TensorAnnotation::_internal_mutable_quant_parameter_tensor_names() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.quant_parameter_tensor_names_;
}

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

// GraphProto

// repeated .onnx.NodeProto node = 1;
inline int GraphProto::_internal_node_size() const {
  return _internal_node().size();
}
inline int GraphProto::node_size() const {
  return _internal_node_size();
}
inline void GraphProto::clear_node() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::NodeProto* PROTOBUF_NONNULL GraphProto::mutable_node(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
  return _internal_mutable_node()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL GraphProto::mutable_node()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_node();
}
inline const ::onnx::NodeProto& GraphProto::node(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
  return _internal_node().Get(index);
}
inline ::onnx::NodeProto* PROTOBUF_NONNULL GraphProto::add_node()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::NodeProto* _add =
      _internal_mutable_node()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& GraphProto::node() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
  return _internal_node();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
GraphProto::_internal_node() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_node() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.node_;
}

// optional string name = 2;
inline bool GraphProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void GraphProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
inline const ::std::string& GraphProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void GraphProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
}
inline ::std::string* PROTOBUF_NONNULL GraphProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
  return _s;
}
inline const ::std::string& GraphProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void GraphProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL GraphProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE GraphProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void GraphProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
}

// repeated .onnx.TensorProto initializer = 5;
inline int GraphProto::_internal_initializer_size() const {
  return _internal_initializer().size();
}
inline int GraphProto::initializer_size() const {
  return _internal_initializer_size();
}
inline void GraphProto::clear_initializer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initializer_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL GraphProto::mutable_initializer(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
  return _internal_mutable_initializer()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL GraphProto::mutable_initializer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_initializer();
}
inline const ::onnx::TensorProto& GraphProto::initializer(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
  return _internal_initializer().Get(index);
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL GraphProto::add_initializer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TensorProto* _add =
      _internal_mutable_initializer()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& GraphProto::initializer() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
  return _internal_initializer();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
GraphProto::_internal_initializer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.initializer_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_initializer() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.initializer_;
}

// repeated .onnx.SparseTensorProto sparse_initializer = 15;
inline int GraphProto::_internal_sparse_initializer_size() const {
  return _internal_sparse_initializer().size();
}
inline int GraphProto::sparse_initializer_size() const {
  return _internal_sparse_initializer_size();
}
inline void GraphProto::clear_sparse_initializer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sparse_initializer_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL GraphProto::mutable_sparse_initializer(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
  return _internal_mutable_sparse_initializer()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL GraphProto::mutable_sparse_initializer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_sparse_initializer();
}
inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
  return _internal_sparse_initializer().Get(index);
}
inline ::onnx::SparseTensorProto* PROTOBUF_NONNULL GraphProto::add_sparse_initializer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::SparseTensorProto* _add =
      _internal_mutable_sparse_initializer()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& GraphProto::sparse_initializer() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
  return _internal_sparse_initializer();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
GraphProto::_internal_sparse_initializer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sparse_initializer_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_sparse_initializer() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.sparse_initializer_;
}

// optional string doc_string = 10;
inline bool GraphProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void GraphProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline const ::std::string& GraphProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void GraphProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL GraphProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
  return _s;
}
inline const ::std::string& GraphProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void GraphProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL GraphProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE GraphProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void GraphProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
}

// repeated .onnx.ValueInfoProto input = 11;
inline int GraphProto::_internal_input_size() const {
  return _internal_input().size();
}
inline int GraphProto::input_size() const {
  return _internal_input_size();
}
inline void GraphProto::clear_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_input(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
  return _internal_mutable_input()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_input();
}
inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
  return _internal_input().Get(index);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ValueInfoProto* _add =
      _internal_mutable_input()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::input() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
  return _internal_input();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
GraphProto::_internal_input() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_input() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.input_;
}

// repeated .onnx.ValueInfoProto output = 12;
inline int GraphProto::_internal_output_size() const {
  return _internal_output().size();
}
inline int GraphProto::output_size() const {
  return _internal_output_size();
}
inline void GraphProto::clear_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_output(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
  return _internal_mutable_output()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_output();
}
inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
  return _internal_output().Get(index);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ValueInfoProto* _add =
      _internal_mutable_output()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::output() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
  return _internal_output();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
GraphProto::_internal_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_output() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.output_;
}

// repeated .onnx.ValueInfoProto value_info = 13;
inline int GraphProto::_internal_value_info_size() const {
  return _internal_value_info().size();
}
inline int GraphProto::value_info_size() const {
  return _internal_value_info_size();
}
inline void GraphProto::clear_value_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_info_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::mutable_value_info(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
  return _internal_mutable_value_info()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL GraphProto::mutable_value_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_value_info();
}
inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
  return _internal_value_info().Get(index);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL GraphProto::add_value_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ValueInfoProto* _add =
      _internal_mutable_value_info()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& GraphProto::value_info() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
  return _internal_value_info();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
GraphProto::_internal_value_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_info_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_value_info() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.value_info_;
}

// repeated .onnx.TensorAnnotation quantization_annotation = 14;
inline int GraphProto::_internal_quantization_annotation_size() const {
  return _internal_quantization_annotation().size();
}
inline int GraphProto::quantization_annotation_size() const {
  return _internal_quantization_annotation_size();
}
inline void GraphProto::clear_quantization_annotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quantization_annotation_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000020U);
}
inline ::onnx::TensorAnnotation* PROTOBUF_NONNULL GraphProto::mutable_quantization_annotation(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
  return _internal_mutable_quantization_annotation()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL GraphProto::mutable_quantization_annotation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_quantization_annotation();
}
inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
  return _internal_quantization_annotation().Get(index);
}
inline ::onnx::TensorAnnotation* PROTOBUF_NONNULL GraphProto::add_quantization_annotation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TensorAnnotation* _add =
      _internal_mutable_quantization_annotation()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>& GraphProto::quantization_annotation() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
  return _internal_quantization_annotation();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>&
GraphProto::_internal_quantization_annotation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.quantization_annotation_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorAnnotation>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_quantization_annotation() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.quantization_annotation_;
}

// repeated .onnx.StringStringEntryProto metadata_props = 16;
inline int GraphProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int GraphProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void GraphProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000080U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL GraphProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL GraphProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL GraphProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& GraphProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
GraphProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
GraphProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

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

// TensorProto_Segment

// optional int64 begin = 1;
inline bool TensorProto_Segment::has_begin() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void TensorProto_Segment::clear_begin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.begin_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t TensorProto_Segment::begin() const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
  return _internal_begin();
}
inline void TensorProto_Segment::set_begin(::int64_t value) {
  _internal_set_begin(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
}
inline ::int64_t TensorProto_Segment::_internal_begin() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.begin_;
}
inline void TensorProto_Segment::_internal_set_begin(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.begin_ = value;
}

// optional int64 end = 2;
inline bool TensorProto_Segment::has_end() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TensorProto_Segment::clear_end() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.end_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int64_t TensorProto_Segment::end() const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
  return _internal_end();
}
inline void TensorProto_Segment::set_end(::int64_t value) {
  _internal_set_end(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
}
inline ::int64_t TensorProto_Segment::_internal_end() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.end_;
}
inline void TensorProto_Segment::_internal_set_end(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.end_ = value;
}

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

// TensorProto

// repeated int64 dims = 1;
inline int TensorProto::_internal_dims_size() const {
  return _internal_dims().size();
}
inline int TensorProto::dims_size() const {
  return _internal_dims_size();
}
inline void TensorProto::clear_dims() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dims_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t TensorProto::dims(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
  return _internal_dims().Get(index);
}
inline void TensorProto::set_dims(int index, ::int64_t value) {
  _internal_mutable_dims()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
}
inline void TensorProto::add_dims(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_dims()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::dims() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
  return _internal_dims();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL TensorProto::mutable_dims()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_dims();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
TensorProto::_internal_dims() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dims_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_dims() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.dims_;
}

// optional int32 data_type = 2;
inline bool TensorProto::has_data_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void TensorProto::clear_data_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00002000U);
}
inline ::int32_t TensorProto::data_type() const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
  return _internal_data_type();
}
inline void TensorProto::set_data_type(::int32_t value) {
  _internal_set_data_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
}
inline ::int32_t TensorProto::_internal_data_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.data_type_;
}
inline void TensorProto::_internal_set_data_type(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_type_ = value;
}

// optional .onnx.TensorProto.Segment segment = 3;
inline bool TensorProto::has_segment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.segment_ != nullptr);
  return value;
}
inline void TensorProto::clear_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.segment_ != nullptr) _impl_.segment_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00001000U);
}
inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorProto_Segment* p = _impl_.segment_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto_Segment&>(::onnx::_TensorProto_Segment_default_instance_);
}
inline const ::onnx::TensorProto_Segment& TensorProto::segment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
  return _internal_segment();
}
inline void TensorProto::unsafe_arena_set_allocated_segment(
    ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
  }
  _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
}
inline ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE TensorProto::release_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::TensorProto_Segment* released = _impl_.segment_;
  _impl_.segment_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorProto_Segment* PROTOBUF_NULLABLE TensorProto::unsafe_arena_release_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::TensorProto_Segment* temp = _impl_.segment_;
  _impl_.segment_ = nullptr;
  return temp;
}
inline ::onnx::TensorProto_Segment* PROTOBUF_NONNULL TensorProto::_internal_mutable_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.segment_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto_Segment>(GetArena());
    _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(p);
  }
  return _impl_.segment_;
}
inline ::onnx::TensorProto_Segment* PROTOBUF_NONNULL TensorProto::mutable_segment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
  return _msg;
}
inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.segment_);
  }

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

  _impl_.segment_ = reinterpret_cast<::onnx::TensorProto_Segment*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
}

// repeated float float_data = 4 [packed = true];
inline int TensorProto::_internal_float_data_size() const {
  return _internal_float_data().size();
}
inline int TensorProto::float_data_size() const {
  return _internal_float_data_size();
}
inline void TensorProto::clear_float_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.float_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline float TensorProto::float_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
  return _internal_float_data().Get(index);
}
inline void TensorProto::set_float_data(int index, float value) {
  _internal_mutable_float_data()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
}
inline void TensorProto::add_float_data(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_float_data()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
}
inline const ::google::protobuf::RepeatedField<float>& TensorProto::float_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
  return _internal_float_data();
}
inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL TensorProto::mutable_float_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_float_data();
}
inline const ::google::protobuf::RepeatedField<float>&
TensorProto::_internal_float_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.float_data_;
}
inline ::google::protobuf::RepeatedField<float>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_float_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.float_data_;
}

// repeated int32 int32_data = 5 [packed = true];
inline int TensorProto::_internal_int32_data_size() const {
  return _internal_int32_data().size();
}
inline int TensorProto::int32_data_size() const {
  return _internal_int32_data_size();
}
inline void TensorProto::clear_int32_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.int32_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::int32_t TensorProto::int32_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
  return _internal_int32_data().Get(index);
}
inline void TensorProto::set_int32_data(int index, ::int32_t value) {
  _internal_mutable_int32_data()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
}
inline void TensorProto::add_int32_data(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_int32_data()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
}
inline const ::google::protobuf::RepeatedField<::int32_t>& TensorProto::int32_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
  return _internal_int32_data();
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL TensorProto::mutable_int32_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_int32_data();
}
inline const ::google::protobuf::RepeatedField<::int32_t>&
TensorProto::_internal_int32_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.int32_data_;
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_int32_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.int32_data_;
}

// repeated bytes string_data = 6;
inline int TensorProto::_internal_string_data_size() const {
  return _internal_string_data().size();
}
inline int TensorProto::string_data_size() const {
  return _internal_string_data_size();
}
inline void TensorProto::clear_string_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.string_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::add_string_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_string_data()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
  return _s;
}
inline const ::std::string& TensorProto::string_data(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
  return _internal_string_data().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_string_data(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
  return _internal_mutable_string_data()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void TensorProto::set_string_data(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_string_data()->Mutable(index), ::std::forward<Arg_>(value),
                        args... , ::google::protobuf::internal::BytesTag{});
  // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
}
template <typename Arg_, typename... Args_>
inline void TensorProto::add_string_data(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_string_data(), ::std::forward<Arg_>(value),
      args... , ::google::protobuf::internal::BytesTag{});
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& TensorProto::string_data()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
  return _internal_string_data();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TensorProto::mutable_string_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_string_data();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
TensorProto::_internal_string_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.string_data_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_string_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.string_data_;
}

// repeated int64 int64_data = 7 [packed = true];
inline int TensorProto::_internal_int64_data_size() const {
  return _internal_int64_data().size();
}
inline int TensorProto::int64_data_size() const {
  return _internal_int64_data_size();
}
inline void TensorProto::clear_int64_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.int64_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::int64_t TensorProto::int64_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
  return _internal_int64_data().Get(index);
}
inline void TensorProto::set_int64_data(int index, ::int64_t value) {
  _internal_mutable_int64_data()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
}
inline void TensorProto::add_int64_data(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_int64_data()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& TensorProto::int64_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
  return _internal_int64_data();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL TensorProto::mutable_int64_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_int64_data();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
TensorProto::_internal_int64_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.int64_data_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_int64_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.int64_data_;
}

// optional string name = 8;
inline bool TensorProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void TensorProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline const ::std::string& TensorProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
  return _s;
}
inline const ::std::string& TensorProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void TensorProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void TensorProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
}

// optional string doc_string = 12;
inline bool TensorProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void TensorProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000800U);
}
inline const ::std::string& TensorProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
  return _s;
}
inline const ::std::string& TensorProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void TensorProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void TensorProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
}

// optional bytes raw_data = 9;
inline bool TensorProto::has_raw_data() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void TensorProto::clear_raw_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.raw_data_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
inline const ::std::string& TensorProto::raw_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
  return _internal_raw_data();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorProto::set_raw_data(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.raw_data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::mutable_raw_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_raw_data();
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
  return _s;
}
inline const ::std::string& TensorProto::_internal_raw_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.raw_data_.Get();
}
inline void TensorProto::_internal_set_raw_data(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.raw_data_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorProto::_internal_mutable_raw_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.raw_data_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorProto::release_raw_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.raw_data_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.raw_data_.Set("", GetArena());
  }
  return released;
}
inline void TensorProto::set_allocated_raw_data(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  _impl_.raw_data_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.raw_data_.IsDefault()) {
    _impl_.raw_data_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
}

// repeated .onnx.StringStringEntryProto external_data = 13;
inline int TensorProto::_internal_external_data_size() const {
  return _internal_external_data().size();
}
inline int TensorProto::external_data_size() const {
  return _internal_external_data_size();
}
inline void TensorProto::clear_external_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.external_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000080U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::mutable_external_data(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
  return _internal_mutable_external_data()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorProto::mutable_external_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_external_data();
}
inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
  return _internal_external_data().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::add_external_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_external_data()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::external_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
  return _internal_external_data();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
TensorProto::_internal_external_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.external_data_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_external_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.external_data_;
}

// optional .onnx.TensorProto.DataLocation data_location = 14;
inline bool TensorProto::has_data_location() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void TensorProto::clear_data_location() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_location_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00004000U);
}
inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
  return _internal_data_location();
}
inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
  _internal_set_data_location(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
}
inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::onnx::TensorProto_DataLocation>(_impl_.data_location_);
}
inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::onnx::TensorProto_DataLocation_internal_data_));
                                          _impl_.data_location_ = value;
}

// repeated double double_data = 10 [packed = true];
inline int TensorProto::_internal_double_data_size() const {
  return _internal_double_data().size();
}
inline int TensorProto::double_data_size() const {
  return _internal_double_data_size();
}
inline void TensorProto::clear_double_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.double_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000020U);
}
inline double TensorProto::double_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
  return _internal_double_data().Get(index);
}
inline void TensorProto::set_double_data(int index, double value) {
  _internal_mutable_double_data()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
}
inline void TensorProto::add_double_data(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_double_data()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
}
inline const ::google::protobuf::RepeatedField<double>& TensorProto::double_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
  return _internal_double_data();
}
inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL TensorProto::mutable_double_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_double_data();
}
inline const ::google::protobuf::RepeatedField<double>&
TensorProto::_internal_double_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.double_data_;
}
inline ::google::protobuf::RepeatedField<double>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_double_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.double_data_;
}

// repeated uint64 uint64_data = 11 [packed = true];
inline int TensorProto::_internal_uint64_data_size() const {
  return _internal_uint64_data().size();
}
inline int TensorProto::uint64_data_size() const {
  return _internal_uint64_data_size();
}
inline void TensorProto::clear_uint64_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.uint64_data_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::uint64_t TensorProto::uint64_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
  return _internal_uint64_data().Get(index);
}
inline void TensorProto::set_uint64_data(int index, ::uint64_t value) {
  _internal_mutable_uint64_data()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
}
inline void TensorProto::add_uint64_data(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_uint64_data()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& TensorProto::uint64_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
  return _internal_uint64_data();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL TensorProto::mutable_uint64_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_uint64_data();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>&
TensorProto::_internal_uint64_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.uint64_data_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_uint64_data() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.uint64_data_;
}

// repeated .onnx.StringStringEntryProto metadata_props = 16;
inline int TensorProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int TensorProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void TensorProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000100U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL TensorProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL TensorProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& TensorProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
TensorProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
TensorProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

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

// SparseTensorProto

// optional .onnx.TensorProto values = 1;
inline bool SparseTensorProto::has_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
  return value;
}
inline void SparseTensorProto::clear_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.values_ != nullptr) _impl_.values_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorProto* p = _impl_.values_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
}
inline const ::onnx::TensorProto& SparseTensorProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
  return _internal_values();
}
inline void SparseTensorProto::unsafe_arena_set_allocated_values(
    ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
  }
  _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::release_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::onnx::TensorProto* released = _impl_.values_;
  _impl_.values_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::unsafe_arena_release_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::onnx::TensorProto* temp = _impl_.values_;
  _impl_.values_ = nullptr;
  return temp;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::_internal_mutable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
    _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(p);
  }
  return _impl_.values_;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::mutable_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::onnx::TensorProto* _msg = _internal_mutable_values();
  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
  return _msg;
}
inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
  }

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

  _impl_.values_ = reinterpret_cast<::onnx::TensorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
}

// optional .onnx.TensorProto indices = 2;
inline bool SparseTensorProto::has_indices() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.indices_ != nullptr);
  return value;
}
inline void SparseTensorProto::clear_indices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.indices_ != nullptr) _impl_.indices_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorProto* p = _impl_.indices_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
}
inline const ::onnx::TensorProto& SparseTensorProto::indices() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
  return _internal_indices();
}
inline void SparseTensorProto::unsafe_arena_set_allocated_indices(
    ::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
  }
  _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::release_indices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::TensorProto* released = _impl_.indices_;
  _impl_.indices_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorProto* PROTOBUF_NULLABLE SparseTensorProto::unsafe_arena_release_indices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::TensorProto* temp = _impl_.indices_;
  _impl_.indices_ = nullptr;
  return temp;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::_internal_mutable_indices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.indices_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
    _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(p);
  }
  return _impl_.indices_;
}
inline ::onnx::TensorProto* PROTOBUF_NONNULL SparseTensorProto::mutable_indices()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::onnx::TensorProto* _msg = _internal_mutable_indices();
  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
  return _msg;
}
inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.indices_);
  }

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

  _impl_.indices_ = reinterpret_cast<::onnx::TensorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
}

// repeated int64 dims = 3;
inline int SparseTensorProto::_internal_dims_size() const {
  return _internal_dims().size();
}
inline int SparseTensorProto::dims_size() const {
  return _internal_dims_size();
}
inline void SparseTensorProto::clear_dims() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dims_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t SparseTensorProto::dims(int index) const {
  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
  return _internal_dims().Get(index);
}
inline void SparseTensorProto::set_dims(int index, ::int64_t value) {
  _internal_mutable_dims()->Set(index, value);
  // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
}
inline void SparseTensorProto::add_dims(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_dims()->InternalAddWithArena(
      internal_visibility(), GetArena(), value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& SparseTensorProto::dims() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
  return _internal_dims();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL SparseTensorProto::mutable_dims()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_dims();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
SparseTensorProto::_internal_dims() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dims_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
SparseTensorProto::_internal_mutable_dims() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.dims_;
}

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

// TensorShapeProto_Dimension

// int64 dim_value = 1;
inline bool TensorShapeProto_Dimension::has_dim_value() const {
  return value_case() == kDimValue;
}
inline void TensorShapeProto_Dimension::set_has_dim_value() {
  _impl_._oneof_case_[0] = kDimValue;
}
inline void TensorShapeProto_Dimension::clear_dim_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kDimValue) {
    _impl_.value_.dim_value_ = ::int64_t{0};
    clear_has_value();
  }
}
inline ::int64_t TensorShapeProto_Dimension::dim_value() const {
  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
  return _internal_dim_value();
}
inline void TensorShapeProto_Dimension::set_dim_value(::int64_t value) {
  if (value_case() != kDimValue) {
    clear_value();
    set_has_dim_value();
  }
  _impl_.value_.dim_value_ = value;
  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
}
inline ::int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
  if (value_case() == kDimValue) {
    return _impl_.value_.dim_value_;
  }
  return ::int64_t{0};
}

// string dim_param = 2;
inline bool TensorShapeProto_Dimension::has_dim_param() const {
  return value_case() == kDimParam;
}
inline void TensorShapeProto_Dimension::set_has_dim_param() {
  _impl_._oneof_case_[0] = kDimParam;
}
inline void TensorShapeProto_Dimension::clear_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kDimParam) {
    _impl_.value_.dim_param_.Destroy();
    clear_has_value();
  }
}
inline const ::std::string& TensorShapeProto_Dimension::dim_param() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
  return _internal_dim_param();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_dim_param(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() != kDimParam) {
    clear_value();

    set_has_dim_param();
    _impl_.value_.dim_param_.InitDefault();
  }
  _impl_.value_.dim_param_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
}
inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::mutable_dim_param()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (value_case() != kDimParam) {
    clear_value();

    set_has_dim_param();
    _impl_.value_.dim_param_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_dim_param();
  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
  return _s;
}
inline const ::std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (value_case() != kDimParam) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.value_.dim_param_.Get();
}
inline void TensorShapeProto_Dimension::_internal_set_dim_param(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.dim_param_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::_internal_mutable_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.value_.dim_param_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorShapeProto_Dimension::release_dim_param() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
  if (value_case() != kDimParam) {
    return nullptr;
  }
  clear_has_value();
  return _impl_.value_.dim_param_.Release();
}
inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_value()) {
    clear_value();
  }
  if (value != nullptr) {
    set_has_dim_param();
    _impl_.value_.dim_param_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
}

// optional string denotation = 3;
inline bool TensorShapeProto_Dimension::has_denotation() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void TensorShapeProto_Dimension::clear_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.denotation_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& TensorShapeProto_Dimension::denotation() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
  return _internal_denotation();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TensorShapeProto_Dimension::set_denotation(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
}
inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::mutable_denotation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_denotation();
  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
  return _s;
}
inline const ::std::string& TensorShapeProto_Dimension::_internal_denotation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.denotation_.Get();
}
inline void TensorShapeProto_Dimension::_internal_set_denotation(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.denotation_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TensorShapeProto_Dimension::_internal_mutable_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.denotation_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TensorShapeProto_Dimension::release_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.denotation_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.denotation_.Set("", GetArena());
  }
  return released;
}
inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.denotation_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.denotation_.IsDefault()) {
    _impl_.denotation_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
}

inline bool TensorShapeProto_Dimension::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void TensorShapeProto_Dimension::clear_has_value() {
  _impl_._oneof_case_[0] = VALUE_NOT_SET;
}
inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
  return TensorShapeProto_Dimension::ValueCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// TensorShapeProto

// repeated .onnx.TensorShapeProto.Dimension dim = 1;
inline int TensorShapeProto::_internal_dim_size() const {
  return _internal_dim().size();
}
inline int TensorShapeProto::dim_size() const {
  return _internal_dim_size();
}
inline void TensorShapeProto::clear_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dim_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL TensorShapeProto::mutable_dim(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
  return _internal_mutable_dim()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL TensorShapeProto::mutable_dim()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_dim();
}
inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
  return _internal_dim().Get(index);
}
inline ::onnx::TensorShapeProto_Dimension* PROTOBUF_NONNULL TensorShapeProto::add_dim()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::TensorShapeProto_Dimension* _add =
      _internal_mutable_dim()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>& TensorShapeProto::dim() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
  return _internal_dim();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>&
TensorShapeProto::_internal_dim() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dim_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::TensorShapeProto_Dimension>* PROTOBUF_NONNULL
TensorShapeProto::_internal_mutable_dim() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.dim_;
}

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

// TypeProto_Tensor

// optional int32 elem_type = 1;
inline bool TypeProto_Tensor::has_elem_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TypeProto_Tensor::clear_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.elem_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int32_t TypeProto_Tensor::elem_type() const {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
  return _internal_elem_type();
}
inline void TypeProto_Tensor::set_elem_type(::int32_t value) {
  _internal_set_elem_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
}
inline ::int32_t TypeProto_Tensor::_internal_elem_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.elem_type_;
}
inline void TypeProto_Tensor::_internal_set_elem_type(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.elem_type_ = value;
}

// optional .onnx.TensorShapeProto shape = 2;
inline bool TypeProto_Tensor::has_shape() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
  return value;
}
inline void TypeProto_Tensor::clear_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorShapeProto* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
}
inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
  return _internal_shape();
}
inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
    ::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
}
inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_Tensor::release_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* released = _impl_.shape_;
  _impl_.shape_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_Tensor::unsafe_arena_release_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_Tensor::_internal_mutable_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.shape_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
    _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
  }
  return _impl_.shape_;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_Tensor::mutable_shape()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
  return _msg;
}
inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
  }

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

  _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
}

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

// TypeProto_Sequence

// optional .onnx.TypeProto elem_type = 1;
inline bool TypeProto_Sequence::has_elem_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
  return value;
}
inline void TypeProto_Sequence::clear_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TypeProto* p = _impl_.elem_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
}
inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
  return _internal_elem_type();
}
inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(
    ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
  }
  _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Sequence::release_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* released = _impl_.elem_type_;
  _impl_.elem_type_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Sequence::unsafe_arena_release_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* temp = _impl_.elem_type_;
  _impl_.elem_type_ = nullptr;
  return temp;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Sequence::_internal_mutable_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.elem_type_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
    _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
  }
  return _impl_.elem_type_;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Sequence::mutable_elem_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
  return _msg;
}
inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
  }

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

  _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
}

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

// TypeProto_Map

// optional int32 key_type = 1;
inline bool TypeProto_Map::has_key_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TypeProto_Map::clear_key_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int32_t TypeProto_Map::key_type() const {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
  return _internal_key_type();
}
inline void TypeProto_Map::set_key_type(::int32_t value) {
  _internal_set_key_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
}
inline ::int32_t TypeProto_Map::_internal_key_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.key_type_;
}
inline void TypeProto_Map::_internal_set_key_type(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_type_ = value;
}

// optional .onnx.TypeProto value_type = 2;
inline bool TypeProto_Map::has_value_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.value_type_ != nullptr);
  return value;
}
inline void TypeProto_Map::clear_value_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.value_type_ != nullptr) _impl_.value_type_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TypeProto* p = _impl_.value_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
}
inline const ::onnx::TypeProto& TypeProto_Map::value_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
  return _internal_value_type();
}
inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(
    ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
  }
  _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Map::release_value_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* released = _impl_.value_type_;
  _impl_.value_type_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Map::unsafe_arena_release_value_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* temp = _impl_.value_type_;
  _impl_.value_type_ = nullptr;
  return temp;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Map::_internal_mutable_value_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.value_type_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
    _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
  }
  return _impl_.value_type_;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Map::mutable_value_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* _msg = _internal_mutable_value_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
  return _msg;
}
inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_type_);
  }

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

  _impl_.value_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
}

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

// TypeProto_Optional

// optional .onnx.TypeProto elem_type = 1;
inline bool TypeProto_Optional::has_elem_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.elem_type_ != nullptr);
  return value;
}
inline void TypeProto_Optional::clear_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.elem_type_ != nullptr) _impl_.elem_type_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TypeProto* p = _impl_.elem_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TypeProto&>(::onnx::_TypeProto_default_instance_);
}
inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
  return _internal_elem_type();
}
inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(
    ::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
  }
  _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Optional::release_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* released = _impl_.elem_type_;
  _impl_.elem_type_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TypeProto* PROTOBUF_NULLABLE TypeProto_Optional::unsafe_arena_release_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* temp = _impl_.elem_type_;
  _impl_.elem_type_ = nullptr;
  return temp;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Optional::_internal_mutable_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.elem_type_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto>(GetArena());
    _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(p);
  }
  return _impl_.elem_type_;
}
inline ::onnx::TypeProto* PROTOBUF_NONNULL TypeProto_Optional::mutable_elem_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TypeProto* _msg = _internal_mutable_elem_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
  return _msg;
}
inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elem_type_);
  }

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

  _impl_.elem_type_ = reinterpret_cast<::onnx::TypeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
}

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

// TypeProto_SparseTensor

// optional int32 elem_type = 1;
inline bool TypeProto_SparseTensor::has_elem_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TypeProto_SparseTensor::clear_elem_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.elem_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int32_t TypeProto_SparseTensor::elem_type() const {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
  return _internal_elem_type();
}
inline void TypeProto_SparseTensor::set_elem_type(::int32_t value) {
  _internal_set_elem_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
}
inline ::int32_t TypeProto_SparseTensor::_internal_elem_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.elem_type_;
}
inline void TypeProto_SparseTensor::_internal_set_elem_type(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.elem_type_ = value;
}

// optional .onnx.TensorShapeProto shape = 2;
inline bool TypeProto_SparseTensor::has_shape() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
  return value;
}
inline void TypeProto_SparseTensor::clear_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::onnx::TensorShapeProto* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorShapeProto&>(::onnx::_TensorShapeProto_default_instance_);
}
inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
  return _internal_shape();
}
inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(
    ::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
}
inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_SparseTensor::release_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* released = _impl_.shape_;
  _impl_.shape_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NULLABLE TypeProto_SparseTensor::unsafe_arena_release_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_SparseTensor::_internal_mutable_shape() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.shape_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorShapeProto>(GetArena());
    _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(p);
  }
  return _impl_.shape_;
}
inline ::onnx::TensorShapeProto* PROTOBUF_NONNULL TypeProto_SparseTensor::mutable_shape()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::onnx::TensorShapeProto* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
  return _msg;
}
inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.shape_);
  }

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

  _impl_.shape_ = reinterpret_cast<::onnx::TensorShapeProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
}

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

// TypeProto_Opaque

// optional string domain = 1;
inline bool TypeProto_Opaque::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void TypeProto_Opaque::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& TypeProto_Opaque::domain() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.domain)
  return _internal_domain();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_domain(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.domain)
}
inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.domain)
  return _s;
}
inline const ::std::string& TypeProto_Opaque::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.domain_.Get();
}
inline void TypeProto_Opaque::_internal_set_domain(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.domain_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TypeProto_Opaque::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.domain)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.domain_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.domain_.Set("", GetArena());
  }
  return released;
}
inline void TypeProto_Opaque::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.domain_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
    _impl_.domain_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.domain)
}

// optional string name = 2;
inline bool TypeProto_Opaque::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TypeProto_Opaque::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& TypeProto_Opaque::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.Opaque.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TypeProto_Opaque::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TypeProto.Opaque.name)
}
inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Opaque.name)
  return _s;
}
inline const ::std::string& TypeProto_Opaque::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void TypeProto_Opaque::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TypeProto_Opaque::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TypeProto_Opaque::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.Opaque.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void TypeProto_Opaque::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Opaque.name)
}

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

// TypeProto

// .onnx.TypeProto.Tensor tensor_type = 1;
inline bool TypeProto::has_tensor_type() const {
  return value_case() == kTensorType;
}
inline bool TypeProto::_internal_has_tensor_type() const {
  return value_case() == kTensorType;
}
inline void TypeProto::set_has_tensor_type() {
  _impl_._oneof_case_[0] = kTensorType;
}
inline void TypeProto::clear_tensor_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kTensorType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.tensor_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.tensor_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE TypeProto::release_tensor_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
  if (value_case() == kTensorType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.tensor_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
  return value_case() == kTensorType ? static_cast<const ::onnx::TypeProto_Tensor&>(*reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_Tensor&>(::onnx::_TypeProto_Tensor_default_instance_);
}
inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
  return _internal_tensor_type();
}
inline ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_tensor_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
  if (value_case() == kTensorType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
    _impl_.value_.tensor_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_tensor_type(
    ::onnx::TypeProto_Tensor* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_tensor_type();
    _impl_.value_.tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
}
inline ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL TypeProto::_internal_mutable_tensor_type() {
  if (value_case() != kTensorType) {
    clear_value();
    set_has_tensor_type();
    _impl_.value_.tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Tensor>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_Tensor*>(_impl_.value_.tensor_type_);
}
inline ::onnx::TypeProto_Tensor* PROTOBUF_NONNULL TypeProto::mutable_tensor_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
  return _msg;
}

// .onnx.TypeProto.Sequence sequence_type = 4;
inline bool TypeProto::has_sequence_type() const {
  return value_case() == kSequenceType;
}
inline bool TypeProto::_internal_has_sequence_type() const {
  return value_case() == kSequenceType;
}
inline void TypeProto::set_has_sequence_type() {
  _impl_._oneof_case_[0] = kSequenceType;
}
inline void TypeProto::clear_sequence_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kSequenceType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.sequence_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sequence_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE TypeProto::release_sequence_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
  if (value_case() == kSequenceType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.sequence_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
  return value_case() == kSequenceType ? static_cast<const ::onnx::TypeProto_Sequence&>(*reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_Sequence&>(::onnx::_TypeProto_Sequence_default_instance_);
}
inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
  return _internal_sequence_type();
}
inline ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_sequence_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
  if (value_case() == kSequenceType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
    _impl_.value_.sequence_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_sequence_type(
    ::onnx::TypeProto_Sequence* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_sequence_type();
    _impl_.value_.sequence_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
}
inline ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL TypeProto::_internal_mutable_sequence_type() {
  if (value_case() != kSequenceType) {
    clear_value();
    set_has_sequence_type();
    _impl_.value_.sequence_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Sequence>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_Sequence*>(_impl_.value_.sequence_type_);
}
inline ::onnx::TypeProto_Sequence* PROTOBUF_NONNULL TypeProto::mutable_sequence_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_Sequence* _msg = _internal_mutable_sequence_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
  return _msg;
}

// .onnx.TypeProto.Map map_type = 5;
inline bool TypeProto::has_map_type() const {
  return value_case() == kMapType;
}
inline bool TypeProto::_internal_has_map_type() const {
  return value_case() == kMapType;
}
inline void TypeProto::set_has_map_type() {
  _impl_._oneof_case_[0] = kMapType;
}
inline void TypeProto::clear_map_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kMapType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.map_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.map_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_Map* PROTOBUF_NULLABLE TypeProto::release_map_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
  if (value_case() == kMapType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
  return value_case() == kMapType ? static_cast<const ::onnx::TypeProto_Map&>(*reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_Map&>(::onnx::_TypeProto_Map_default_instance_);
}
inline const ::onnx::TypeProto_Map& TypeProto::map_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
  return _internal_map_type();
}
inline ::onnx::TypeProto_Map* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_map_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
  if (value_case() == kMapType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
    _impl_.value_.map_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_map_type(
    ::onnx::TypeProto_Map* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_map_type();
    _impl_.value_.map_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
}
inline ::onnx::TypeProto_Map* PROTOBUF_NONNULL TypeProto::_internal_mutable_map_type() {
  if (value_case() != kMapType) {
    clear_value();
    set_has_map_type();
    _impl_.value_.map_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Map>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_Map*>(_impl_.value_.map_type_);
}
inline ::onnx::TypeProto_Map* PROTOBUF_NONNULL TypeProto::mutable_map_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_Map* _msg = _internal_mutable_map_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
  return _msg;
}

// .onnx.TypeProto.Optional optional_type = 9;
inline bool TypeProto::has_optional_type() const {
  return value_case() == kOptionalType;
}
inline bool TypeProto::_internal_has_optional_type() const {
  return value_case() == kOptionalType;
}
inline void TypeProto::set_has_optional_type() {
  _impl_._oneof_case_[0] = kOptionalType;
}
inline void TypeProto::clear_optional_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kOptionalType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.optional_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.optional_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE TypeProto::release_optional_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
  if (value_case() == kOptionalType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.optional_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
  return value_case() == kOptionalType ? static_cast<const ::onnx::TypeProto_Optional&>(*reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_Optional&>(::onnx::_TypeProto_Optional_default_instance_);
}
inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
  return _internal_optional_type();
}
inline ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_optional_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
  if (value_case() == kOptionalType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
    _impl_.value_.optional_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_optional_type(
    ::onnx::TypeProto_Optional* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_optional_type();
    _impl_.value_.optional_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
}
inline ::onnx::TypeProto_Optional* PROTOBUF_NONNULL TypeProto::_internal_mutable_optional_type() {
  if (value_case() != kOptionalType) {
    clear_value();
    set_has_optional_type();
    _impl_.value_.optional_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Optional>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_Optional*>(_impl_.value_.optional_type_);
}
inline ::onnx::TypeProto_Optional* PROTOBUF_NONNULL TypeProto::mutable_optional_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_Optional* _msg = _internal_mutable_optional_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
  return _msg;
}

// .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
inline bool TypeProto::has_sparse_tensor_type() const {
  return value_case() == kSparseTensorType;
}
inline bool TypeProto::_internal_has_sparse_tensor_type() const {
  return value_case() == kSparseTensorType;
}
inline void TypeProto::set_has_sparse_tensor_type() {
  _impl_._oneof_case_[0] = kSparseTensorType;
}
inline void TypeProto::clear_sparse_tensor_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kSparseTensorType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.sparse_tensor_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.sparse_tensor_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE TypeProto::release_sparse_tensor_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
  if (value_case() == kSparseTensorType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.sparse_tensor_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
  return value_case() == kSparseTensorType ? static_cast<const ::onnx::TypeProto_SparseTensor&>(*reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_SparseTensor&>(::onnx::_TypeProto_SparseTensor_default_instance_);
}
inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
  return _internal_sparse_tensor_type();
}
inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_sparse_tensor_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
  if (value_case() == kSparseTensorType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
    _impl_.value_.sparse_tensor_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(
    ::onnx::TypeProto_SparseTensor* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_sparse_tensor_type();
    _impl_.value_.sparse_tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
}
inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL TypeProto::_internal_mutable_sparse_tensor_type() {
  if (value_case() != kSparseTensorType) {
    clear_value();
    set_has_sparse_tensor_type();
    _impl_.value_.sparse_tensor_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_SparseTensor>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_SparseTensor*>(_impl_.value_.sparse_tensor_type_);
}
inline ::onnx::TypeProto_SparseTensor* PROTOBUF_NONNULL TypeProto::mutable_sparse_tensor_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_SparseTensor* _msg = _internal_mutable_sparse_tensor_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
  return _msg;
}

// .onnx.TypeProto.Opaque opaque_type = 7;
inline bool TypeProto::has_opaque_type() const {
  return value_case() == kOpaqueType;
}
inline bool TypeProto::_internal_has_opaque_type() const {
  return value_case() == kOpaqueType;
}
inline void TypeProto::set_has_opaque_type() {
  _impl_._oneof_case_[0] = kOpaqueType;
}
inline void TypeProto::clear_opaque_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value_case() == kOpaqueType) {
    if (GetArena() == nullptr) {
      delete _impl_.value_.opaque_type_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.value_.opaque_type_);
    }
    clear_has_value();
  }
}
inline ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE TypeProto::release_opaque_type() {
  // @@protoc_insertion_point(field_release:onnx.TypeProto.opaque_type)
  if (value_case() == kOpaqueType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.opaque_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::onnx::TypeProto_Opaque& TypeProto::_internal_opaque_type() const {
  return value_case() == kOpaqueType ? static_cast<const ::onnx::TypeProto_Opaque&>(*reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_))
                     : reinterpret_cast<const ::onnx::TypeProto_Opaque&>(::onnx::_TypeProto_Opaque_default_instance_);
}
inline const ::onnx::TypeProto_Opaque& TypeProto::opaque_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.opaque_type)
  return _internal_opaque_type();
}
inline ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE TypeProto::unsafe_arena_release_opaque_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.opaque_type)
  if (value_case() == kOpaqueType) {
    clear_has_value();
    auto* temp = reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
    _impl_.value_.opaque_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TypeProto::unsafe_arena_set_allocated_opaque_type(
    ::onnx::TypeProto_Opaque* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_value();
  if (value) {
    set_has_opaque_type();
    _impl_.value_.opaque_type_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.opaque_type)
}
inline ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL TypeProto::_internal_mutable_opaque_type() {
  if (value_case() != kOpaqueType) {
    clear_value();
    set_has_opaque_type();
    _impl_.value_.opaque_type_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::onnx::TypeProto_Opaque>(GetArena()));
  }
  return reinterpret_cast<::onnx::TypeProto_Opaque*>(_impl_.value_.opaque_type_);
}
inline ::onnx::TypeProto_Opaque* PROTOBUF_NONNULL TypeProto::mutable_opaque_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::onnx::TypeProto_Opaque* _msg = _internal_mutable_opaque_type();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.opaque_type)
  return _msg;
}

// optional string denotation = 6;
inline bool TypeProto::has_denotation() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void TypeProto::clear_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.denotation_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& TypeProto::denotation() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
  return _internal_denotation();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TypeProto::set_denotation(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.denotation_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
}
inline ::std::string* PROTOBUF_NONNULL TypeProto::mutable_denotation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_denotation();
  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
  return _s;
}
inline const ::std::string& TypeProto::_internal_denotation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.denotation_.Get();
}
inline void TypeProto::_internal_set_denotation(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.denotation_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TypeProto::_internal_mutable_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.denotation_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TypeProto::release_denotation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.denotation_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.denotation_.Set("", GetArena());
  }
  return released;
}
inline void TypeProto::set_allocated_denotation(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.denotation_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.denotation_.IsDefault()) {
    _impl_.denotation_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
}

inline bool TypeProto::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void TypeProto::clear_has_value() {
  _impl_._oneof_case_[0] = VALUE_NOT_SET;
}
inline TypeProto::ValueCase TypeProto::value_case() const {
  return TypeProto::ValueCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// OperatorSetIdProto

// optional string domain = 1;
inline bool OperatorSetIdProto::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void OperatorSetIdProto::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& OperatorSetIdProto::domain() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
  return _internal_domain();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OperatorSetIdProto::set_domain(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
}
inline ::std::string* PROTOBUF_NONNULL OperatorSetIdProto::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
  return _s;
}
inline const ::std::string& OperatorSetIdProto::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.domain_.Get();
}
inline void OperatorSetIdProto::_internal_set_domain(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OperatorSetIdProto::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.domain_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OperatorSetIdProto::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.domain_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.domain_.Set("", GetArena());
  }
  return released;
}
inline void OperatorSetIdProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.domain_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
    _impl_.domain_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
}

// optional int64 version = 2;
inline bool OperatorSetIdProto::has_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void OperatorSetIdProto::clear_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::int64_t OperatorSetIdProto::version() const {
  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
  return _internal_version();
}
inline void OperatorSetIdProto::set_version(::int64_t value) {
  _internal_set_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
}
inline ::int64_t OperatorSetIdProto::_internal_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.version_;
}
inline void OperatorSetIdProto::_internal_set_version(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = value;
}

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

// FunctionProto

// optional string name = 1;
inline bool FunctionProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void FunctionProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
inline const ::std::string& FunctionProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void FunctionProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
  return _s;
}
inline const ::std::string& FunctionProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void FunctionProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void FunctionProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
}

// repeated string input = 4;
inline int FunctionProto::_internal_input_size() const {
  return _internal_input().size();
}
inline int FunctionProto::input_size() const {
  return _internal_input_size();
}
inline void FunctionProto::clear_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_input()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
  return _s;
}
inline const ::std::string& FunctionProto::input(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
  return _internal_input().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_input(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
  return _internal_mutable_input()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::set_input(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_input()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::add_input(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_input(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::input()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
  return _internal_input();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_input();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
FunctionProto::_internal_input() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_input() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.input_;
}

// repeated string output = 5;
inline int FunctionProto::_internal_output_size() const {
  return _internal_output().size();
}
inline int FunctionProto::output_size() const {
  return _internal_output_size();
}
inline void FunctionProto::clear_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_output()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
  return _s;
}
inline const ::std::string& FunctionProto::output(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
  return _internal_output().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_output(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
  return _internal_mutable_output()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::set_output(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_output()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::add_output(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_output(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::output()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
  return _internal_output();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_output();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
FunctionProto::_internal_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_output() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.output_;
}

// repeated string attribute = 6;
inline int FunctionProto::_internal_attribute_size() const {
  return _internal_attribute().size();
}
inline int FunctionProto::attribute_size() const {
  return _internal_attribute_size();
}
inline void FunctionProto::clear_attribute() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.attribute_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::add_attribute()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_attribute()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
  return _s;
}
inline const ::std::string& FunctionProto::attribute(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
  return _internal_attribute().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_attribute(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
  return _internal_mutable_attribute()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::set_attribute(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_attribute()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
}
template <typename Arg_, typename... Args_>
inline void FunctionProto::add_attribute(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_attribute(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& FunctionProto::attribute()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
  return _internal_attribute();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::mutable_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_attribute();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
FunctionProto::_internal_attribute() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.attribute_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_attribute() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.attribute_;
}

// repeated .onnx.AttributeProto attribute_proto = 11;
inline int FunctionProto::_internal_attribute_proto_size() const {
  return _internal_attribute_proto().size();
}
inline int FunctionProto::attribute_proto_size() const {
  return _internal_attribute_proto_size();
}
inline void FunctionProto::clear_attribute_proto() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.attribute_proto_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000020U);
}
inline ::onnx::AttributeProto* PROTOBUF_NONNULL FunctionProto::mutable_attribute_proto(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
  return _internal_mutable_attribute_proto()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL FunctionProto::mutable_attribute_proto()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_attribute_proto();
}
inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
  return _internal_attribute_proto().Get(index);
}
inline ::onnx::AttributeProto* PROTOBUF_NONNULL FunctionProto::add_attribute_proto()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::AttributeProto* _add =
      _internal_mutable_attribute_proto()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>& FunctionProto::attribute_proto() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
  return _internal_attribute_proto();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>&
FunctionProto::_internal_attribute_proto() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.attribute_proto_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::AttributeProto>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_attribute_proto() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.attribute_proto_;
}

// repeated .onnx.NodeProto node = 7;
inline int FunctionProto::_internal_node_size() const {
  return _internal_node().size();
}
inline int FunctionProto::node_size() const {
  return _internal_node_size();
}
inline void FunctionProto::clear_node() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::onnx::NodeProto* PROTOBUF_NONNULL FunctionProto::mutable_node(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
  return _internal_mutable_node()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL FunctionProto::mutable_node()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_node();
}
inline const ::onnx::NodeProto& FunctionProto::node(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
  return _internal_node().Get(index);
}
inline ::onnx::NodeProto* PROTOBUF_NONNULL FunctionProto::add_node()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::NodeProto* _add =
      _internal_mutable_node()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>& FunctionProto::node() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
  return _internal_node();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>&
FunctionProto::_internal_node() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::NodeProto>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_node() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.node_;
}

// optional string doc_string = 8;
inline bool FunctionProto::has_doc_string() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void FunctionProto::clear_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
inline const ::std::string& FunctionProto::doc_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
  return _internal_doc_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void FunctionProto::set_doc_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_doc_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
  return _s;
}
inline const ::std::string& FunctionProto::_internal_doc_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.doc_string_.Get();
}
inline void FunctionProto::_internal_set_doc_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.doc_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.doc_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_doc_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.doc_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  return released;
}
inline void FunctionProto::set_allocated_doc_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.doc_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.doc_string_.IsDefault()) {
    _impl_.doc_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
}

// repeated .onnx.OperatorSetIdProto opset_import = 9;
inline int FunctionProto::_internal_opset_import_size() const {
  return _internal_opset_import().size();
}
inline int FunctionProto::opset_import_size() const {
  return _internal_opset_import_size();
}
inline void FunctionProto::clear_opset_import() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.opset_import_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL FunctionProto::mutable_opset_import(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
  return _internal_mutable_opset_import()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL FunctionProto::mutable_opset_import()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_opset_import();
}
inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
  return _internal_opset_import().Get(index);
}
inline ::onnx::OperatorSetIdProto* PROTOBUF_NONNULL FunctionProto::add_opset_import()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::OperatorSetIdProto* _add =
      _internal_mutable_opset_import()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>& FunctionProto::opset_import() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
  return _internal_opset_import();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>&
FunctionProto::_internal_opset_import() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.opset_import_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorSetIdProto>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_opset_import() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.opset_import_;
}

// optional string domain = 10;
inline bool FunctionProto::has_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void FunctionProto::clear_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
inline const ::std::string& FunctionProto::domain() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
  return _internal_domain();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void FunctionProto::set_domain(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_domain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
  return _s;
}
inline const ::std::string& FunctionProto::_internal_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.domain_.Get();
}
inline void FunctionProto::_internal_set_domain(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.domain_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.domain_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.domain_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.domain_.Set("", GetArena());
  }
  return released;
}
inline void FunctionProto::set_allocated_domain(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  _impl_.domain_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.domain_.IsDefault()) {
    _impl_.domain_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
}

// optional string overload = 13;
inline bool FunctionProto::has_overload() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void FunctionProto::clear_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.overload_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000800U);
}
inline const ::std::string& FunctionProto::overload() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload)
  return _internal_overload();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void FunctionProto::set_overload(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  _impl_.overload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload)
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::mutable_overload()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::std::string* _s = _internal_mutable_overload();
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload)
  return _s;
}
inline const ::std::string& FunctionProto::_internal_overload() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.overload_.Get();
}
inline void FunctionProto::_internal_set_overload(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.overload_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL FunctionProto::_internal_mutable_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.overload_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE FunctionProto::release_overload() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  auto* released = _impl_.overload_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.overload_.Set("", GetArena());
  }
  return released;
}
inline void FunctionProto::set_allocated_overload(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  _impl_.overload_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.overload_.IsDefault()) {
    _impl_.overload_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload)
}

// repeated .onnx.ValueInfoProto value_info = 12;
inline int FunctionProto::_internal_value_info_size() const {
  return _internal_value_info().size();
}
inline int FunctionProto::value_info_size() const {
  return _internal_value_info_size();
}
inline void FunctionProto::clear_value_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_info_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL FunctionProto::mutable_value_info(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info)
  return _internal_mutable_value_info()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL FunctionProto::mutable_value_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_value_info();
}
inline const ::onnx::ValueInfoProto& FunctionProto::value_info(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info)
  return _internal_value_info().Get(index);
}
inline ::onnx::ValueInfoProto* PROTOBUF_NONNULL FunctionProto::add_value_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::ValueInfoProto* _add =
      _internal_mutable_value_info()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>& FunctionProto::value_info() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info)
  return _internal_value_info();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>&
FunctionProto::_internal_value_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_info_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::ValueInfoProto>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_value_info() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.value_info_;
}

// repeated .onnx.StringStringEntryProto metadata_props = 14;
inline int FunctionProto::_internal_metadata_props_size() const {
  return _internal_metadata_props().size();
}
inline int FunctionProto::metadata_props_size() const {
  return _internal_metadata_props_size();
}
inline void FunctionProto::clear_metadata_props() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.metadata_props_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000080U);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL FunctionProto::mutable_metadata_props(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props)
  return _internal_mutable_metadata_props()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL FunctionProto::mutable_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_metadata_props();
}
inline const ::onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props)
  return _internal_metadata_props().Get(index);
}
inline ::onnx::StringStringEntryProto* PROTOBUF_NONNULL FunctionProto::add_metadata_props()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::onnx::StringStringEntryProto* _add =
      _internal_mutable_metadata_props()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>& FunctionProto::metadata_props() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props)
  return _internal_metadata_props();
}
inline const ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>&
FunctionProto::_internal_metadata_props() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.metadata_props_;
}
inline ::google::protobuf::RepeatedPtrField<::onnx::StringStringEntryProto>* PROTOBUF_NONNULL
FunctionProto::_internal_mutable_metadata_props() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.metadata_props_;
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace onnx


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::onnx::AttributeProto_AttributeType> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::AttributeProto_AttributeType>() {
  return ::onnx::AttributeProto_AttributeType_descriptor();
}
template <>
struct is_proto_enum<::onnx::TensorProto_DataType> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::TensorProto_DataType>() {
  return ::onnx::TensorProto_DataType_descriptor();
}
template <>
struct is_proto_enum<::onnx::TensorProto_DataLocation> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::TensorProto_DataLocation>() {
  return ::onnx::TensorProto_DataLocation_descriptor();
}
template <>
struct is_proto_enum<::onnx::Version> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::Version>() {
  return ::onnx::Version_descriptor();
}
template <>
struct is_proto_enum<::onnx::OperatorStatus> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::onnx::OperatorStatus>() {
  return ::onnx::OperatorStatus_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // onnx_2fonnx_2dml_2eproto_2epb_2eh
