// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: onnx/onnx_onnx_torch-ml.proto

#ifndef PROTOBUF_INCLUDED_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto
#define PROTOBUF_INCLUDED_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto ONNX_API

namespace protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto {
// Internal implementation detail -- do not use these members.
struct ONNX_API TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[18];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void ONNX_API AddDescriptors();
}  // namespace protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto
namespace onnx_torch { const ::std::string& GetEmptyStringAlreadyInited(); 
class AttributeProto;
class AttributeProtoDefaultTypeInternal;
ONNX_API extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
class GraphProto;
class GraphProtoDefaultTypeInternal;
ONNX_API extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
class ModelProto;
class ModelProtoDefaultTypeInternal;
ONNX_API extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
class NodeProto;
class NodeProtoDefaultTypeInternal;
ONNX_API extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
class OperatorSetIdProto;
class OperatorSetIdProtoDefaultTypeInternal;
ONNX_API extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
class StringStringEntryProto;
class StringStringEntryProtoDefaultTypeInternal;
ONNX_API extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
class TensorAnnotation;
class TensorAnnotationDefaultTypeInternal;
ONNX_API extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
class TensorProto;
class TensorProtoDefaultTypeInternal;
ONNX_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
class TensorProto_Segment;
class TensorProto_SegmentDefaultTypeInternal;
ONNX_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
class TensorShapeProto;
class TensorShapeProtoDefaultTypeInternal;
ONNX_API extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
class TensorShapeProto_Dimension;
class TensorShapeProto_DimensionDefaultTypeInternal;
ONNX_API extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
class TypeProto;
class TypeProtoDefaultTypeInternal;
ONNX_API extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
class TypeProto_Map;
class TypeProto_MapDefaultTypeInternal;
ONNX_API extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
class TypeProto_Opaque;
class TypeProto_OpaqueDefaultTypeInternal;
ONNX_API extern TypeProto_OpaqueDefaultTypeInternal _TypeProto_Opaque_default_instance_;
class TypeProto_Sequence;
class TypeProto_SequenceDefaultTypeInternal;
ONNX_API extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
class TypeProto_SparseTensor;
class TypeProto_SparseTensorDefaultTypeInternal;
ONNX_API extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
class TypeProto_Tensor;
class TypeProto_TensorDefaultTypeInternal;
ONNX_API extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
class ValueInfoProto;
class ValueInfoProtoDefaultTypeInternal;
ONNX_API extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
}  // namespace onnx_torch
namespace google {
namespace protobuf {
template<> ONNX_API ::onnx_torch::AttributeProto* Arena::CreateMaybeMessage<::onnx_torch::AttributeProto>(Arena*);
template<> ONNX_API ::onnx_torch::GraphProto* Arena::CreateMaybeMessage<::onnx_torch::GraphProto>(Arena*);
template<> ONNX_API ::onnx_torch::ModelProto* Arena::CreateMaybeMessage<::onnx_torch::ModelProto>(Arena*);
template<> ONNX_API ::onnx_torch::NodeProto* Arena::CreateMaybeMessage<::onnx_torch::NodeProto>(Arena*);
template<> ONNX_API ::onnx_torch::OperatorSetIdProto* Arena::CreateMaybeMessage<::onnx_torch::OperatorSetIdProto>(Arena*);
template<> ONNX_API ::onnx_torch::StringStringEntryProto* Arena::CreateMaybeMessage<::onnx_torch::StringStringEntryProto>(Arena*);
template<> ONNX_API ::onnx_torch::TensorAnnotation* Arena::CreateMaybeMessage<::onnx_torch::TensorAnnotation>(Arena*);
template<> ONNX_API ::onnx_torch::TensorProto* Arena::CreateMaybeMessage<::onnx_torch::TensorProto>(Arena*);
template<> ONNX_API ::onnx_torch::TensorProto_Segment* Arena::CreateMaybeMessage<::onnx_torch::TensorProto_Segment>(Arena*);
template<> ONNX_API ::onnx_torch::TensorShapeProto* Arena::CreateMaybeMessage<::onnx_torch::TensorShapeProto>(Arena*);
template<> ONNX_API ::onnx_torch::TensorShapeProto_Dimension* Arena::CreateMaybeMessage<::onnx_torch::TensorShapeProto_Dimension>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto* Arena::CreateMaybeMessage<::onnx_torch::TypeProto>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto_Map* Arena::CreateMaybeMessage<::onnx_torch::TypeProto_Map>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto_Opaque* Arena::CreateMaybeMessage<::onnx_torch::TypeProto_Opaque>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto_Sequence* Arena::CreateMaybeMessage<::onnx_torch::TypeProto_Sequence>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto_SparseTensor* Arena::CreateMaybeMessage<::onnx_torch::TypeProto_SparseTensor>(Arena*);
template<> ONNX_API ::onnx_torch::TypeProto_Tensor* Arena::CreateMaybeMessage<::onnx_torch::TypeProto_Tensor>(Arena*);
template<> ONNX_API ::onnx_torch::ValueInfoProto* Arena::CreateMaybeMessage<::onnx_torch::ValueInfoProto>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace onnx_torch {

enum AttributeProto_AttributeType {
  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_FLOATS = 6,
  AttributeProto_AttributeType_INTS = 7,
  AttributeProto_AttributeType_STRINGS = 8,
  AttributeProto_AttributeType_TENSORS = 9,
  AttributeProto_AttributeType_GRAPHS = 10
};
ONNX_API bool AttributeProto_AttributeType_IsValid(int value);
const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_GRAPHS;
const int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;

ONNX_API const ::google::protobuf::EnumDescriptor* AttributeProto_AttributeType_descriptor();
inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
  return ::google::protobuf::internal::NameOfEnum(
    AttributeProto_AttributeType_descriptor(), value);
}
inline bool AttributeProto_AttributeType_Parse(
    const ::std::string& name, AttributeProto_AttributeType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(
    AttributeProto_AttributeType_descriptor(), name, value);
}
enum TensorProto_DataType {
  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
};
ONNX_API bool TensorProto_DataType_IsValid(int value);
const TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
const TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_BFLOAT16;
const int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;

ONNX_API const ::google::protobuf::EnumDescriptor* TensorProto_DataType_descriptor();
inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
  return ::google::protobuf::internal::NameOfEnum(
    TensorProto_DataType_descriptor(), value);
}
inline bool TensorProto_DataType_Parse(
    const ::std::string& name, TensorProto_DataType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
    TensorProto_DataType_descriptor(), name, value);
}
enum TensorProto_DataLocation {
  TensorProto_DataLocation_DEFAULT = 0,
  TensorProto_DataLocation_EXTERNAL = 1
};
ONNX_API bool TensorProto_DataLocation_IsValid(int value);
const TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = TensorProto_DataLocation_DEFAULT;
const TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = TensorProto_DataLocation_EXTERNAL;
const int TensorProto_DataLocation_DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_MAX + 1;

ONNX_API const ::google::protobuf::EnumDescriptor* TensorProto_DataLocation_descriptor();
inline const ::std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value) {
  return ::google::protobuf::internal::NameOfEnum(
    TensorProto_DataLocation_descriptor(), value);
}
inline bool TensorProto_DataLocation_Parse(
    const ::std::string& name, TensorProto_DataLocation* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataLocation>(
    TensorProto_DataLocation_descriptor(), name, value);
}
enum Version {
  _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 = 5
};
ONNX_API bool Version_IsValid(int value);
const Version Version_MIN = _START_VERSION;
const Version Version_MAX = IR_VERSION;
const int Version_ARRAYSIZE = Version_MAX + 1;

ONNX_API const ::google::protobuf::EnumDescriptor* Version_descriptor();
inline const ::std::string& Version_Name(Version value) {
  return ::google::protobuf::internal::NameOfEnum(
    Version_descriptor(), value);
}
inline bool Version_Parse(
    const ::std::string& name, Version* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Version>(
    Version_descriptor(), name, value);
}
// ===================================================================

class ONNX_API AttributeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.AttributeProto) */ {
 public:
  AttributeProto();
  virtual ~AttributeProto();

  AttributeProto(const AttributeProto& from);

  inline AttributeProto& operator=(const AttributeProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AttributeProto(AttributeProto&& from) noexcept;

  inline AttributeProto& operator=(AttributeProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AttributeProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AttributeProto* internal_default_instance() {
    return reinterpret_cast<const AttributeProto*>(
               &_AttributeProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    0;

  void Swap(AttributeProto* other);
  friend void swap(AttributeProto& a, AttributeProto& b) {
    a.Swap(&b);
  }

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

  inline AttributeProto* New() const final {
    return CreateMaybeMessage<AttributeProto>(NULL);
  }

  AttributeProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<AttributeProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const AttributeProto& from);
  void MergeFrom(const AttributeProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AttributeProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef AttributeProto_AttributeType AttributeType;
  static const AttributeType UNDEFINED =
    AttributeProto_AttributeType_UNDEFINED;
  static const AttributeType FLOAT =
    AttributeProto_AttributeType_FLOAT;
  static const AttributeType INT =
    AttributeProto_AttributeType_INT;
  static const AttributeType STRING =
    AttributeProto_AttributeType_STRING;
  static const AttributeType TENSOR =
    AttributeProto_AttributeType_TENSOR;
  static const AttributeType GRAPH =
    AttributeProto_AttributeType_GRAPH;
  static const AttributeType FLOATS =
    AttributeProto_AttributeType_FLOATS;
  static const AttributeType INTS =
    AttributeProto_AttributeType_INTS;
  static const AttributeType STRINGS =
    AttributeProto_AttributeType_STRINGS;
  static const AttributeType TENSORS =
    AttributeProto_AttributeType_TENSORS;
  static const AttributeType GRAPHS =
    AttributeProto_AttributeType_GRAPHS;
  static inline bool AttributeType_IsValid(int value) {
    return AttributeProto_AttributeType_IsValid(value);
  }
  static const AttributeType AttributeType_MIN =
    AttributeProto_AttributeType_AttributeType_MIN;
  static const AttributeType AttributeType_MAX =
    AttributeProto_AttributeType_AttributeType_MAX;
  static const int AttributeType_ARRAYSIZE =
    AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  AttributeType_descriptor() {
    return AttributeProto_AttributeType_descriptor();
  }
  static inline const ::std::string& AttributeType_Name(AttributeType value) {
    return AttributeProto_AttributeType_Name(value);
  }
  static inline bool AttributeType_Parse(const ::std::string& name,
      AttributeType* value) {
    return AttributeProto_AttributeType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated float floats = 7;
  int floats_size() const;
  void clear_floats();
  static const int kFloatsFieldNumber = 7;
  float floats(int index) const;
  void set_floats(int index, float value);
  void add_floats(float value);
  const ::google::protobuf::RepeatedField< float >&
      floats() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_floats();

  // repeated int64 ints = 8;
  int ints_size() const;
  void clear_ints();
  static const int kIntsFieldNumber = 8;
  ::google::protobuf::int64 ints(int index) const;
  void set_ints(int index, ::google::protobuf::int64 value);
  void add_ints(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      ints() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_ints();

  // repeated bytes strings = 9;
  int strings_size() const;
  void clear_strings();
  static const int kStringsFieldNumber = 9;
  const ::std::string& strings(int index) const;
  ::std::string* mutable_strings(int index);
  void set_strings(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_strings(int index, ::std::string&& value);
  #endif
  void set_strings(int index, const char* value);
  void set_strings(int index, const void* value, size_t size);
  ::std::string* add_strings();
  void add_strings(const ::std::string& value);
  #if LANG_CXX11
  void add_strings(::std::string&& value);
  #endif
  void add_strings(const char* value);
  void add_strings(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings();

  // repeated .onnx_torch.TensorProto tensors = 10;
  int tensors_size() const;
  void clear_tensors();
  static const int kTensorsFieldNumber = 10;
  ::onnx_torch::TensorProto* mutable_tensors(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >*
      mutable_tensors();
  const ::onnx_torch::TensorProto& tensors(int index) const;
  ::onnx_torch::TensorProto* add_tensors();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >&
      tensors() const;

  // repeated .onnx_torch.GraphProto graphs = 11;
  int graphs_size() const;
  void clear_graphs();
  static const int kGraphsFieldNumber = 11;
  ::onnx_torch::GraphProto* mutable_graphs(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::GraphProto >*
      mutable_graphs();
  const ::onnx_torch::GraphProto& graphs(int index) const;
  ::onnx_torch::GraphProto* add_graphs();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::GraphProto >&
      graphs() const;

  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional bytes s = 4;
  bool has_s() const;
  void clear_s();
  static const int kSFieldNumber = 4;
  const ::std::string& s() const;
  void set_s(const ::std::string& value);
  #if LANG_CXX11
  void set_s(::std::string&& value);
  #endif
  void set_s(const char* value);
  void set_s(const void* value, size_t size);
  ::std::string* mutable_s();
  ::std::string* release_s();
  void set_allocated_s(::std::string* s);

  // optional string doc_string = 13;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 13;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // optional string ref_attr_name = 21;
  bool has_ref_attr_name() const;
  void clear_ref_attr_name();
  static const int kRefAttrNameFieldNumber = 21;
  const ::std::string& ref_attr_name() const;
  void set_ref_attr_name(const ::std::string& value);
  #if LANG_CXX11
  void set_ref_attr_name(::std::string&& value);
  #endif
  void set_ref_attr_name(const char* value);
  void set_ref_attr_name(const char* value, size_t size);
  ::std::string* mutable_ref_attr_name();
  ::std::string* release_ref_attr_name();
  void set_allocated_ref_attr_name(::std::string* ref_attr_name);

  // optional .onnx_torch.TensorProto t = 5;
  bool has_t() const;
  void clear_t();
  static const int kTFieldNumber = 5;
  private:
  const ::onnx_torch::TensorProto& _internal_t() const;
  public:
  const ::onnx_torch::TensorProto& t() const;
  ::onnx_torch::TensorProto* release_t();
  ::onnx_torch::TensorProto* mutable_t();
  void set_allocated_t(::onnx_torch::TensorProto* t);

  // optional .onnx_torch.GraphProto g = 6;
  bool has_g() const;
  void clear_g();
  static const int kGFieldNumber = 6;
  private:
  const ::onnx_torch::GraphProto& _internal_g() const;
  public:
  const ::onnx_torch::GraphProto& g() const;
  ::onnx_torch::GraphProto* release_g();
  ::onnx_torch::GraphProto* mutable_g();
  void set_allocated_g(::onnx_torch::GraphProto* g);

  // optional int64 i = 3;
  bool has_i() const;
  void clear_i();
  static const int kIFieldNumber = 3;
  ::google::protobuf::int64 i() const;
  void set_i(::google::protobuf::int64 value);

  // optional float f = 2;
  bool has_f() const;
  void clear_f();
  static const int kFFieldNumber = 2;
  float f() const;
  void set_f(float value);

  // optional .onnx_torch.AttributeProto.AttributeType type = 20;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 20;
  ::onnx_torch::AttributeProto_AttributeType type() const;
  void set_type(::onnx_torch::AttributeProto_AttributeType value);

  // @@protoc_insertion_point(class_scope:onnx_torch.AttributeProto)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_ref_attr_name();
  void clear_has_ref_attr_name();
  void set_has_doc_string();
  void clear_has_doc_string();
  void set_has_type();
  void clear_has_type();
  void set_has_f();
  void clear_has_f();
  void set_has_i();
  void clear_has_i();
  void set_has_s();
  void clear_has_s();
  void set_has_t();
  void clear_has_t();
  void set_has_g();
  void clear_has_g();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< float > floats_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > ints_;
  ::google::protobuf::RepeatedPtrField< ::std::string> strings_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto > tensors_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::GraphProto > graphs_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr s_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
  ::onnx_torch::TensorProto* t_;
  ::onnx_torch::GraphProto* g_;
  ::google::protobuf::int64 i_;
  float f_;
  int type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API ValueInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.ValueInfoProto) */ {
 public:
  ValueInfoProto();
  virtual ~ValueInfoProto();

  ValueInfoProto(const ValueInfoProto& from);

  inline ValueInfoProto& operator=(const ValueInfoProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ValueInfoProto(ValueInfoProto&& from) noexcept;

  inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ValueInfoProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ValueInfoProto* internal_default_instance() {
    return reinterpret_cast<const ValueInfoProto*>(
               &_ValueInfoProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    1;

  void Swap(ValueInfoProto* other);
  friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
    a.Swap(&b);
  }

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

  inline ValueInfoProto* New() const final {
    return CreateMaybeMessage<ValueInfoProto>(NULL);
  }

  ValueInfoProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ValueInfoProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ValueInfoProto& from);
  void MergeFrom(const ValueInfoProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ValueInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional string doc_string = 3;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 3;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // optional .onnx_torch.TypeProto type = 2;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 2;
  private:
  const ::onnx_torch::TypeProto& _internal_type() const;
  public:
  const ::onnx_torch::TypeProto& type() const;
  ::onnx_torch::TypeProto* release_type();
  ::onnx_torch::TypeProto* mutable_type();
  void set_allocated_type(::onnx_torch::TypeProto* type);

  // @@protoc_insertion_point(class_scope:onnx_torch.ValueInfoProto)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_type();
  void clear_has_type();
  void set_has_doc_string();
  void clear_has_doc_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  ::onnx_torch::TypeProto* type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API NodeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.NodeProto) */ {
 public:
  NodeProto();
  virtual ~NodeProto();

  NodeProto(const NodeProto& from);

  inline NodeProto& operator=(const NodeProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NodeProto(NodeProto&& from) noexcept;

  inline NodeProto& operator=(NodeProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NodeProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NodeProto* internal_default_instance() {
    return reinterpret_cast<const NodeProto*>(
               &_NodeProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    2;

  void Swap(NodeProto* other);
  friend void swap(NodeProto& a, NodeProto& b) {
    a.Swap(&b);
  }

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

  inline NodeProto* New() const final {
    return CreateMaybeMessage<NodeProto>(NULL);
  }

  NodeProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NodeProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NodeProto& from);
  void MergeFrom(const NodeProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NodeProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated string input = 1;
  int input_size() const;
  void clear_input();
  static const int kInputFieldNumber = 1;
  const ::std::string& input(int index) const;
  ::std::string* mutable_input(int index);
  void set_input(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_input(int index, ::std::string&& value);
  #endif
  void set_input(int index, const char* value);
  void set_input(int index, const char* value, size_t size);
  ::std::string* add_input();
  void add_input(const ::std::string& value);
  #if LANG_CXX11
  void add_input(::std::string&& value);
  #endif
  void add_input(const char* value);
  void add_input(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();

  // repeated string output = 2;
  int output_size() const;
  void clear_output();
  static const int kOutputFieldNumber = 2;
  const ::std::string& output(int index) const;
  ::std::string* mutable_output(int index);
  void set_output(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_output(int index, ::std::string&& value);
  #endif
  void set_output(int index, const char* value);
  void set_output(int index, const char* value, size_t size);
  ::std::string* add_output();
  void add_output(const ::std::string& value);
  #if LANG_CXX11
  void add_output(::std::string&& value);
  #endif
  void add_output(const char* value);
  void add_output(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& output() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_output();

  // repeated .onnx_torch.AttributeProto attribute = 5;
  int attribute_size() const;
  void clear_attribute();
  static const int kAttributeFieldNumber = 5;
  ::onnx_torch::AttributeProto* mutable_attribute(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::AttributeProto >*
      mutable_attribute();
  const ::onnx_torch::AttributeProto& attribute(int index) const;
  ::onnx_torch::AttributeProto* add_attribute();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::AttributeProto >&
      attribute() const;

  // optional string name = 3;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 3;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional string op_type = 4;
  bool has_op_type() const;
  void clear_op_type();
  static const int kOpTypeFieldNumber = 4;
  const ::std::string& op_type() const;
  void set_op_type(const ::std::string& value);
  #if LANG_CXX11
  void set_op_type(::std::string&& value);
  #endif
  void set_op_type(const char* value);
  void set_op_type(const char* value, size_t size);
  ::std::string* mutable_op_type();
  ::std::string* release_op_type();
  void set_allocated_op_type(::std::string* op_type);

  // optional string doc_string = 6;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 6;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // optional string domain = 7;
  bool has_domain() const;
  void clear_domain();
  static const int kDomainFieldNumber = 7;
  const ::std::string& domain() const;
  void set_domain(const ::std::string& value);
  #if LANG_CXX11
  void set_domain(::std::string&& value);
  #endif
  void set_domain(const char* value);
  void set_domain(const char* value, size_t size);
  ::std::string* mutable_domain();
  ::std::string* release_domain();
  void set_allocated_domain(::std::string* domain);

  // @@protoc_insertion_point(class_scope:onnx_torch.NodeProto)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_op_type();
  void clear_has_op_type();
  void set_has_domain();
  void clear_has_domain();
  void set_has_doc_string();
  void clear_has_doc_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> input_;
  ::google::protobuf::RepeatedPtrField< ::std::string> output_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::AttributeProto > attribute_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr op_type_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  ::google::protobuf::internal::ArenaStringPtr domain_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API ModelProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.ModelProto) */ {
 public:
  ModelProto();
  virtual ~ModelProto();

  ModelProto(const ModelProto& from);

  inline ModelProto& operator=(const ModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ModelProto(ModelProto&& from) noexcept;

  inline ModelProto& operator=(ModelProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ModelProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ModelProto* internal_default_instance() {
    return reinterpret_cast<const ModelProto*>(
               &_ModelProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    3;

  void Swap(ModelProto* other);
  friend void swap(ModelProto& a, ModelProto& b) {
    a.Swap(&b);
  }

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

  inline ModelProto* New() const final {
    return CreateMaybeMessage<ModelProto>(NULL);
  }

  ModelProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ModelProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ModelProto& from);
  void MergeFrom(const ModelProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ModelProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .onnx_torch.OperatorSetIdProto opset_import = 8;
  int opset_import_size() const;
  void clear_opset_import();
  static const int kOpsetImportFieldNumber = 8;
  ::onnx_torch::OperatorSetIdProto* mutable_opset_import(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::OperatorSetIdProto >*
      mutable_opset_import();
  const ::onnx_torch::OperatorSetIdProto& opset_import(int index) const;
  ::onnx_torch::OperatorSetIdProto* add_opset_import();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::OperatorSetIdProto >&
      opset_import() const;

  // repeated .onnx_torch.StringStringEntryProto metadata_props = 14;
  int metadata_props_size() const;
  void clear_metadata_props();
  static const int kMetadataPropsFieldNumber = 14;
  ::onnx_torch::StringStringEntryProto* mutable_metadata_props(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
      mutable_metadata_props();
  const ::onnx_torch::StringStringEntryProto& metadata_props(int index) const;
  ::onnx_torch::StringStringEntryProto* add_metadata_props();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
      metadata_props() const;

  // optional string producer_name = 2;
  bool has_producer_name() const;
  void clear_producer_name();
  static const int kProducerNameFieldNumber = 2;
  const ::std::string& producer_name() const;
  void set_producer_name(const ::std::string& value);
  #if LANG_CXX11
  void set_producer_name(::std::string&& value);
  #endif
  void set_producer_name(const char* value);
  void set_producer_name(const char* value, size_t size);
  ::std::string* mutable_producer_name();
  ::std::string* release_producer_name();
  void set_allocated_producer_name(::std::string* producer_name);

  // optional string producer_version = 3;
  bool has_producer_version() const;
  void clear_producer_version();
  static const int kProducerVersionFieldNumber = 3;
  const ::std::string& producer_version() const;
  void set_producer_version(const ::std::string& value);
  #if LANG_CXX11
  void set_producer_version(::std::string&& value);
  #endif
  void set_producer_version(const char* value);
  void set_producer_version(const char* value, size_t size);
  ::std::string* mutable_producer_version();
  ::std::string* release_producer_version();
  void set_allocated_producer_version(::std::string* producer_version);

  // optional string domain = 4;
  bool has_domain() const;
  void clear_domain();
  static const int kDomainFieldNumber = 4;
  const ::std::string& domain() const;
  void set_domain(const ::std::string& value);
  #if LANG_CXX11
  void set_domain(::std::string&& value);
  #endif
  void set_domain(const char* value);
  void set_domain(const char* value, size_t size);
  ::std::string* mutable_domain();
  ::std::string* release_domain();
  void set_allocated_domain(::std::string* domain);

  // optional string doc_string = 6;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 6;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // optional .onnx_torch.GraphProto graph = 7;
  bool has_graph() const;
  void clear_graph();
  static const int kGraphFieldNumber = 7;
  private:
  const ::onnx_torch::GraphProto& _internal_graph() const;
  public:
  const ::onnx_torch::GraphProto& graph() const;
  ::onnx_torch::GraphProto* release_graph();
  ::onnx_torch::GraphProto* mutable_graph();
  void set_allocated_graph(::onnx_torch::GraphProto* graph);

  // optional int64 ir_version = 1;
  bool has_ir_version() const;
  void clear_ir_version();
  static const int kIrVersionFieldNumber = 1;
  ::google::protobuf::int64 ir_version() const;
  void set_ir_version(::google::protobuf::int64 value);

  // optional int64 model_version = 5;
  bool has_model_version() const;
  void clear_model_version();
  static const int kModelVersionFieldNumber = 5;
  ::google::protobuf::int64 model_version() const;
  void set_model_version(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.ModelProto)
 private:
  void set_has_ir_version();
  void clear_has_ir_version();
  void set_has_producer_name();
  void clear_has_producer_name();
  void set_has_producer_version();
  void clear_has_producer_version();
  void set_has_domain();
  void clear_has_domain();
  void set_has_model_version();
  void clear_has_model_version();
  void set_has_doc_string();
  void clear_has_doc_string();
  void set_has_graph();
  void clear_has_graph();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::OperatorSetIdProto > opset_import_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto > metadata_props_;
  ::google::protobuf::internal::ArenaStringPtr producer_name_;
  ::google::protobuf::internal::ArenaStringPtr producer_version_;
  ::google::protobuf::internal::ArenaStringPtr domain_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  ::onnx_torch::GraphProto* graph_;
  ::google::protobuf::int64 ir_version_;
  ::google::protobuf::int64 model_version_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API StringStringEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.StringStringEntryProto) */ {
 public:
  StringStringEntryProto();
  virtual ~StringStringEntryProto();

  StringStringEntryProto(const StringStringEntryProto& from);

  inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StringStringEntryProto(StringStringEntryProto&& from) noexcept;

  inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StringStringEntryProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StringStringEntryProto* internal_default_instance() {
    return reinterpret_cast<const StringStringEntryProto*>(
               &_StringStringEntryProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    4;

  void Swap(StringStringEntryProto* other);
  friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
    a.Swap(&b);
  }

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

  inline StringStringEntryProto* New() const final {
    return CreateMaybeMessage<StringStringEntryProto>(NULL);
  }

  StringStringEntryProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StringStringEntryProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StringStringEntryProto& from);
  void MergeFrom(const StringStringEntryProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringStringEntryProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string key = 1;
  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // optional string value = 2;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:onnx_torch.StringStringEntryProto)
 private:
  void set_has_key();
  void clear_has_key();
  void set_has_value();
  void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TensorAnnotation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TensorAnnotation) */ {
 public:
  TensorAnnotation();
  virtual ~TensorAnnotation();

  TensorAnnotation(const TensorAnnotation& from);

  inline TensorAnnotation& operator=(const TensorAnnotation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TensorAnnotation(TensorAnnotation&& from) noexcept;

  inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorAnnotation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorAnnotation* internal_default_instance() {
    return reinterpret_cast<const TensorAnnotation*>(
               &_TensorAnnotation_default_instance_);
  }
  static int const kIndexInFileMessages =
    5;

  void Swap(TensorAnnotation* other);
  friend void swap(TensorAnnotation& a, TensorAnnotation& b) {
    a.Swap(&b);
  }

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

  inline TensorAnnotation* New() const final {
    return CreateMaybeMessage<TensorAnnotation>(NULL);
  }

  TensorAnnotation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorAnnotation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorAnnotation& from);
  void MergeFrom(const TensorAnnotation& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorAnnotation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .onnx_torch.StringStringEntryProto quant_parameter_tensor_names = 2;
  int quant_parameter_tensor_names_size() const;
  void clear_quant_parameter_tensor_names();
  static const int kQuantParameterTensorNamesFieldNumber = 2;
  ::onnx_torch::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
      mutable_quant_parameter_tensor_names();
  const ::onnx_torch::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
  ::onnx_torch::StringStringEntryProto* add_quant_parameter_tensor_names();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
      quant_parameter_tensor_names() const;

  // optional string tensor_name = 1;
  bool has_tensor_name() const;
  void clear_tensor_name();
  static const int kTensorNameFieldNumber = 1;
  const ::std::string& tensor_name() const;
  void set_tensor_name(const ::std::string& value);
  #if LANG_CXX11
  void set_tensor_name(::std::string&& value);
  #endif
  void set_tensor_name(const char* value);
  void set_tensor_name(const char* value, size_t size);
  ::std::string* mutable_tensor_name();
  ::std::string* release_tensor_name();
  void set_allocated_tensor_name(::std::string* tensor_name);

  // @@protoc_insertion_point(class_scope:onnx_torch.TensorAnnotation)
 private:
  void set_has_tensor_name();
  void clear_has_tensor_name();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto > quant_parameter_tensor_names_;
  ::google::protobuf::internal::ArenaStringPtr tensor_name_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API GraphProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.GraphProto) */ {
 public:
  GraphProto();
  virtual ~GraphProto();

  GraphProto(const GraphProto& from);

  inline GraphProto& operator=(const GraphProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  GraphProto(GraphProto&& from) noexcept;

  inline GraphProto& operator=(GraphProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GraphProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GraphProto* internal_default_instance() {
    return reinterpret_cast<const GraphProto*>(
               &_GraphProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    6;

  void Swap(GraphProto* other);
  friend void swap(GraphProto& a, GraphProto& b) {
    a.Swap(&b);
  }

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

  inline GraphProto* New() const final {
    return CreateMaybeMessage<GraphProto>(NULL);
  }

  GraphProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GraphProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GraphProto& from);
  void MergeFrom(const GraphProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GraphProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .onnx_torch.NodeProto node = 1;
  int node_size() const;
  void clear_node();
  static const int kNodeFieldNumber = 1;
  ::onnx_torch::NodeProto* mutable_node(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::NodeProto >*
      mutable_node();
  const ::onnx_torch::NodeProto& node(int index) const;
  ::onnx_torch::NodeProto* add_node();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::NodeProto >&
      node() const;

  // repeated .onnx_torch.TensorProto initializer = 5;
  int initializer_size() const;
  void clear_initializer();
  static const int kInitializerFieldNumber = 5;
  ::onnx_torch::TensorProto* mutable_initializer(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >*
      mutable_initializer();
  const ::onnx_torch::TensorProto& initializer(int index) const;
  ::onnx_torch::TensorProto* add_initializer();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >&
      initializer() const;

  // repeated .onnx_torch.ValueInfoProto input = 11;
  int input_size() const;
  void clear_input();
  static const int kInputFieldNumber = 11;
  ::onnx_torch::ValueInfoProto* mutable_input(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
      mutable_input();
  const ::onnx_torch::ValueInfoProto& input(int index) const;
  ::onnx_torch::ValueInfoProto* add_input();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
      input() const;

  // repeated .onnx_torch.ValueInfoProto output = 12;
  int output_size() const;
  void clear_output();
  static const int kOutputFieldNumber = 12;
  ::onnx_torch::ValueInfoProto* mutable_output(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
      mutable_output();
  const ::onnx_torch::ValueInfoProto& output(int index) const;
  ::onnx_torch::ValueInfoProto* add_output();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
      output() const;

  // repeated .onnx_torch.ValueInfoProto value_info = 13;
  int value_info_size() const;
  void clear_value_info();
  static const int kValueInfoFieldNumber = 13;
  ::onnx_torch::ValueInfoProto* mutable_value_info(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
      mutable_value_info();
  const ::onnx_torch::ValueInfoProto& value_info(int index) const;
  ::onnx_torch::ValueInfoProto* add_value_info();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
      value_info() const;

  // repeated .onnx_torch.TensorAnnotation quantization_annotation = 14;
  int quantization_annotation_size() const;
  void clear_quantization_annotation();
  static const int kQuantizationAnnotationFieldNumber = 14;
  ::onnx_torch::TensorAnnotation* mutable_quantization_annotation(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorAnnotation >*
      mutable_quantization_annotation();
  const ::onnx_torch::TensorAnnotation& quantization_annotation(int index) const;
  ::onnx_torch::TensorAnnotation* add_quantization_annotation();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorAnnotation >&
      quantization_annotation() const;

  // optional string name = 2;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional string doc_string = 10;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 10;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // @@protoc_insertion_point(class_scope:onnx_torch.GraphProto)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_doc_string();
  void clear_has_doc_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::NodeProto > node_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto > initializer_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto > input_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto > output_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto > value_info_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorAnnotation > quantization_annotation_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TensorProto_Segment : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TensorProto.Segment) */ {
 public:
  TensorProto_Segment();
  virtual ~TensorProto_Segment();

  TensorProto_Segment(const TensorProto_Segment& from);

  inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TensorProto_Segment(TensorProto_Segment&& from) noexcept;

  inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorProto_Segment& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorProto_Segment* internal_default_instance() {
    return reinterpret_cast<const TensorProto_Segment*>(
               &_TensorProto_Segment_default_instance_);
  }
  static int const kIndexInFileMessages =
    7;

  void Swap(TensorProto_Segment* other);
  friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
    a.Swap(&b);
  }

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

  inline TensorProto_Segment* New() const final {
    return CreateMaybeMessage<TensorProto_Segment>(NULL);
  }

  TensorProto_Segment* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorProto_Segment>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorProto_Segment& from);
  void MergeFrom(const TensorProto_Segment& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorProto_Segment* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int64 begin = 1;
  bool has_begin() const;
  void clear_begin();
  static const int kBeginFieldNumber = 1;
  ::google::protobuf::int64 begin() const;
  void set_begin(::google::protobuf::int64 value);

  // optional int64 end = 2;
  bool has_end() const;
  void clear_end();
  static const int kEndFieldNumber = 2;
  ::google::protobuf::int64 end() const;
  void set_end(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.TensorProto.Segment)
 private:
  void set_has_begin();
  void clear_has_begin();
  void set_has_end();
  void clear_has_end();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int64 begin_;
  ::google::protobuf::int64 end_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TensorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TensorProto) */ {
 public:
  TensorProto();
  virtual ~TensorProto();

  TensorProto(const TensorProto& from);

  inline TensorProto& operator=(const TensorProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TensorProto(TensorProto&& from) noexcept;

  inline TensorProto& operator=(TensorProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorProto* internal_default_instance() {
    return reinterpret_cast<const TensorProto*>(
               &_TensorProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    8;

  void Swap(TensorProto* other);
  friend void swap(TensorProto& a, TensorProto& b) {
    a.Swap(&b);
  }

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

  inline TensorProto* New() const final {
    return CreateMaybeMessage<TensorProto>(NULL);
  }

  TensorProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorProto& from);
  void MergeFrom(const TensorProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TensorProto_Segment Segment;

  typedef TensorProto_DataType DataType;
  static const DataType UNDEFINED =
    TensorProto_DataType_UNDEFINED;
  static const DataType FLOAT =
    TensorProto_DataType_FLOAT;
  static const DataType UINT8 =
    TensorProto_DataType_UINT8;
  static const DataType INT8 =
    TensorProto_DataType_INT8;
  static const DataType UINT16 =
    TensorProto_DataType_UINT16;
  static const DataType INT16 =
    TensorProto_DataType_INT16;
  static const DataType INT32 =
    TensorProto_DataType_INT32;
  static const DataType INT64 =
    TensorProto_DataType_INT64;
  static const DataType STRING =
    TensorProto_DataType_STRING;
  static const DataType BOOL =
    TensorProto_DataType_BOOL;
  static const DataType FLOAT16 =
    TensorProto_DataType_FLOAT16;
  static const DataType DOUBLE =
    TensorProto_DataType_DOUBLE;
  static const DataType UINT32 =
    TensorProto_DataType_UINT32;
  static const DataType UINT64 =
    TensorProto_DataType_UINT64;
  static const DataType COMPLEX64 =
    TensorProto_DataType_COMPLEX64;
  static const DataType COMPLEX128 =
    TensorProto_DataType_COMPLEX128;
  static const DataType BFLOAT16 =
    TensorProto_DataType_BFLOAT16;
  static inline bool DataType_IsValid(int value) {
    return TensorProto_DataType_IsValid(value);
  }
  static const DataType DataType_MIN =
    TensorProto_DataType_DataType_MIN;
  static const DataType DataType_MAX =
    TensorProto_DataType_DataType_MAX;
  static const int DataType_ARRAYSIZE =
    TensorProto_DataType_DataType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DataType_descriptor() {
    return TensorProto_DataType_descriptor();
  }
  static inline const ::std::string& DataType_Name(DataType value) {
    return TensorProto_DataType_Name(value);
  }
  static inline bool DataType_Parse(const ::std::string& name,
      DataType* value) {
    return TensorProto_DataType_Parse(name, value);
  }

  typedef TensorProto_DataLocation DataLocation;
  static const DataLocation DEFAULT =
    TensorProto_DataLocation_DEFAULT;
  static const DataLocation EXTERNAL =
    TensorProto_DataLocation_EXTERNAL;
  static inline bool DataLocation_IsValid(int value) {
    return TensorProto_DataLocation_IsValid(value);
  }
  static const DataLocation DataLocation_MIN =
    TensorProto_DataLocation_DataLocation_MIN;
  static const DataLocation DataLocation_MAX =
    TensorProto_DataLocation_DataLocation_MAX;
  static const int DataLocation_ARRAYSIZE =
    TensorProto_DataLocation_DataLocation_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DataLocation_descriptor() {
    return TensorProto_DataLocation_descriptor();
  }
  static inline const ::std::string& DataLocation_Name(DataLocation value) {
    return TensorProto_DataLocation_Name(value);
  }
  static inline bool DataLocation_Parse(const ::std::string& name,
      DataLocation* value) {
    return TensorProto_DataLocation_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated int64 dims = 1;
  int dims_size() const;
  void clear_dims();
  static const int kDimsFieldNumber = 1;
  ::google::protobuf::int64 dims(int index) const;
  void set_dims(int index, ::google::protobuf::int64 value);
  void add_dims(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      dims() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_dims();

  // repeated float float_data = 4 [packed = true];
  int float_data_size() const;
  void clear_float_data();
  static const int kFloatDataFieldNumber = 4;
  float float_data(int index) const;
  void set_float_data(int index, float value);
  void add_float_data(float value);
  const ::google::protobuf::RepeatedField< float >&
      float_data() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_float_data();

  // repeated int32 int32_data = 5 [packed = true];
  int int32_data_size() const;
  void clear_int32_data();
  static const int kInt32DataFieldNumber = 5;
  ::google::protobuf::int32 int32_data(int index) const;
  void set_int32_data(int index, ::google::protobuf::int32 value);
  void add_int32_data(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      int32_data() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_int32_data();

  // repeated bytes string_data = 6;
  int string_data_size() const;
  void clear_string_data();
  static const int kStringDataFieldNumber = 6;
  const ::std::string& string_data(int index) const;
  ::std::string* mutable_string_data(int index);
  void set_string_data(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_string_data(int index, ::std::string&& value);
  #endif
  void set_string_data(int index, const char* value);
  void set_string_data(int index, const void* value, size_t size);
  ::std::string* add_string_data();
  void add_string_data(const ::std::string& value);
  #if LANG_CXX11
  void add_string_data(::std::string&& value);
  #endif
  void add_string_data(const char* value);
  void add_string_data(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& string_data() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_data();

  // repeated int64 int64_data = 7 [packed = true];
  int int64_data_size() const;
  void clear_int64_data();
  static const int kInt64DataFieldNumber = 7;
  ::google::protobuf::int64 int64_data(int index) const;
  void set_int64_data(int index, ::google::protobuf::int64 value);
  void add_int64_data(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      int64_data() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_int64_data();

  // repeated double double_data = 10 [packed = true];
  int double_data_size() const;
  void clear_double_data();
  static const int kDoubleDataFieldNumber = 10;
  double double_data(int index) const;
  void set_double_data(int index, double value);
  void add_double_data(double value);
  const ::google::protobuf::RepeatedField< double >&
      double_data() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_double_data();

  // repeated uint64 uint64_data = 11 [packed = true];
  int uint64_data_size() const;
  void clear_uint64_data();
  static const int kUint64DataFieldNumber = 11;
  ::google::protobuf::uint64 uint64_data(int index) const;
  void set_uint64_data(int index, ::google::protobuf::uint64 value);
  void add_uint64_data(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      uint64_data() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_uint64_data();

  // repeated .onnx_torch.StringStringEntryProto external_data = 13;
  int external_data_size() const;
  void clear_external_data();
  static const int kExternalDataFieldNumber = 13;
  ::onnx_torch::StringStringEntryProto* mutable_external_data(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
      mutable_external_data();
  const ::onnx_torch::StringStringEntryProto& external_data(int index) const;
  ::onnx_torch::StringStringEntryProto* add_external_data();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
      external_data() const;

  // optional string name = 8;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 8;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional bytes raw_data = 9;
  bool has_raw_data() const;
  void clear_raw_data();
  static const int kRawDataFieldNumber = 9;
  const ::std::string& raw_data() const;
  void set_raw_data(const ::std::string& value);
  #if LANG_CXX11
  void set_raw_data(::std::string&& value);
  #endif
  void set_raw_data(const char* value);
  void set_raw_data(const void* value, size_t size);
  ::std::string* mutable_raw_data();
  ::std::string* release_raw_data();
  void set_allocated_raw_data(::std::string* raw_data);

  // optional string doc_string = 12;
  bool has_doc_string() const;
  void clear_doc_string();
  static const int kDocStringFieldNumber = 12;
  const ::std::string& doc_string() const;
  void set_doc_string(const ::std::string& value);
  #if LANG_CXX11
  void set_doc_string(::std::string&& value);
  #endif
  void set_doc_string(const char* value);
  void set_doc_string(const char* value, size_t size);
  ::std::string* mutable_doc_string();
  ::std::string* release_doc_string();
  void set_allocated_doc_string(::std::string* doc_string);

  // optional .onnx_torch.TensorProto.Segment segment = 3;
  bool has_segment() const;
  void clear_segment();
  static const int kSegmentFieldNumber = 3;
  private:
  const ::onnx_torch::TensorProto_Segment& _internal_segment() const;
  public:
  const ::onnx_torch::TensorProto_Segment& segment() const;
  ::onnx_torch::TensorProto_Segment* release_segment();
  ::onnx_torch::TensorProto_Segment* mutable_segment();
  void set_allocated_segment(::onnx_torch::TensorProto_Segment* segment);

  // optional int32 data_type = 2;
  bool has_data_type() const;
  void clear_data_type();
  static const int kDataTypeFieldNumber = 2;
  ::google::protobuf::int32 data_type() const;
  void set_data_type(::google::protobuf::int32 value);

  // optional .onnx_torch.TensorProto.DataLocation data_location = 14;
  bool has_data_location() const;
  void clear_data_location();
  static const int kDataLocationFieldNumber = 14;
  ::onnx_torch::TensorProto_DataLocation data_location() const;
  void set_data_location(::onnx_torch::TensorProto_DataLocation value);

  // @@protoc_insertion_point(class_scope:onnx_torch.TensorProto)
 private:
  void set_has_data_type();
  void clear_has_data_type();
  void set_has_segment();
  void clear_has_segment();
  void set_has_name();
  void clear_has_name();
  void set_has_doc_string();
  void clear_has_doc_string();
  void set_has_raw_data();
  void clear_has_raw_data();
  void set_has_data_location();
  void clear_has_data_location();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
  ::google::protobuf::RepeatedField< float > float_data_;
  mutable int _float_data_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > int32_data_;
  mutable int _int32_data_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> string_data_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_data_;
  mutable int _int64_data_cached_byte_size_;
  ::google::protobuf::RepeatedField< double > double_data_;
  mutable int _double_data_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > uint64_data_;
  mutable int _uint64_data_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto > external_data_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr raw_data_;
  ::google::protobuf::internal::ArenaStringPtr doc_string_;
  ::onnx_torch::TensorProto_Segment* segment_;
  ::google::protobuf::int32 data_type_;
  int data_location_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TensorShapeProto_Dimension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TensorShapeProto.Dimension) */ {
 public:
  TensorShapeProto_Dimension();
  virtual ~TensorShapeProto_Dimension();

  TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);

  inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept;

  inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorShapeProto_Dimension& default_instance();

  enum ValueCase {
    kDimValue = 1,
    kDimParam = 2,
    VALUE_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorShapeProto_Dimension* internal_default_instance() {
    return reinterpret_cast<const TensorShapeProto_Dimension*>(
               &_TensorShapeProto_Dimension_default_instance_);
  }
  static int const kIndexInFileMessages =
    9;

  void Swap(TensorShapeProto_Dimension* other);
  friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
    a.Swap(&b);
  }

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

  inline TensorShapeProto_Dimension* New() const final {
    return CreateMaybeMessage<TensorShapeProto_Dimension>(NULL);
  }

  TensorShapeProto_Dimension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorShapeProto_Dimension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorShapeProto_Dimension& from);
  void MergeFrom(const TensorShapeProto_Dimension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorShapeProto_Dimension* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string denotation = 3;
  bool has_denotation() const;
  void clear_denotation();
  static const int kDenotationFieldNumber = 3;
  const ::std::string& denotation() const;
  void set_denotation(const ::std::string& value);
  #if LANG_CXX11
  void set_denotation(::std::string&& value);
  #endif
  void set_denotation(const char* value);
  void set_denotation(const char* value, size_t size);
  ::std::string* mutable_denotation();
  ::std::string* release_denotation();
  void set_allocated_denotation(::std::string* denotation);

  // optional int64 dim_value = 1;
  bool has_dim_value() const;
  void clear_dim_value();
  static const int kDimValueFieldNumber = 1;
  ::google::protobuf::int64 dim_value() const;
  void set_dim_value(::google::protobuf::int64 value);

  // optional string dim_param = 2;
  bool has_dim_param() const;
  void clear_dim_param();
  static const int kDimParamFieldNumber = 2;
  const ::std::string& dim_param() const;
  void set_dim_param(const ::std::string& value);
  #if LANG_CXX11
  void set_dim_param(::std::string&& value);
  #endif
  void set_dim_param(const char* value);
  void set_dim_param(const char* value, size_t size);
  ::std::string* mutable_dim_param();
  ::std::string* release_dim_param();
  void set_allocated_dim_param(::std::string* dim_param);

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:onnx_torch.TensorShapeProto.Dimension)
 private:
  void set_has_dim_value();
  void set_has_dim_param();
  void set_has_denotation();
  void clear_has_denotation();

  inline bool has_value() const;
  inline void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr denotation_;
  union ValueUnion {
    ValueUnion() {}
    ::google::protobuf::int64 dim_value_;
    ::google::protobuf::internal::ArenaStringPtr dim_param_;
  } value_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TensorShapeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TensorShapeProto) */ {
 public:
  TensorShapeProto();
  virtual ~TensorShapeProto();

  TensorShapeProto(const TensorShapeProto& from);

  inline TensorShapeProto& operator=(const TensorShapeProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TensorShapeProto(TensorShapeProto&& from) noexcept;

  inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorShapeProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorShapeProto* internal_default_instance() {
    return reinterpret_cast<const TensorShapeProto*>(
               &_TensorShapeProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    10;

  void Swap(TensorShapeProto* other);
  friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
    a.Swap(&b);
  }

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

  inline TensorShapeProto* New() const final {
    return CreateMaybeMessage<TensorShapeProto>(NULL);
  }

  TensorShapeProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TensorShapeProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TensorShapeProto& from);
  void MergeFrom(const TensorShapeProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorShapeProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TensorShapeProto_Dimension Dimension;

  // accessors -------------------------------------------------------

  // repeated .onnx_torch.TensorShapeProto.Dimension dim = 1;
  int dim_size() const;
  void clear_dim();
  static const int kDimFieldNumber = 1;
  ::onnx_torch::TensorShapeProto_Dimension* mutable_dim(int index);
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorShapeProto_Dimension >*
      mutable_dim();
  const ::onnx_torch::TensorShapeProto_Dimension& dim(int index) const;
  ::onnx_torch::TensorShapeProto_Dimension* add_dim();
  const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorShapeProto_Dimension >&
      dim() const;

  // @@protoc_insertion_point(class_scope:onnx_torch.TensorShapeProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorShapeProto_Dimension > dim_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto_Tensor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto.Tensor) */ {
 public:
  TypeProto_Tensor();
  virtual ~TypeProto_Tensor();

  TypeProto_Tensor(const TypeProto_Tensor& from);

  inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto_Tensor(TypeProto_Tensor&& from) noexcept;

  inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto_Tensor& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto_Tensor* internal_default_instance() {
    return reinterpret_cast<const TypeProto_Tensor*>(
               &_TypeProto_Tensor_default_instance_);
  }
  static int const kIndexInFileMessages =
    11;

  void Swap(TypeProto_Tensor* other);
  friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
    a.Swap(&b);
  }

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

  inline TypeProto_Tensor* New() const final {
    return CreateMaybeMessage<TypeProto_Tensor>(NULL);
  }

  TypeProto_Tensor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto_Tensor>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto_Tensor& from);
  void MergeFrom(const TypeProto_Tensor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto_Tensor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .onnx_torch.TensorShapeProto shape = 2;
  bool has_shape() const;
  void clear_shape();
  static const int kShapeFieldNumber = 2;
  private:
  const ::onnx_torch::TensorShapeProto& _internal_shape() const;
  public:
  const ::onnx_torch::TensorShapeProto& shape() const;
  ::onnx_torch::TensorShapeProto* release_shape();
  ::onnx_torch::TensorShapeProto* mutable_shape();
  void set_allocated_shape(::onnx_torch::TensorShapeProto* shape);

  // optional int32 elem_type = 1;
  bool has_elem_type() const;
  void clear_elem_type();
  static const int kElemTypeFieldNumber = 1;
  ::google::protobuf::int32 elem_type() const;
  void set_elem_type(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto.Tensor)
 private:
  void set_has_elem_type();
  void clear_has_elem_type();
  void set_has_shape();
  void clear_has_shape();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::onnx_torch::TensorShapeProto* shape_;
  ::google::protobuf::int32 elem_type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto_Sequence : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto.Sequence) */ {
 public:
  TypeProto_Sequence();
  virtual ~TypeProto_Sequence();

  TypeProto_Sequence(const TypeProto_Sequence& from);

  inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto_Sequence(TypeProto_Sequence&& from) noexcept;

  inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto_Sequence& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto_Sequence* internal_default_instance() {
    return reinterpret_cast<const TypeProto_Sequence*>(
               &_TypeProto_Sequence_default_instance_);
  }
  static int const kIndexInFileMessages =
    12;

  void Swap(TypeProto_Sequence* other);
  friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) {
    a.Swap(&b);
  }

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

  inline TypeProto_Sequence* New() const final {
    return CreateMaybeMessage<TypeProto_Sequence>(NULL);
  }

  TypeProto_Sequence* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto_Sequence>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto_Sequence& from);
  void MergeFrom(const TypeProto_Sequence& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto_Sequence* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .onnx_torch.TypeProto elem_type = 1;
  bool has_elem_type() const;
  void clear_elem_type();
  static const int kElemTypeFieldNumber = 1;
  private:
  const ::onnx_torch::TypeProto& _internal_elem_type() const;
  public:
  const ::onnx_torch::TypeProto& elem_type() const;
  ::onnx_torch::TypeProto* release_elem_type();
  ::onnx_torch::TypeProto* mutable_elem_type();
  void set_allocated_elem_type(::onnx_torch::TypeProto* elem_type);

  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto.Sequence)
 private:
  void set_has_elem_type();
  void clear_has_elem_type();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::onnx_torch::TypeProto* elem_type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto_Map : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto.Map) */ {
 public:
  TypeProto_Map();
  virtual ~TypeProto_Map();

  TypeProto_Map(const TypeProto_Map& from);

  inline TypeProto_Map& operator=(const TypeProto_Map& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto_Map(TypeProto_Map&& from) noexcept;

  inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto_Map& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto_Map* internal_default_instance() {
    return reinterpret_cast<const TypeProto_Map*>(
               &_TypeProto_Map_default_instance_);
  }
  static int const kIndexInFileMessages =
    13;

  void Swap(TypeProto_Map* other);
  friend void swap(TypeProto_Map& a, TypeProto_Map& b) {
    a.Swap(&b);
  }

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

  inline TypeProto_Map* New() const final {
    return CreateMaybeMessage<TypeProto_Map>(NULL);
  }

  TypeProto_Map* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto_Map>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto_Map& from);
  void MergeFrom(const TypeProto_Map& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto_Map* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .onnx_torch.TypeProto value_type = 2;
  bool has_value_type() const;
  void clear_value_type();
  static const int kValueTypeFieldNumber = 2;
  private:
  const ::onnx_torch::TypeProto& _internal_value_type() const;
  public:
  const ::onnx_torch::TypeProto& value_type() const;
  ::onnx_torch::TypeProto* release_value_type();
  ::onnx_torch::TypeProto* mutable_value_type();
  void set_allocated_value_type(::onnx_torch::TypeProto* value_type);

  // optional int32 key_type = 1;
  bool has_key_type() const;
  void clear_key_type();
  static const int kKeyTypeFieldNumber = 1;
  ::google::protobuf::int32 key_type() const;
  void set_key_type(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto.Map)
 private:
  void set_has_key_type();
  void clear_has_key_type();
  void set_has_value_type();
  void clear_has_value_type();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::onnx_torch::TypeProto* value_type_;
  ::google::protobuf::int32 key_type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto_Opaque : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto.Opaque) */ {
 public:
  TypeProto_Opaque();
  virtual ~TypeProto_Opaque();

  TypeProto_Opaque(const TypeProto_Opaque& from);

  inline TypeProto_Opaque& operator=(const TypeProto_Opaque& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto_Opaque(TypeProto_Opaque&& from) noexcept;

  inline TypeProto_Opaque& operator=(TypeProto_Opaque&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto_Opaque& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto_Opaque* internal_default_instance() {
    return reinterpret_cast<const TypeProto_Opaque*>(
               &_TypeProto_Opaque_default_instance_);
  }
  static int const kIndexInFileMessages =
    14;

  void Swap(TypeProto_Opaque* other);
  friend void swap(TypeProto_Opaque& a, TypeProto_Opaque& b) {
    a.Swap(&b);
  }

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

  inline TypeProto_Opaque* New() const final {
    return CreateMaybeMessage<TypeProto_Opaque>(NULL);
  }

  TypeProto_Opaque* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto_Opaque>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto_Opaque& from);
  void MergeFrom(const TypeProto_Opaque& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto_Opaque* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string domain = 1;
  bool has_domain() const;
  void clear_domain();
  static const int kDomainFieldNumber = 1;
  const ::std::string& domain() const;
  void set_domain(const ::std::string& value);
  #if LANG_CXX11
  void set_domain(::std::string&& value);
  #endif
  void set_domain(const char* value);
  void set_domain(const char* value, size_t size);
  ::std::string* mutable_domain();
  ::std::string* release_domain();
  void set_allocated_domain(::std::string* domain);

  // optional string name = 2;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto.Opaque)
 private:
  void set_has_domain();
  void clear_has_domain();
  void set_has_name();
  void clear_has_name();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr domain_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto_SparseTensor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto.SparseTensor) */ {
 public:
  TypeProto_SparseTensor();
  virtual ~TypeProto_SparseTensor();

  TypeProto_SparseTensor(const TypeProto_SparseTensor& from);

  inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept;

  inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto_SparseTensor& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto_SparseTensor* internal_default_instance() {
    return reinterpret_cast<const TypeProto_SparseTensor*>(
               &_TypeProto_SparseTensor_default_instance_);
  }
  static int const kIndexInFileMessages =
    15;

  void Swap(TypeProto_SparseTensor* other);
  friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) {
    a.Swap(&b);
  }

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

  inline TypeProto_SparseTensor* New() const final {
    return CreateMaybeMessage<TypeProto_SparseTensor>(NULL);
  }

  TypeProto_SparseTensor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto_SparseTensor>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto_SparseTensor& from);
  void MergeFrom(const TypeProto_SparseTensor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto_SparseTensor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .onnx_torch.TensorShapeProto shape = 2;
  bool has_shape() const;
  void clear_shape();
  static const int kShapeFieldNumber = 2;
  private:
  const ::onnx_torch::TensorShapeProto& _internal_shape() const;
  public:
  const ::onnx_torch::TensorShapeProto& shape() const;
  ::onnx_torch::TensorShapeProto* release_shape();
  ::onnx_torch::TensorShapeProto* mutable_shape();
  void set_allocated_shape(::onnx_torch::TensorShapeProto* shape);

  // optional int32 elem_type = 1;
  bool has_elem_type() const;
  void clear_elem_type();
  static const int kElemTypeFieldNumber = 1;
  ::google::protobuf::int32 elem_type() const;
  void set_elem_type(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto.SparseTensor)
 private:
  void set_has_elem_type();
  void clear_has_elem_type();
  void set_has_shape();
  void clear_has_shape();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::onnx_torch::TensorShapeProto* shape_;
  ::google::protobuf::int32 elem_type_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API TypeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.TypeProto) */ {
 public:
  TypeProto();
  virtual ~TypeProto();

  TypeProto(const TypeProto& from);

  inline TypeProto& operator=(const TypeProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TypeProto(TypeProto&& from) noexcept;

  inline TypeProto& operator=(TypeProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TypeProto& default_instance();

  enum ValueCase {
    kTensorType = 1,
    kSequenceType = 4,
    kMapType = 5,
    kOpaqueType = 7,
    kSparseTensorType = 8,
    VALUE_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TypeProto* internal_default_instance() {
    return reinterpret_cast<const TypeProto*>(
               &_TypeProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    16;

  void Swap(TypeProto* other);
  friend void swap(TypeProto& a, TypeProto& b) {
    a.Swap(&b);
  }

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

  inline TypeProto* New() const final {
    return CreateMaybeMessage<TypeProto>(NULL);
  }

  TypeProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TypeProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TypeProto& from);
  void MergeFrom(const TypeProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TypeProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TypeProto_Tensor Tensor;
  typedef TypeProto_Sequence Sequence;
  typedef TypeProto_Map Map;
  typedef TypeProto_Opaque Opaque;
  typedef TypeProto_SparseTensor SparseTensor;

  // accessors -------------------------------------------------------

  // optional string denotation = 6;
  bool has_denotation() const;
  void clear_denotation();
  static const int kDenotationFieldNumber = 6;
  const ::std::string& denotation() const;
  void set_denotation(const ::std::string& value);
  #if LANG_CXX11
  void set_denotation(::std::string&& value);
  #endif
  void set_denotation(const char* value);
  void set_denotation(const char* value, size_t size);
  ::std::string* mutable_denotation();
  ::std::string* release_denotation();
  void set_allocated_denotation(::std::string* denotation);

  // optional .onnx_torch.TypeProto.Tensor tensor_type = 1;
  bool has_tensor_type() const;
  void clear_tensor_type();
  static const int kTensorTypeFieldNumber = 1;
  private:
  const ::onnx_torch::TypeProto_Tensor& _internal_tensor_type() const;
  public:
  const ::onnx_torch::TypeProto_Tensor& tensor_type() const;
  ::onnx_torch::TypeProto_Tensor* release_tensor_type();
  ::onnx_torch::TypeProto_Tensor* mutable_tensor_type();
  void set_allocated_tensor_type(::onnx_torch::TypeProto_Tensor* tensor_type);

  // optional .onnx_torch.TypeProto.Sequence sequence_type = 4;
  bool has_sequence_type() const;
  void clear_sequence_type();
  static const int kSequenceTypeFieldNumber = 4;
  private:
  const ::onnx_torch::TypeProto_Sequence& _internal_sequence_type() const;
  public:
  const ::onnx_torch::TypeProto_Sequence& sequence_type() const;
  ::onnx_torch::TypeProto_Sequence* release_sequence_type();
  ::onnx_torch::TypeProto_Sequence* mutable_sequence_type();
  void set_allocated_sequence_type(::onnx_torch::TypeProto_Sequence* sequence_type);

  // optional .onnx_torch.TypeProto.Map map_type = 5;
  bool has_map_type() const;
  void clear_map_type();
  static const int kMapTypeFieldNumber = 5;
  private:
  const ::onnx_torch::TypeProto_Map& _internal_map_type() const;
  public:
  const ::onnx_torch::TypeProto_Map& map_type() const;
  ::onnx_torch::TypeProto_Map* release_map_type();
  ::onnx_torch::TypeProto_Map* mutable_map_type();
  void set_allocated_map_type(::onnx_torch::TypeProto_Map* map_type);

  // optional .onnx_torch.TypeProto.Opaque opaque_type = 7;
  bool has_opaque_type() const;
  void clear_opaque_type();
  static const int kOpaqueTypeFieldNumber = 7;
  private:
  const ::onnx_torch::TypeProto_Opaque& _internal_opaque_type() const;
  public:
  const ::onnx_torch::TypeProto_Opaque& opaque_type() const;
  ::onnx_torch::TypeProto_Opaque* release_opaque_type();
  ::onnx_torch::TypeProto_Opaque* mutable_opaque_type();
  void set_allocated_opaque_type(::onnx_torch::TypeProto_Opaque* opaque_type);

  // optional .onnx_torch.TypeProto.SparseTensor sparse_tensor_type = 8;
  bool has_sparse_tensor_type() const;
  void clear_sparse_tensor_type();
  static const int kSparseTensorTypeFieldNumber = 8;
  private:
  const ::onnx_torch::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
  public:
  const ::onnx_torch::TypeProto_SparseTensor& sparse_tensor_type() const;
  ::onnx_torch::TypeProto_SparseTensor* release_sparse_tensor_type();
  ::onnx_torch::TypeProto_SparseTensor* mutable_sparse_tensor_type();
  void set_allocated_sparse_tensor_type(::onnx_torch::TypeProto_SparseTensor* sparse_tensor_type);

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:onnx_torch.TypeProto)
 private:
  void set_has_tensor_type();
  void set_has_sequence_type();
  void set_has_map_type();
  void set_has_opaque_type();
  void set_has_sparse_tensor_type();
  void set_has_denotation();
  void clear_has_denotation();

  inline bool has_value() const;
  inline void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr denotation_;
  union ValueUnion {
    ValueUnion() {}
    ::onnx_torch::TypeProto_Tensor* tensor_type_;
    ::onnx_torch::TypeProto_Sequence* sequence_type_;
    ::onnx_torch::TypeProto_Map* map_type_;
    ::onnx_torch::TypeProto_Opaque* opaque_type_;
    ::onnx_torch::TypeProto_SparseTensor* sparse_tensor_type_;
  } value_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ONNX_API OperatorSetIdProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:onnx_torch.OperatorSetIdProto) */ {
 public:
  OperatorSetIdProto();
  virtual ~OperatorSetIdProto();

  OperatorSetIdProto(const OperatorSetIdProto& from);

  inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OperatorSetIdProto(OperatorSetIdProto&& from) noexcept;

  inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OperatorSetIdProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OperatorSetIdProto* internal_default_instance() {
    return reinterpret_cast<const OperatorSetIdProto*>(
               &_OperatorSetIdProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    17;

  void Swap(OperatorSetIdProto* other);
  friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
    a.Swap(&b);
  }

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

  inline OperatorSetIdProto* New() const final {
    return CreateMaybeMessage<OperatorSetIdProto>(NULL);
  }

  OperatorSetIdProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OperatorSetIdProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const OperatorSetIdProto& from);
  void MergeFrom(const OperatorSetIdProto& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OperatorSetIdProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string domain = 1;
  bool has_domain() const;
  void clear_domain();
  static const int kDomainFieldNumber = 1;
  const ::std::string& domain() const;
  void set_domain(const ::std::string& value);
  #if LANG_CXX11
  void set_domain(::std::string&& value);
  #endif
  void set_domain(const char* value);
  void set_domain(const char* value, size_t size);
  ::std::string* mutable_domain();
  ::std::string* release_domain();
  void set_allocated_domain(::std::string* domain);

  // optional int64 version = 2;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 2;
  ::google::protobuf::int64 version() const;
  void set_version(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:onnx_torch.OperatorSetIdProto)
 private:
  void set_has_domain();
  void clear_has_domain();
  void set_has_version();
  void clear_has_version();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr domain_;
  ::google::protobuf::int64 version_;
  friend struct ::protobuf_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto::TableStruct;
};
// ===================================================================


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

#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 {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AttributeProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AttributeProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AttributeProto::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& AttributeProto::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.name)
  return name_.GetNoArena();
}
inline void AttributeProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.name)
}
#if LANG_CXX11
inline void AttributeProto::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.AttributeProto.name)
}
#endif
inline void AttributeProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.AttributeProto.name)
}
inline void AttributeProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.AttributeProto.name)
}
inline ::std::string* AttributeProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* AttributeProto::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void AttributeProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.name)
}

// optional string ref_attr_name = 21;
inline bool AttributeProto::has_ref_attr_name() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AttributeProto::set_has_ref_attr_name() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AttributeProto::clear_has_ref_attr_name() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AttributeProto::clear_ref_attr_name() {
  ref_attr_name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_ref_attr_name();
}
inline const ::std::string& AttributeProto::ref_attr_name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.ref_attr_name)
  return ref_attr_name_.GetNoArena();
}
inline void AttributeProto::set_ref_attr_name(const ::std::string& value) {
  set_has_ref_attr_name();
  ref_attr_name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.ref_attr_name)
}
#if LANG_CXX11
inline void AttributeProto::set_ref_attr_name(::std::string&& value) {
  set_has_ref_attr_name();
  ref_attr_name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.AttributeProto.ref_attr_name)
}
#endif
inline void AttributeProto::set_ref_attr_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_ref_attr_name();
  ref_attr_name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.AttributeProto.ref_attr_name)
}
inline void AttributeProto::set_ref_attr_name(const char* value, size_t size) {
  set_has_ref_attr_name();
  ref_attr_name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.AttributeProto.ref_attr_name)
}
inline ::std::string* AttributeProto::mutable_ref_attr_name() {
  set_has_ref_attr_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.ref_attr_name)
  return ref_attr_name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* AttributeProto::release_ref_attr_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.ref_attr_name)
  if (!has_ref_attr_name()) {
    return NULL;
  }
  clear_has_ref_attr_name();
  return ref_attr_name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void AttributeProto::set_allocated_ref_attr_name(::std::string* ref_attr_name) {
  if (ref_attr_name != NULL) {
    set_has_ref_attr_name();
  } else {
    clear_has_ref_attr_name();
  }
  ref_attr_name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), ref_attr_name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.ref_attr_name)
}

// optional string doc_string = 13;
inline bool AttributeProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AttributeProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AttributeProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AttributeProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& AttributeProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void AttributeProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.doc_string)
}
#if LANG_CXX11
inline void AttributeProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.AttributeProto.doc_string)
}
#endif
inline void AttributeProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.AttributeProto.doc_string)
}
inline void AttributeProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.AttributeProto.doc_string)
}
inline ::std::string* AttributeProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* AttributeProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void AttributeProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.doc_string)
}

// optional .onnx_torch.AttributeProto.AttributeType type = 20;
inline bool AttributeProto::has_type() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void AttributeProto::set_has_type() {
  _has_bits_[0] |= 0x00000100u;
}
inline void AttributeProto::clear_has_type() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void AttributeProto::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::onnx_torch::AttributeProto_AttributeType AttributeProto::type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.type)
  return static_cast< ::onnx_torch::AttributeProto_AttributeType >(type_);
}
inline void AttributeProto::set_type(::onnx_torch::AttributeProto_AttributeType value) {
  assert(::onnx_torch::AttributeProto_AttributeType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.type)
}

// optional float f = 2;
inline bool AttributeProto::has_f() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AttributeProto::set_has_f() {
  _has_bits_[0] |= 0x00000080u;
}
inline void AttributeProto::clear_has_f() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void AttributeProto::clear_f() {
  f_ = 0;
  clear_has_f();
}
inline float AttributeProto::f() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.f)
  return f_;
}
inline void AttributeProto::set_f(float value) {
  set_has_f();
  f_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.f)
}

// optional int64 i = 3;
inline bool AttributeProto::has_i() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AttributeProto::set_has_i() {
  _has_bits_[0] |= 0x00000040u;
}
inline void AttributeProto::clear_has_i() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void AttributeProto::clear_i() {
  i_ = GOOGLE_LONGLONG(0);
  clear_has_i();
}
inline ::google::protobuf::int64 AttributeProto::i() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.i)
  return i_;
}
inline void AttributeProto::set_i(::google::protobuf::int64 value) {
  set_has_i();
  i_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.i)
}

// optional bytes s = 4;
inline bool AttributeProto::has_s() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AttributeProto::set_has_s() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AttributeProto::clear_has_s() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AttributeProto::clear_s() {
  s_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_s();
}
inline const ::std::string& AttributeProto::s() const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.s)
  return s_.GetNoArena();
}
inline void AttributeProto::set_s(const ::std::string& value) {
  set_has_s();
  s_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.s)
}
#if LANG_CXX11
inline void AttributeProto::set_s(::std::string&& value) {
  set_has_s();
  s_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.AttributeProto.s)
}
#endif
inline void AttributeProto::set_s(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_s();
  s_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.AttributeProto.s)
}
inline void AttributeProto::set_s(const void* value, size_t size) {
  set_has_s();
  s_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.AttributeProto.s)
}
inline ::std::string* AttributeProto::mutable_s() {
  set_has_s();
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.s)
  return s_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* AttributeProto::release_s() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.s)
  if (!has_s()) {
    return NULL;
  }
  clear_has_s();
  return s_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void AttributeProto::set_allocated_s(::std::string* s) {
  if (s != NULL) {
    set_has_s();
  } else {
    clear_has_s();
  }
  s_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), s);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.s)
}

// optional .onnx_torch.TensorProto t = 5;
inline bool AttributeProto::has_t() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AttributeProto::set_has_t() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AttributeProto::clear_has_t() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AttributeProto::clear_t() {
  if (t_ != NULL) t_->Clear();
  clear_has_t();
}
inline const ::onnx_torch::TensorProto& AttributeProto::_internal_t() const {
  return *t_;
}
inline const ::onnx_torch::TensorProto& AttributeProto::t() const {
  const ::onnx_torch::TensorProto* p = t_;
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.t)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TensorProto*>(
      &::onnx_torch::_TensorProto_default_instance_);
}
inline ::onnx_torch::TensorProto* AttributeProto::release_t() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.t)
  clear_has_t();
  ::onnx_torch::TensorProto* temp = t_;
  t_ = NULL;
  return temp;
}
inline ::onnx_torch::TensorProto* AttributeProto::mutable_t() {
  set_has_t();
  if (t_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TensorProto>(GetArenaNoVirtual());
    t_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.t)
  return t_;
}
inline void AttributeProto::set_allocated_t(::onnx_torch::TensorProto* t) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete t_;
  }
  if (t) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      t = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, t, submessage_arena);
    }
    set_has_t();
  } else {
    clear_has_t();
  }
  t_ = t;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.t)
}

// optional .onnx_torch.GraphProto g = 6;
inline bool AttributeProto::has_g() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AttributeProto::set_has_g() {
  _has_bits_[0] |= 0x00000020u;
}
inline void AttributeProto::clear_has_g() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void AttributeProto::clear_g() {
  if (g_ != NULL) g_->Clear();
  clear_has_g();
}
inline const ::onnx_torch::GraphProto& AttributeProto::_internal_g() const {
  return *g_;
}
inline const ::onnx_torch::GraphProto& AttributeProto::g() const {
  const ::onnx_torch::GraphProto* p = g_;
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.g)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::GraphProto*>(
      &::onnx_torch::_GraphProto_default_instance_);
}
inline ::onnx_torch::GraphProto* AttributeProto::release_g() {
  // @@protoc_insertion_point(field_release:onnx_torch.AttributeProto.g)
  clear_has_g();
  ::onnx_torch::GraphProto* temp = g_;
  g_ = NULL;
  return temp;
}
inline ::onnx_torch::GraphProto* AttributeProto::mutable_g() {
  set_has_g();
  if (g_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::GraphProto>(GetArenaNoVirtual());
    g_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.g)
  return g_;
}
inline void AttributeProto::set_allocated_g(::onnx_torch::GraphProto* g) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete g_;
  }
  if (g) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      g = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, g, submessage_arena);
    }
    set_has_g();
  } else {
    clear_has_g();
  }
  g_ = g;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.AttributeProto.g)
}

// repeated float floats = 7;
inline int AttributeProto::floats_size() const {
  return floats_.size();
}
inline void AttributeProto::clear_floats() {
  floats_.Clear();
}
inline float AttributeProto::floats(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.floats)
  return floats_.Get(index);
}
inline void AttributeProto::set_floats(int index, float value) {
  floats_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.floats)
}
inline void AttributeProto::add_floats(float value) {
  floats_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.floats)
}
inline const ::google::protobuf::RepeatedField< float >&
AttributeProto::floats() const {
  // @@protoc_insertion_point(field_list:onnx_torch.AttributeProto.floats)
  return floats_;
}
inline ::google::protobuf::RepeatedField< float >*
AttributeProto::mutable_floats() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.AttributeProto.floats)
  return &floats_;
}

// repeated int64 ints = 8;
inline int AttributeProto::ints_size() const {
  return ints_.size();
}
inline void AttributeProto::clear_ints() {
  ints_.Clear();
}
inline ::google::protobuf::int64 AttributeProto::ints(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.ints)
  return ints_.Get(index);
}
inline void AttributeProto::set_ints(int index, ::google::protobuf::int64 value) {
  ints_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.ints)
}
inline void AttributeProto::add_ints(::google::protobuf::int64 value) {
  ints_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.ints)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
AttributeProto::ints() const {
  // @@protoc_insertion_point(field_list:onnx_torch.AttributeProto.ints)
  return ints_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
AttributeProto::mutable_ints() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.AttributeProto.ints)
  return &ints_;
}

// repeated bytes strings = 9;
inline int AttributeProto::strings_size() const {
  return strings_.size();
}
inline void AttributeProto::clear_strings() {
  strings_.Clear();
}
inline const ::std::string& AttributeProto::strings(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.strings)
  return strings_.Get(index);
}
inline ::std::string* AttributeProto::mutable_strings(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.strings)
  return strings_.Mutable(index);
}
inline void AttributeProto::set_strings(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.strings)
  strings_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void AttributeProto::set_strings(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.AttributeProto.strings)
  strings_.Mutable(index)->assign(std::move(value));
}
#endif
inline void AttributeProto::set_strings(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  strings_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:onnx_torch.AttributeProto.strings)
}
inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
  strings_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.AttributeProto.strings)
}
inline ::std::string* AttributeProto::add_strings() {
  // @@protoc_insertion_point(field_add_mutable:onnx_torch.AttributeProto.strings)
  return strings_.Add();
}
inline void AttributeProto::add_strings(const ::std::string& value) {
  strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.strings)
}
#if LANG_CXX11
inline void AttributeProto::add_strings(::std::string&& value) {
  strings_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.strings)
}
#endif
inline void AttributeProto::add_strings(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:onnx_torch.AttributeProto.strings)
}
inline void AttributeProto::add_strings(const void* value, size_t size) {
  strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:onnx_torch.AttributeProto.strings)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
AttributeProto::strings() const {
  // @@protoc_insertion_point(field_list:onnx_torch.AttributeProto.strings)
  return strings_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
AttributeProto::mutable_strings() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.AttributeProto.strings)
  return &strings_;
}

// repeated .onnx_torch.TensorProto tensors = 10;
inline int AttributeProto::tensors_size() const {
  return tensors_.size();
}
inline void AttributeProto::clear_tensors() {
  tensors_.Clear();
}
inline ::onnx_torch::TensorProto* AttributeProto::mutable_tensors(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.tensors)
  return tensors_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >*
AttributeProto::mutable_tensors() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.AttributeProto.tensors)
  return &tensors_;
}
inline const ::onnx_torch::TensorProto& AttributeProto::tensors(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.tensors)
  return tensors_.Get(index);
}
inline ::onnx_torch::TensorProto* AttributeProto::add_tensors() {
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.tensors)
  return tensors_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >&
AttributeProto::tensors() const {
  // @@protoc_insertion_point(field_list:onnx_torch.AttributeProto.tensors)
  return tensors_;
}

// repeated .onnx_torch.GraphProto graphs = 11;
inline int AttributeProto::graphs_size() const {
  return graphs_.size();
}
inline void AttributeProto::clear_graphs() {
  graphs_.Clear();
}
inline ::onnx_torch::GraphProto* AttributeProto::mutable_graphs(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.AttributeProto.graphs)
  return graphs_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::GraphProto >*
AttributeProto::mutable_graphs() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.AttributeProto.graphs)
  return &graphs_;
}
inline const ::onnx_torch::GraphProto& AttributeProto::graphs(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.AttributeProto.graphs)
  return graphs_.Get(index);
}
inline ::onnx_torch::GraphProto* AttributeProto::add_graphs() {
  // @@protoc_insertion_point(field_add:onnx_torch.AttributeProto.graphs)
  return graphs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::GraphProto >&
AttributeProto::graphs() const {
  // @@protoc_insertion_point(field_list:onnx_torch.AttributeProto.graphs)
  return graphs_;
}

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

// ValueInfoProto

// optional string name = 1;
inline bool ValueInfoProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ValueInfoProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ValueInfoProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ValueInfoProto::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& ValueInfoProto::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ValueInfoProto.name)
  return name_.GetNoArena();
}
inline void ValueInfoProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ValueInfoProto.name)
}
#if LANG_CXX11
inline void ValueInfoProto::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ValueInfoProto.name)
}
#endif
inline void ValueInfoProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ValueInfoProto.name)
}
inline void ValueInfoProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ValueInfoProto.name)
}
inline ::std::string* ValueInfoProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ValueInfoProto.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueInfoProto::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.ValueInfoProto.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ValueInfoProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ValueInfoProto.name)
}

// optional .onnx_torch.TypeProto type = 2;
inline bool ValueInfoProto::has_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ValueInfoProto::set_has_type() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ValueInfoProto::clear_has_type() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ValueInfoProto::clear_type() {
  if (type_ != NULL) type_->Clear();
  clear_has_type();
}
inline const ::onnx_torch::TypeProto& ValueInfoProto::_internal_type() const {
  return *type_;
}
inline const ::onnx_torch::TypeProto& ValueInfoProto::type() const {
  const ::onnx_torch::TypeProto* p = type_;
  // @@protoc_insertion_point(field_get:onnx_torch.ValueInfoProto.type)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TypeProto*>(
      &::onnx_torch::_TypeProto_default_instance_);
}
inline ::onnx_torch::TypeProto* ValueInfoProto::release_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.ValueInfoProto.type)
  clear_has_type();
  ::onnx_torch::TypeProto* temp = type_;
  type_ = NULL;
  return temp;
}
inline ::onnx_torch::TypeProto* ValueInfoProto::mutable_type() {
  set_has_type();
  if (type_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TypeProto>(GetArenaNoVirtual());
    type_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.ValueInfoProto.type)
  return type_;
}
inline void ValueInfoProto::set_allocated_type(::onnx_torch::TypeProto* type) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete type_;
  }
  if (type) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      type = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, type, submessage_arena);
    }
    set_has_type();
  } else {
    clear_has_type();
  }
  type_ = type;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ValueInfoProto.type)
}

// optional string doc_string = 3;
inline bool ValueInfoProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ValueInfoProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ValueInfoProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ValueInfoProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& ValueInfoProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ValueInfoProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void ValueInfoProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ValueInfoProto.doc_string)
}
#if LANG_CXX11
inline void ValueInfoProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ValueInfoProto.doc_string)
}
#endif
inline void ValueInfoProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ValueInfoProto.doc_string)
}
inline void ValueInfoProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ValueInfoProto.doc_string)
}
inline ::std::string* ValueInfoProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ValueInfoProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueInfoProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.ValueInfoProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ValueInfoProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ValueInfoProto.doc_string)
}

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

// NodeProto

// repeated string input = 1;
inline int NodeProto::input_size() const {
  return input_.size();
}
inline void NodeProto::clear_input() {
  input_.Clear();
}
inline const ::std::string& NodeProto::input(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.input)
  return input_.Get(index);
}
inline ::std::string* NodeProto::mutable_input(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.input)
  return input_.Mutable(index);
}
inline void NodeProto::set_input(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.input)
  input_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NodeProto::set_input(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.input)
  input_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NodeProto::set_input(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.input)
}
inline void NodeProto::set_input(int index, const char* value, size_t size) {
  input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.input)
}
inline ::std::string* NodeProto::add_input() {
  // @@protoc_insertion_point(field_add_mutable:onnx_torch.NodeProto.input)
  return input_.Add();
}
inline void NodeProto::add_input(const ::std::string& value) {
  input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:onnx_torch.NodeProto.input)
}
#if LANG_CXX11
inline void NodeProto::add_input(::std::string&& value) {
  input_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:onnx_torch.NodeProto.input)
}
#endif
inline void NodeProto::add_input(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:onnx_torch.NodeProto.input)
}
inline void NodeProto::add_input(const char* value, size_t size) {
  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:onnx_torch.NodeProto.input)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NodeProto::input() const {
  // @@protoc_insertion_point(field_list:onnx_torch.NodeProto.input)
  return input_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NodeProto::mutable_input() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.NodeProto.input)
  return &input_;
}

// repeated string output = 2;
inline int NodeProto::output_size() const {
  return output_.size();
}
inline void NodeProto::clear_output() {
  output_.Clear();
}
inline const ::std::string& NodeProto::output(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.output)
  return output_.Get(index);
}
inline ::std::string* NodeProto::mutable_output(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.output)
  return output_.Mutable(index);
}
inline void NodeProto::set_output(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.output)
  output_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void NodeProto::set_output(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.output)
  output_.Mutable(index)->assign(std::move(value));
}
#endif
inline void NodeProto::set_output(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  output_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.output)
}
inline void NodeProto::set_output(int index, const char* value, size_t size) {
  output_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.output)
}
inline ::std::string* NodeProto::add_output() {
  // @@protoc_insertion_point(field_add_mutable:onnx_torch.NodeProto.output)
  return output_.Add();
}
inline void NodeProto::add_output(const ::std::string& value) {
  output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:onnx_torch.NodeProto.output)
}
#if LANG_CXX11
inline void NodeProto::add_output(::std::string&& value) {
  output_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:onnx_torch.NodeProto.output)
}
#endif
inline void NodeProto::add_output(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:onnx_torch.NodeProto.output)
}
inline void NodeProto::add_output(const char* value, size_t size) {
  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:onnx_torch.NodeProto.output)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NodeProto::output() const {
  // @@protoc_insertion_point(field_list:onnx_torch.NodeProto.output)
  return output_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NodeProto::mutable_output() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.NodeProto.output)
  return &output_;
}

// optional string name = 3;
inline bool NodeProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NodeProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NodeProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NodeProto::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& NodeProto::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.name)
  return name_.GetNoArena();
}
inline void NodeProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.name)
}
#if LANG_CXX11
inline void NodeProto::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.NodeProto.name)
}
#endif
inline void NodeProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.name)
}
inline void NodeProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.name)
}
inline ::std::string* NodeProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeProto::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.NodeProto.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void NodeProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.NodeProto.name)
}

// optional string op_type = 4;
inline bool NodeProto::has_op_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NodeProto::set_has_op_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NodeProto::clear_has_op_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NodeProto::clear_op_type() {
  op_type_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_op_type();
}
inline const ::std::string& NodeProto::op_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.op_type)
  return op_type_.GetNoArena();
}
inline void NodeProto::set_op_type(const ::std::string& value) {
  set_has_op_type();
  op_type_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.op_type)
}
#if LANG_CXX11
inline void NodeProto::set_op_type(::std::string&& value) {
  set_has_op_type();
  op_type_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.NodeProto.op_type)
}
#endif
inline void NodeProto::set_op_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_op_type();
  op_type_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.op_type)
}
inline void NodeProto::set_op_type(const char* value, size_t size) {
  set_has_op_type();
  op_type_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.op_type)
}
inline ::std::string* NodeProto::mutable_op_type() {
  set_has_op_type();
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.op_type)
  return op_type_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeProto::release_op_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.NodeProto.op_type)
  if (!has_op_type()) {
    return NULL;
  }
  clear_has_op_type();
  return op_type_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void NodeProto::set_allocated_op_type(::std::string* op_type) {
  if (op_type != NULL) {
    set_has_op_type();
  } else {
    clear_has_op_type();
  }
  op_type_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), op_type);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.NodeProto.op_type)
}

// optional string domain = 7;
inline bool NodeProto::has_domain() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NodeProto::set_has_domain() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NodeProto::clear_has_domain() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NodeProto::clear_domain() {
  domain_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_domain();
}
inline const ::std::string& NodeProto::domain() const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.domain)
  return domain_.GetNoArena();
}
inline void NodeProto::set_domain(const ::std::string& value) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.domain)
}
#if LANG_CXX11
inline void NodeProto::set_domain(::std::string&& value) {
  set_has_domain();
  domain_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.NodeProto.domain)
}
#endif
inline void NodeProto::set_domain(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.domain)
}
inline void NodeProto::set_domain(const char* value, size_t size) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.domain)
}
inline ::std::string* NodeProto::mutable_domain() {
  set_has_domain();
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.domain)
  return domain_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeProto::release_domain() {
  // @@protoc_insertion_point(field_release:onnx_torch.NodeProto.domain)
  if (!has_domain()) {
    return NULL;
  }
  clear_has_domain();
  return domain_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void NodeProto::set_allocated_domain(::std::string* domain) {
  if (domain != NULL) {
    set_has_domain();
  } else {
    clear_has_domain();
  }
  domain_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), domain);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.NodeProto.domain)
}

// repeated .onnx_torch.AttributeProto attribute = 5;
inline int NodeProto::attribute_size() const {
  return attribute_.size();
}
inline void NodeProto::clear_attribute() {
  attribute_.Clear();
}
inline ::onnx_torch::AttributeProto* NodeProto::mutable_attribute(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.attribute)
  return attribute_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::AttributeProto >*
NodeProto::mutable_attribute() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.NodeProto.attribute)
  return &attribute_;
}
inline const ::onnx_torch::AttributeProto& NodeProto::attribute(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.attribute)
  return attribute_.Get(index);
}
inline ::onnx_torch::AttributeProto* NodeProto::add_attribute() {
  // @@protoc_insertion_point(field_add:onnx_torch.NodeProto.attribute)
  return attribute_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::AttributeProto >&
NodeProto::attribute() const {
  // @@protoc_insertion_point(field_list:onnx_torch.NodeProto.attribute)
  return attribute_;
}

// optional string doc_string = 6;
inline bool NodeProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NodeProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NodeProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NodeProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& NodeProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.NodeProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void NodeProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.NodeProto.doc_string)
}
#if LANG_CXX11
inline void NodeProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.NodeProto.doc_string)
}
#endif
inline void NodeProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.NodeProto.doc_string)
}
inline void NodeProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.NodeProto.doc_string)
}
inline ::std::string* NodeProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.NodeProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.NodeProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void NodeProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.NodeProto.doc_string)
}

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

// ModelProto

// optional int64 ir_version = 1;
inline bool ModelProto::has_ir_version() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ModelProto::set_has_ir_version() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ModelProto::clear_has_ir_version() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ModelProto::clear_ir_version() {
  ir_version_ = GOOGLE_LONGLONG(0);
  clear_has_ir_version();
}
inline ::google::protobuf::int64 ModelProto::ir_version() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.ir_version)
  return ir_version_;
}
inline void ModelProto::set_ir_version(::google::protobuf::int64 value) {
  set_has_ir_version();
  ir_version_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.ir_version)
}

// repeated .onnx_torch.OperatorSetIdProto opset_import = 8;
inline int ModelProto::opset_import_size() const {
  return opset_import_.size();
}
inline void ModelProto::clear_opset_import() {
  opset_import_.Clear();
}
inline ::onnx_torch::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.opset_import)
  return opset_import_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::OperatorSetIdProto >*
ModelProto::mutable_opset_import() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.ModelProto.opset_import)
  return &opset_import_;
}
inline const ::onnx_torch::OperatorSetIdProto& ModelProto::opset_import(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.opset_import)
  return opset_import_.Get(index);
}
inline ::onnx_torch::OperatorSetIdProto* ModelProto::add_opset_import() {
  // @@protoc_insertion_point(field_add:onnx_torch.ModelProto.opset_import)
  return opset_import_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::OperatorSetIdProto >&
ModelProto::opset_import() const {
  // @@protoc_insertion_point(field_list:onnx_torch.ModelProto.opset_import)
  return opset_import_;
}

// optional string producer_name = 2;
inline bool ModelProto::has_producer_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ModelProto::set_has_producer_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ModelProto::clear_has_producer_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ModelProto::clear_producer_name() {
  producer_name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_producer_name();
}
inline const ::std::string& ModelProto::producer_name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.producer_name)
  return producer_name_.GetNoArena();
}
inline void ModelProto::set_producer_name(const ::std::string& value) {
  set_has_producer_name();
  producer_name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.producer_name)
}
#if LANG_CXX11
inline void ModelProto::set_producer_name(::std::string&& value) {
  set_has_producer_name();
  producer_name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ModelProto.producer_name)
}
#endif
inline void ModelProto::set_producer_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_producer_name();
  producer_name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ModelProto.producer_name)
}
inline void ModelProto::set_producer_name(const char* value, size_t size) {
  set_has_producer_name();
  producer_name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ModelProto.producer_name)
}
inline ::std::string* ModelProto::mutable_producer_name() {
  set_has_producer_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.producer_name)
  return producer_name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ModelProto::release_producer_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.ModelProto.producer_name)
  if (!has_producer_name()) {
    return NULL;
  }
  clear_has_producer_name();
  return producer_name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ModelProto::set_allocated_producer_name(::std::string* producer_name) {
  if (producer_name != NULL) {
    set_has_producer_name();
  } else {
    clear_has_producer_name();
  }
  producer_name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), producer_name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ModelProto.producer_name)
}

// optional string producer_version = 3;
inline bool ModelProto::has_producer_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ModelProto::set_has_producer_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ModelProto::clear_has_producer_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ModelProto::clear_producer_version() {
  producer_version_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_producer_version();
}
inline const ::std::string& ModelProto::producer_version() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.producer_version)
  return producer_version_.GetNoArena();
}
inline void ModelProto::set_producer_version(const ::std::string& value) {
  set_has_producer_version();
  producer_version_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.producer_version)
}
#if LANG_CXX11
inline void ModelProto::set_producer_version(::std::string&& value) {
  set_has_producer_version();
  producer_version_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ModelProto.producer_version)
}
#endif
inline void ModelProto::set_producer_version(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_producer_version();
  producer_version_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ModelProto.producer_version)
}
inline void ModelProto::set_producer_version(const char* value, size_t size) {
  set_has_producer_version();
  producer_version_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ModelProto.producer_version)
}
inline ::std::string* ModelProto::mutable_producer_version() {
  set_has_producer_version();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.producer_version)
  return producer_version_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ModelProto::release_producer_version() {
  // @@protoc_insertion_point(field_release:onnx_torch.ModelProto.producer_version)
  if (!has_producer_version()) {
    return NULL;
  }
  clear_has_producer_version();
  return producer_version_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ModelProto::set_allocated_producer_version(::std::string* producer_version) {
  if (producer_version != NULL) {
    set_has_producer_version();
  } else {
    clear_has_producer_version();
  }
  producer_version_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), producer_version);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ModelProto.producer_version)
}

// optional string domain = 4;
inline bool ModelProto::has_domain() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ModelProto::set_has_domain() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ModelProto::clear_has_domain() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ModelProto::clear_domain() {
  domain_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_domain();
}
inline const ::std::string& ModelProto::domain() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.domain)
  return domain_.GetNoArena();
}
inline void ModelProto::set_domain(const ::std::string& value) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.domain)
}
#if LANG_CXX11
inline void ModelProto::set_domain(::std::string&& value) {
  set_has_domain();
  domain_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ModelProto.domain)
}
#endif
inline void ModelProto::set_domain(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ModelProto.domain)
}
inline void ModelProto::set_domain(const char* value, size_t size) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ModelProto.domain)
}
inline ::std::string* ModelProto::mutable_domain() {
  set_has_domain();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.domain)
  return domain_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ModelProto::release_domain() {
  // @@protoc_insertion_point(field_release:onnx_torch.ModelProto.domain)
  if (!has_domain()) {
    return NULL;
  }
  clear_has_domain();
  return domain_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ModelProto::set_allocated_domain(::std::string* domain) {
  if (domain != NULL) {
    set_has_domain();
  } else {
    clear_has_domain();
  }
  domain_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), domain);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ModelProto.domain)
}

// optional int64 model_version = 5;
inline bool ModelProto::has_model_version() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ModelProto::set_has_model_version() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ModelProto::clear_has_model_version() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ModelProto::clear_model_version() {
  model_version_ = GOOGLE_LONGLONG(0);
  clear_has_model_version();
}
inline ::google::protobuf::int64 ModelProto::model_version() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.model_version)
  return model_version_;
}
inline void ModelProto::set_model_version(::google::protobuf::int64 value) {
  set_has_model_version();
  model_version_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.model_version)
}

// optional string doc_string = 6;
inline bool ModelProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ModelProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ModelProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ModelProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& ModelProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void ModelProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.ModelProto.doc_string)
}
#if LANG_CXX11
inline void ModelProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.ModelProto.doc_string)
}
#endif
inline void ModelProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.ModelProto.doc_string)
}
inline void ModelProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.ModelProto.doc_string)
}
inline ::std::string* ModelProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* ModelProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.ModelProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void ModelProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ModelProto.doc_string)
}

// optional .onnx_torch.GraphProto graph = 7;
inline bool ModelProto::has_graph() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ModelProto::set_has_graph() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ModelProto::clear_has_graph() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ModelProto::clear_graph() {
  if (graph_ != NULL) graph_->Clear();
  clear_has_graph();
}
inline const ::onnx_torch::GraphProto& ModelProto::_internal_graph() const {
  return *graph_;
}
inline const ::onnx_torch::GraphProto& ModelProto::graph() const {
  const ::onnx_torch::GraphProto* p = graph_;
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.graph)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::GraphProto*>(
      &::onnx_torch::_GraphProto_default_instance_);
}
inline ::onnx_torch::GraphProto* ModelProto::release_graph() {
  // @@protoc_insertion_point(field_release:onnx_torch.ModelProto.graph)
  clear_has_graph();
  ::onnx_torch::GraphProto* temp = graph_;
  graph_ = NULL;
  return temp;
}
inline ::onnx_torch::GraphProto* ModelProto::mutable_graph() {
  set_has_graph();
  if (graph_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::GraphProto>(GetArenaNoVirtual());
    graph_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.graph)
  return graph_;
}
inline void ModelProto::set_allocated_graph(::onnx_torch::GraphProto* graph) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete graph_;
  }
  if (graph) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      graph = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, graph, submessage_arena);
    }
    set_has_graph();
  } else {
    clear_has_graph();
  }
  graph_ = graph;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.ModelProto.graph)
}

// repeated .onnx_torch.StringStringEntryProto metadata_props = 14;
inline int ModelProto::metadata_props_size() const {
  return metadata_props_.size();
}
inline void ModelProto::clear_metadata_props() {
  metadata_props_.Clear();
}
inline ::onnx_torch::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.ModelProto.metadata_props)
  return metadata_props_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
ModelProto::mutable_metadata_props() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.ModelProto.metadata_props)
  return &metadata_props_;
}
inline const ::onnx_torch::StringStringEntryProto& ModelProto::metadata_props(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.ModelProto.metadata_props)
  return metadata_props_.Get(index);
}
inline ::onnx_torch::StringStringEntryProto* ModelProto::add_metadata_props() {
  // @@protoc_insertion_point(field_add:onnx_torch.ModelProto.metadata_props)
  return metadata_props_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
ModelProto::metadata_props() const {
  // @@protoc_insertion_point(field_list:onnx_torch.ModelProto.metadata_props)
  return metadata_props_;
}

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

// StringStringEntryProto

// optional string key = 1;
inline bool StringStringEntryProto::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StringStringEntryProto::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StringStringEntryProto::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StringStringEntryProto::clear_key() {
  key_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& StringStringEntryProto::key() const {
  // @@protoc_insertion_point(field_get:onnx_torch.StringStringEntryProto.key)
  return key_.GetNoArena();
}
inline void StringStringEntryProto::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.StringStringEntryProto.key)
}
#if LANG_CXX11
inline void StringStringEntryProto::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.StringStringEntryProto.key)
}
#endif
inline void StringStringEntryProto::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.StringStringEntryProto.key)
}
inline void StringStringEntryProto::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.StringStringEntryProto.key)
}
inline ::std::string* StringStringEntryProto::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:onnx_torch.StringStringEntryProto.key)
  return key_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* StringStringEntryProto::release_key() {
  // @@protoc_insertion_point(field_release:onnx_torch.StringStringEntryProto.key)
  if (!has_key()) {
    return NULL;
  }
  clear_has_key();
  return key_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void StringStringEntryProto::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.StringStringEntryProto.key)
}

// optional string value = 2;
inline bool StringStringEntryProto::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StringStringEntryProto::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StringStringEntryProto::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StringStringEntryProto::clear_value() {
  value_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_value();
}
inline const ::std::string& StringStringEntryProto::value() const {
  // @@protoc_insertion_point(field_get:onnx_torch.StringStringEntryProto.value)
  return value_.GetNoArena();
}
inline void StringStringEntryProto::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.StringStringEntryProto.value)
}
#if LANG_CXX11
inline void StringStringEntryProto::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.StringStringEntryProto.value)
}
#endif
inline void StringStringEntryProto::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.StringStringEntryProto.value)
}
inline void StringStringEntryProto::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.StringStringEntryProto.value)
}
inline ::std::string* StringStringEntryProto::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:onnx_torch.StringStringEntryProto.value)
  return value_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* StringStringEntryProto::release_value() {
  // @@protoc_insertion_point(field_release:onnx_torch.StringStringEntryProto.value)
  if (!has_value()) {
    return NULL;
  }
  clear_has_value();
  return value_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void StringStringEntryProto::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.StringStringEntryProto.value)
}

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

// TensorAnnotation

// optional string tensor_name = 1;
inline bool TensorAnnotation::has_tensor_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TensorAnnotation::set_has_tensor_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TensorAnnotation::clear_has_tensor_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TensorAnnotation::clear_tensor_name() {
  tensor_name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_tensor_name();
}
inline const ::std::string& TensorAnnotation::tensor_name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorAnnotation.tensor_name)
  return tensor_name_.GetNoArena();
}
inline void TensorAnnotation::set_tensor_name(const ::std::string& value) {
  set_has_tensor_name();
  tensor_name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorAnnotation.tensor_name)
}
#if LANG_CXX11
inline void TensorAnnotation::set_tensor_name(::std::string&& value) {
  set_has_tensor_name();
  tensor_name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorAnnotation.tensor_name)
}
#endif
inline void TensorAnnotation::set_tensor_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_tensor_name();
  tensor_name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorAnnotation.tensor_name)
}
inline void TensorAnnotation::set_tensor_name(const char* value, size_t size) {
  set_has_tensor_name();
  tensor_name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorAnnotation.tensor_name)
}
inline ::std::string* TensorAnnotation::mutable_tensor_name() {
  set_has_tensor_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorAnnotation.tensor_name)
  return tensor_name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorAnnotation::release_tensor_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorAnnotation.tensor_name)
  if (!has_tensor_name()) {
    return NULL;
  }
  clear_has_tensor_name();
  return tensor_name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TensorAnnotation::set_allocated_tensor_name(::std::string* tensor_name) {
  if (tensor_name != NULL) {
    set_has_tensor_name();
  } else {
    clear_has_tensor_name();
  }
  tensor_name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), tensor_name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorAnnotation.tensor_name)
}

// repeated .onnx_torch.StringStringEntryProto quant_parameter_tensor_names = 2;
inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
  return quant_parameter_tensor_names_.size();
}
inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
  quant_parameter_tensor_names_.Clear();
}
inline ::onnx_torch::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorAnnotation.quant_parameter_tensor_names)
  return quant_parameter_tensor_names_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
TensorAnnotation::mutable_quant_parameter_tensor_names() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorAnnotation.quant_parameter_tensor_names)
  return &quant_parameter_tensor_names_;
}
inline const ::onnx_torch::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorAnnotation.quant_parameter_tensor_names)
  return quant_parameter_tensor_names_.Get(index);
}
inline ::onnx_torch::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() {
  // @@protoc_insertion_point(field_add:onnx_torch.TensorAnnotation.quant_parameter_tensor_names)
  return quant_parameter_tensor_names_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
TensorAnnotation::quant_parameter_tensor_names() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorAnnotation.quant_parameter_tensor_names)
  return quant_parameter_tensor_names_;
}

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

// GraphProto

// repeated .onnx_torch.NodeProto node = 1;
inline int GraphProto::node_size() const {
  return node_.size();
}
inline void GraphProto::clear_node() {
  node_.Clear();
}
inline ::onnx_torch::NodeProto* GraphProto::mutable_node(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.node)
  return node_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::NodeProto >*
GraphProto::mutable_node() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.node)
  return &node_;
}
inline const ::onnx_torch::NodeProto& GraphProto::node(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.node)
  return node_.Get(index);
}
inline ::onnx_torch::NodeProto* GraphProto::add_node() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.node)
  return node_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::NodeProto >&
GraphProto::node() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.node)
  return node_;
}

// optional string name = 2;
inline bool GraphProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GraphProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GraphProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GraphProto::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& GraphProto::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.name)
  return name_.GetNoArena();
}
inline void GraphProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.GraphProto.name)
}
#if LANG_CXX11
inline void GraphProto::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.GraphProto.name)
}
#endif
inline void GraphProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.GraphProto.name)
}
inline void GraphProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.GraphProto.name)
}
inline ::std::string* GraphProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* GraphProto::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.GraphProto.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void GraphProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.GraphProto.name)
}

// repeated .onnx_torch.TensorProto initializer = 5;
inline int GraphProto::initializer_size() const {
  return initializer_.size();
}
inline void GraphProto::clear_initializer() {
  initializer_.Clear();
}
inline ::onnx_torch::TensorProto* GraphProto::mutable_initializer(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.initializer)
  return initializer_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >*
GraphProto::mutable_initializer() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.initializer)
  return &initializer_;
}
inline const ::onnx_torch::TensorProto& GraphProto::initializer(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.initializer)
  return initializer_.Get(index);
}
inline ::onnx_torch::TensorProto* GraphProto::add_initializer() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.initializer)
  return initializer_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorProto >&
GraphProto::initializer() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.initializer)
  return initializer_;
}

// optional string doc_string = 10;
inline bool GraphProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GraphProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GraphProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GraphProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& GraphProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void GraphProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.GraphProto.doc_string)
}
#if LANG_CXX11
inline void GraphProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.GraphProto.doc_string)
}
#endif
inline void GraphProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.GraphProto.doc_string)
}
inline void GraphProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.GraphProto.doc_string)
}
inline ::std::string* GraphProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* GraphProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.GraphProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void GraphProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.GraphProto.doc_string)
}

// repeated .onnx_torch.ValueInfoProto input = 11;
inline int GraphProto::input_size() const {
  return input_.size();
}
inline void GraphProto::clear_input() {
  input_.Clear();
}
inline ::onnx_torch::ValueInfoProto* GraphProto::mutable_input(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.input)
  return input_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
GraphProto::mutable_input() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.input)
  return &input_;
}
inline const ::onnx_torch::ValueInfoProto& GraphProto::input(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.input)
  return input_.Get(index);
}
inline ::onnx_torch::ValueInfoProto* GraphProto::add_input() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.input)
  return input_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
GraphProto::input() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.input)
  return input_;
}

// repeated .onnx_torch.ValueInfoProto output = 12;
inline int GraphProto::output_size() const {
  return output_.size();
}
inline void GraphProto::clear_output() {
  output_.Clear();
}
inline ::onnx_torch::ValueInfoProto* GraphProto::mutable_output(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.output)
  return output_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
GraphProto::mutable_output() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.output)
  return &output_;
}
inline const ::onnx_torch::ValueInfoProto& GraphProto::output(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.output)
  return output_.Get(index);
}
inline ::onnx_torch::ValueInfoProto* GraphProto::add_output() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.output)
  return output_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
GraphProto::output() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.output)
  return output_;
}

// repeated .onnx_torch.ValueInfoProto value_info = 13;
inline int GraphProto::value_info_size() const {
  return value_info_.size();
}
inline void GraphProto::clear_value_info() {
  value_info_.Clear();
}
inline ::onnx_torch::ValueInfoProto* GraphProto::mutable_value_info(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.value_info)
  return value_info_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >*
GraphProto::mutable_value_info() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.value_info)
  return &value_info_;
}
inline const ::onnx_torch::ValueInfoProto& GraphProto::value_info(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.value_info)
  return value_info_.Get(index);
}
inline ::onnx_torch::ValueInfoProto* GraphProto::add_value_info() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.value_info)
  return value_info_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::ValueInfoProto >&
GraphProto::value_info() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.value_info)
  return value_info_;
}

// repeated .onnx_torch.TensorAnnotation quantization_annotation = 14;
inline int GraphProto::quantization_annotation_size() const {
  return quantization_annotation_.size();
}
inline void GraphProto::clear_quantization_annotation() {
  quantization_annotation_.Clear();
}
inline ::onnx_torch::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.GraphProto.quantization_annotation)
  return quantization_annotation_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorAnnotation >*
GraphProto::mutable_quantization_annotation() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.GraphProto.quantization_annotation)
  return &quantization_annotation_;
}
inline const ::onnx_torch::TensorAnnotation& GraphProto::quantization_annotation(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.GraphProto.quantization_annotation)
  return quantization_annotation_.Get(index);
}
inline ::onnx_torch::TensorAnnotation* GraphProto::add_quantization_annotation() {
  // @@protoc_insertion_point(field_add:onnx_torch.GraphProto.quantization_annotation)
  return quantization_annotation_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorAnnotation >&
GraphProto::quantization_annotation() const {
  // @@protoc_insertion_point(field_list:onnx_torch.GraphProto.quantization_annotation)
  return quantization_annotation_;
}

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

// TensorProto_Segment

// optional int64 begin = 1;
inline bool TensorProto_Segment::has_begin() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TensorProto_Segment::set_has_begin() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TensorProto_Segment::clear_has_begin() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TensorProto_Segment::clear_begin() {
  begin_ = GOOGLE_LONGLONG(0);
  clear_has_begin();
}
inline ::google::protobuf::int64 TensorProto_Segment::begin() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.Segment.begin)
  return begin_;
}
inline void TensorProto_Segment::set_begin(::google::protobuf::int64 value) {
  set_has_begin();
  begin_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.Segment.begin)
}

// optional int64 end = 2;
inline bool TensorProto_Segment::has_end() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TensorProto_Segment::set_has_end() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TensorProto_Segment::clear_has_end() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TensorProto_Segment::clear_end() {
  end_ = GOOGLE_LONGLONG(0);
  clear_has_end();
}
inline ::google::protobuf::int64 TensorProto_Segment::end() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.Segment.end)
  return end_;
}
inline void TensorProto_Segment::set_end(::google::protobuf::int64 value) {
  set_has_end();
  end_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.Segment.end)
}

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

// TensorProto

// repeated int64 dims = 1;
inline int TensorProto::dims_size() const {
  return dims_.size();
}
inline void TensorProto::clear_dims() {
  dims_.Clear();
}
inline ::google::protobuf::int64 TensorProto::dims(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.dims)
  return dims_.Get(index);
}
inline void TensorProto::set_dims(int index, ::google::protobuf::int64 value) {
  dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.dims)
}
inline void TensorProto::add_dims(::google::protobuf::int64 value) {
  dims_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.dims)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TensorProto::dims() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.dims)
  return dims_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TensorProto::mutable_dims() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.dims)
  return &dims_;
}

// optional int32 data_type = 2;
inline bool TensorProto::has_data_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TensorProto::set_has_data_type() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TensorProto::clear_has_data_type() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TensorProto::clear_data_type() {
  data_type_ = 0;
  clear_has_data_type();
}
inline ::google::protobuf::int32 TensorProto::data_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.data_type)
  return data_type_;
}
inline void TensorProto::set_data_type(::google::protobuf::int32 value) {
  set_has_data_type();
  data_type_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.data_type)
}

// optional .onnx_torch.TensorProto.Segment segment = 3;
inline bool TensorProto::has_segment() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TensorProto::set_has_segment() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TensorProto::clear_has_segment() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TensorProto::clear_segment() {
  if (segment_ != NULL) segment_->Clear();
  clear_has_segment();
}
inline const ::onnx_torch::TensorProto_Segment& TensorProto::_internal_segment() const {
  return *segment_;
}
inline const ::onnx_torch::TensorProto_Segment& TensorProto::segment() const {
  const ::onnx_torch::TensorProto_Segment* p = segment_;
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.segment)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TensorProto_Segment*>(
      &::onnx_torch::_TensorProto_Segment_default_instance_);
}
inline ::onnx_torch::TensorProto_Segment* TensorProto::release_segment() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorProto.segment)
  clear_has_segment();
  ::onnx_torch::TensorProto_Segment* temp = segment_;
  segment_ = NULL;
  return temp;
}
inline ::onnx_torch::TensorProto_Segment* TensorProto::mutable_segment() {
  set_has_segment();
  if (segment_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TensorProto_Segment>(GetArenaNoVirtual());
    segment_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.segment)
  return segment_;
}
inline void TensorProto::set_allocated_segment(::onnx_torch::TensorProto_Segment* segment) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete segment_;
  }
  if (segment) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      segment = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, segment, submessage_arena);
    }
    set_has_segment();
  } else {
    clear_has_segment();
  }
  segment_ = segment;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorProto.segment)
}

// repeated float float_data = 4 [packed = true];
inline int TensorProto::float_data_size() const {
  return float_data_.size();
}
inline void TensorProto::clear_float_data() {
  float_data_.Clear();
}
inline float TensorProto::float_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.float_data)
  return float_data_.Get(index);
}
inline void TensorProto::set_float_data(int index, float value) {
  float_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.float_data)
}
inline void TensorProto::add_float_data(float value) {
  float_data_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.float_data)
}
inline const ::google::protobuf::RepeatedField< float >&
TensorProto::float_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.float_data)
  return float_data_;
}
inline ::google::protobuf::RepeatedField< float >*
TensorProto::mutable_float_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.float_data)
  return &float_data_;
}

// repeated int32 int32_data = 5 [packed = true];
inline int TensorProto::int32_data_size() const {
  return int32_data_.size();
}
inline void TensorProto::clear_int32_data() {
  int32_data_.Clear();
}
inline ::google::protobuf::int32 TensorProto::int32_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.int32_data)
  return int32_data_.Get(index);
}
inline void TensorProto::set_int32_data(int index, ::google::protobuf::int32 value) {
  int32_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.int32_data)
}
inline void TensorProto::add_int32_data(::google::protobuf::int32 value) {
  int32_data_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.int32_data)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TensorProto::int32_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.int32_data)
  return int32_data_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TensorProto::mutable_int32_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.int32_data)
  return &int32_data_;
}

// repeated bytes string_data = 6;
inline int TensorProto::string_data_size() const {
  return string_data_.size();
}
inline void TensorProto::clear_string_data() {
  string_data_.Clear();
}
inline const ::std::string& TensorProto::string_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.string_data)
  return string_data_.Get(index);
}
inline ::std::string* TensorProto::mutable_string_data(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.string_data)
  return string_data_.Mutable(index);
}
inline void TensorProto::set_string_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.string_data)
  string_data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TensorProto::set_string_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.string_data)
  string_data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TensorProto::set_string_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  string_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorProto.string_data)
}
inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
  string_data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorProto.string_data)
}
inline ::std::string* TensorProto::add_string_data() {
  // @@protoc_insertion_point(field_add_mutable:onnx_torch.TensorProto.string_data)
  return string_data_.Add();
}
inline void TensorProto::add_string_data(const ::std::string& value) {
  string_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.string_data)
}
#if LANG_CXX11
inline void TensorProto::add_string_data(::std::string&& value) {
  string_data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.string_data)
}
#endif
inline void TensorProto::add_string_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  string_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:onnx_torch.TensorProto.string_data)
}
inline void TensorProto::add_string_data(const void* value, size_t size) {
  string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:onnx_torch.TensorProto.string_data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TensorProto::string_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.string_data)
  return string_data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TensorProto::mutable_string_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.string_data)
  return &string_data_;
}

// repeated int64 int64_data = 7 [packed = true];
inline int TensorProto::int64_data_size() const {
  return int64_data_.size();
}
inline void TensorProto::clear_int64_data() {
  int64_data_.Clear();
}
inline ::google::protobuf::int64 TensorProto::int64_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.int64_data)
  return int64_data_.Get(index);
}
inline void TensorProto::set_int64_data(int index, ::google::protobuf::int64 value) {
  int64_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.int64_data)
}
inline void TensorProto::add_int64_data(::google::protobuf::int64 value) {
  int64_data_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.int64_data)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TensorProto::int64_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.int64_data)
  return int64_data_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TensorProto::mutable_int64_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.int64_data)
  return &int64_data_;
}

// optional string name = 8;
inline bool TensorProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TensorProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TensorProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TensorProto::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& TensorProto::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.name)
  return name_.GetNoArena();
}
inline void TensorProto::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.name)
}
#if LANG_CXX11
inline void TensorProto::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorProto.name)
}
#endif
inline void TensorProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorProto.name)
}
inline void TensorProto::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorProto.name)
}
inline ::std::string* TensorProto::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorProto::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorProto.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TensorProto::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorProto.name)
}

// optional string doc_string = 12;
inline bool TensorProto::has_doc_string() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TensorProto::set_has_doc_string() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TensorProto::clear_has_doc_string() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TensorProto::clear_doc_string() {
  doc_string_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_doc_string();
}
inline const ::std::string& TensorProto::doc_string() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.doc_string)
  return doc_string_.GetNoArena();
}
inline void TensorProto::set_doc_string(const ::std::string& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.doc_string)
}
#if LANG_CXX11
inline void TensorProto::set_doc_string(::std::string&& value) {
  set_has_doc_string();
  doc_string_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorProto.doc_string)
}
#endif
inline void TensorProto::set_doc_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorProto.doc_string)
}
inline void TensorProto::set_doc_string(const char* value, size_t size) {
  set_has_doc_string();
  doc_string_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorProto.doc_string)
}
inline ::std::string* TensorProto::mutable_doc_string() {
  set_has_doc_string();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.doc_string)
  return doc_string_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorProto::release_doc_string() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorProto.doc_string)
  if (!has_doc_string()) {
    return NULL;
  }
  clear_has_doc_string();
  return doc_string_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TensorProto::set_allocated_doc_string(::std::string* doc_string) {
  if (doc_string != NULL) {
    set_has_doc_string();
  } else {
    clear_has_doc_string();
  }
  doc_string_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), doc_string);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorProto.doc_string)
}

// optional bytes raw_data = 9;
inline bool TensorProto::has_raw_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TensorProto::set_has_raw_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TensorProto::clear_has_raw_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TensorProto::clear_raw_data() {
  raw_data_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_raw_data();
}
inline const ::std::string& TensorProto::raw_data() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.raw_data)
  return raw_data_.GetNoArena();
}
inline void TensorProto::set_raw_data(const ::std::string& value) {
  set_has_raw_data();
  raw_data_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.raw_data)
}
#if LANG_CXX11
inline void TensorProto::set_raw_data(::std::string&& value) {
  set_has_raw_data();
  raw_data_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorProto.raw_data)
}
#endif
inline void TensorProto::set_raw_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_raw_data();
  raw_data_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorProto.raw_data)
}
inline void TensorProto::set_raw_data(const void* value, size_t size) {
  set_has_raw_data();
  raw_data_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorProto.raw_data)
}
inline ::std::string* TensorProto::mutable_raw_data() {
  set_has_raw_data();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.raw_data)
  return raw_data_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorProto::release_raw_data() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorProto.raw_data)
  if (!has_raw_data()) {
    return NULL;
  }
  clear_has_raw_data();
  return raw_data_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TensorProto::set_allocated_raw_data(::std::string* raw_data) {
  if (raw_data != NULL) {
    set_has_raw_data();
  } else {
    clear_has_raw_data();
  }
  raw_data_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), raw_data);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorProto.raw_data)
}

// repeated .onnx_torch.StringStringEntryProto external_data = 13;
inline int TensorProto::external_data_size() const {
  return external_data_.size();
}
inline void TensorProto::clear_external_data() {
  external_data_.Clear();
}
inline ::onnx_torch::StringStringEntryProto* TensorProto::mutable_external_data(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorProto.external_data)
  return external_data_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >*
TensorProto::mutable_external_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.external_data)
  return &external_data_;
}
inline const ::onnx_torch::StringStringEntryProto& TensorProto::external_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.external_data)
  return external_data_.Get(index);
}
inline ::onnx_torch::StringStringEntryProto* TensorProto::add_external_data() {
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.external_data)
  return external_data_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::StringStringEntryProto >&
TensorProto::external_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.external_data)
  return external_data_;
}

// optional .onnx_torch.TensorProto.DataLocation data_location = 14;
inline bool TensorProto::has_data_location() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TensorProto::set_has_data_location() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TensorProto::clear_has_data_location() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TensorProto::clear_data_location() {
  data_location_ = 0;
  clear_has_data_location();
}
inline ::onnx_torch::TensorProto_DataLocation TensorProto::data_location() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.data_location)
  return static_cast< ::onnx_torch::TensorProto_DataLocation >(data_location_);
}
inline void TensorProto::set_data_location(::onnx_torch::TensorProto_DataLocation value) {
  assert(::onnx_torch::TensorProto_DataLocation_IsValid(value));
  set_has_data_location();
  data_location_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.data_location)
}

// repeated double double_data = 10 [packed = true];
inline int TensorProto::double_data_size() const {
  return double_data_.size();
}
inline void TensorProto::clear_double_data() {
  double_data_.Clear();
}
inline double TensorProto::double_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.double_data)
  return double_data_.Get(index);
}
inline void TensorProto::set_double_data(int index, double value) {
  double_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.double_data)
}
inline void TensorProto::add_double_data(double value) {
  double_data_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.double_data)
}
inline const ::google::protobuf::RepeatedField< double >&
TensorProto::double_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.double_data)
  return double_data_;
}
inline ::google::protobuf::RepeatedField< double >*
TensorProto::mutable_double_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.double_data)
  return &double_data_;
}

// repeated uint64 uint64_data = 11 [packed = true];
inline int TensorProto::uint64_data_size() const {
  return uint64_data_.size();
}
inline void TensorProto::clear_uint64_data() {
  uint64_data_.Clear();
}
inline ::google::protobuf::uint64 TensorProto::uint64_data(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorProto.uint64_data)
  return uint64_data_.Get(index);
}
inline void TensorProto::set_uint64_data(int index, ::google::protobuf::uint64 value) {
  uint64_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorProto.uint64_data)
}
inline void TensorProto::add_uint64_data(::google::protobuf::uint64 value) {
  uint64_data_.Add(value);
  // @@protoc_insertion_point(field_add:onnx_torch.TensorProto.uint64_data)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TensorProto::uint64_data() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorProto.uint64_data)
  return uint64_data_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TensorProto::mutable_uint64_data() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorProto.uint64_data)
  return &uint64_data_;
}

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

// TensorShapeProto_Dimension

// optional int64 dim_value = 1;
inline bool TensorShapeProto_Dimension::has_dim_value() const {
  return value_case() == kDimValue;
}
inline void TensorShapeProto_Dimension::set_has_dim_value() {
  _oneof_case_[0] = kDimValue;
}
inline void TensorShapeProto_Dimension::clear_dim_value() {
  if (has_dim_value()) {
    value_.dim_value_ = GOOGLE_LONGLONG(0);
    clear_has_value();
  }
}
inline ::google::protobuf::int64 TensorShapeProto_Dimension::dim_value() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorShapeProto.Dimension.dim_value)
  if (has_dim_value()) {
    return value_.dim_value_;
  }
  return GOOGLE_LONGLONG(0);
}
inline void TensorShapeProto_Dimension::set_dim_value(::google::protobuf::int64 value) {
  if (!has_dim_value()) {
    clear_value();
    set_has_dim_value();
  }
  value_.dim_value_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TensorShapeProto.Dimension.dim_value)
}

// optional string dim_param = 2;
inline bool TensorShapeProto_Dimension::has_dim_param() const {
  return value_case() == kDimParam;
}
inline void TensorShapeProto_Dimension::set_has_dim_param() {
  _oneof_case_[0] = kDimParam;
}
inline void TensorShapeProto_Dimension::clear_dim_param() {
  if (has_dim_param()) {
    value_.dim_param_.DestroyNoArena(&GetEmptyStringAlreadyInited());
    clear_has_value();
  }
}
inline const ::std::string& TensorShapeProto_Dimension::dim_param() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorShapeProto.Dimension.dim_param)
  if (has_dim_param()) {
    return value_.dim_param_.GetNoArena();
  }
  return *&GetEmptyStringAlreadyInited();
}
inline void TensorShapeProto_Dimension::set_dim_param(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.TensorShapeProto.Dimension.dim_param)
  if (!has_dim_param()) {
    clear_value();
    set_has_dim_param();
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  value_.dim_param_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorShapeProto.Dimension.dim_param)
}
#if LANG_CXX11
inline void TensorShapeProto_Dimension::set_dim_param(::std::string&& value) {
  // @@protoc_insertion_point(field_set:onnx_torch.TensorShapeProto.Dimension.dim_param)
  if (!has_dim_param()) {
    clear_value();
    set_has_dim_param();
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  value_.dim_param_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorShapeProto.Dimension.dim_param)
}
#endif
inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_dim_param()) {
    clear_value();
    set_has_dim_param();
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  value_.dim_param_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorShapeProto.Dimension.dim_param)
}
inline void TensorShapeProto_Dimension::set_dim_param(const char* value, size_t size) {
  if (!has_dim_param()) {
    clear_value();
    set_has_dim_param();
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  value_.dim_param_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorShapeProto.Dimension.dim_param)
}
inline ::std::string* TensorShapeProto_Dimension::mutable_dim_param() {
  if (!has_dim_param()) {
    clear_value();
    set_has_dim_param();
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorShapeProto.Dimension.dim_param)
  return value_.dim_param_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorShapeProto_Dimension::release_dim_param() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorShapeProto.Dimension.dim_param)
  if (has_dim_param()) {
    clear_has_value();
    return value_.dim_param_.ReleaseNoArena(&GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* dim_param) {
  if (!has_dim_param()) {
    value_.dim_param_.UnsafeSetDefault(&GetEmptyStringAlreadyInited());
  }
  clear_value();
  if (dim_param != NULL) {
    set_has_dim_param();
    value_.dim_param_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), dim_param);
  }
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorShapeProto.Dimension.dim_param)
}

// optional string denotation = 3;
inline bool TensorShapeProto_Dimension::has_denotation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TensorShapeProto_Dimension::set_has_denotation() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TensorShapeProto_Dimension::clear_has_denotation() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TensorShapeProto_Dimension::clear_denotation() {
  denotation_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_denotation();
}
inline const ::std::string& TensorShapeProto_Dimension::denotation() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorShapeProto.Dimension.denotation)
  return denotation_.GetNoArena();
}
inline void TensorShapeProto_Dimension::set_denotation(const ::std::string& value) {
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TensorShapeProto.Dimension.denotation)
}
#if LANG_CXX11
inline void TensorShapeProto_Dimension::set_denotation(::std::string&& value) {
  set_has_denotation();
  denotation_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TensorShapeProto.Dimension.denotation)
}
#endif
inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TensorShapeProto.Dimension.denotation)
}
inline void TensorShapeProto_Dimension::set_denotation(const char* value, size_t size) {
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TensorShapeProto.Dimension.denotation)
}
inline ::std::string* TensorShapeProto_Dimension::mutable_denotation() {
  set_has_denotation();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorShapeProto.Dimension.denotation)
  return denotation_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorShapeProto_Dimension::release_denotation() {
  // @@protoc_insertion_point(field_release:onnx_torch.TensorShapeProto.Dimension.denotation)
  if (!has_denotation()) {
    return NULL;
  }
  clear_has_denotation();
  return denotation_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* denotation) {
  if (denotation != NULL) {
    set_has_denotation();
  } else {
    clear_has_denotation();
  }
  denotation_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), denotation);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TensorShapeProto.Dimension.denotation)
}

inline bool TensorShapeProto_Dimension::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void TensorShapeProto_Dimension::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
  return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TensorShapeProto

// repeated .onnx_torch.TensorShapeProto.Dimension dim = 1;
inline int TensorShapeProto::dim_size() const {
  return dim_.size();
}
inline void TensorShapeProto::clear_dim() {
  dim_.Clear();
}
inline ::onnx_torch::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
  // @@protoc_insertion_point(field_mutable:onnx_torch.TensorShapeProto.dim)
  return dim_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorShapeProto_Dimension >*
TensorShapeProto::mutable_dim() {
  // @@protoc_insertion_point(field_mutable_list:onnx_torch.TensorShapeProto.dim)
  return &dim_;
}
inline const ::onnx_torch::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
  // @@protoc_insertion_point(field_get:onnx_torch.TensorShapeProto.dim)
  return dim_.Get(index);
}
inline ::onnx_torch::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
  // @@protoc_insertion_point(field_add:onnx_torch.TensorShapeProto.dim)
  return dim_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::onnx_torch::TensorShapeProto_Dimension >&
TensorShapeProto::dim() const {
  // @@protoc_insertion_point(field_list:onnx_torch.TensorShapeProto.dim)
  return dim_;
}

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

// TypeProto_Tensor

// optional int32 elem_type = 1;
inline bool TypeProto_Tensor::has_elem_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TypeProto_Tensor::set_has_elem_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TypeProto_Tensor::clear_has_elem_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TypeProto_Tensor::clear_elem_type() {
  elem_type_ = 0;
  clear_has_elem_type();
}
inline ::google::protobuf::int32 TypeProto_Tensor::elem_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Tensor.elem_type)
  return elem_type_;
}
inline void TypeProto_Tensor::set_elem_type(::google::protobuf::int32 value) {
  set_has_elem_type();
  elem_type_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.Tensor.elem_type)
}

// optional .onnx_torch.TensorShapeProto shape = 2;
inline bool TypeProto_Tensor::has_shape() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto_Tensor::set_has_shape() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto_Tensor::clear_has_shape() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto_Tensor::clear_shape() {
  if (shape_ != NULL) shape_->Clear();
  clear_has_shape();
}
inline const ::onnx_torch::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
  return *shape_;
}
inline const ::onnx_torch::TensorShapeProto& TypeProto_Tensor::shape() const {
  const ::onnx_torch::TensorShapeProto* p = shape_;
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Tensor.shape)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TensorShapeProto*>(
      &::onnx_torch::_TensorShapeProto_default_instance_);
}
inline ::onnx_torch::TensorShapeProto* TypeProto_Tensor::release_shape() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.Tensor.shape)
  clear_has_shape();
  ::onnx_torch::TensorShapeProto* temp = shape_;
  shape_ = NULL;
  return temp;
}
inline ::onnx_torch::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
  set_has_shape();
  if (shape_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TensorShapeProto>(GetArenaNoVirtual());
    shape_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.Tensor.shape)
  return shape_;
}
inline void TypeProto_Tensor::set_allocated_shape(::onnx_torch::TensorShapeProto* shape) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete shape_;
  }
  if (shape) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      shape = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    set_has_shape();
  } else {
    clear_has_shape();
  }
  shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.Tensor.shape)
}

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

// TypeProto_Sequence

// optional .onnx_torch.TypeProto elem_type = 1;
inline bool TypeProto_Sequence::has_elem_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto_Sequence::set_has_elem_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto_Sequence::clear_has_elem_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto_Sequence::clear_elem_type() {
  if (elem_type_ != NULL) elem_type_->Clear();
  clear_has_elem_type();
}
inline const ::onnx_torch::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
  return *elem_type_;
}
inline const ::onnx_torch::TypeProto& TypeProto_Sequence::elem_type() const {
  const ::onnx_torch::TypeProto* p = elem_type_;
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Sequence.elem_type)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TypeProto*>(
      &::onnx_torch::_TypeProto_default_instance_);
}
inline ::onnx_torch::TypeProto* TypeProto_Sequence::release_elem_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.Sequence.elem_type)
  clear_has_elem_type();
  ::onnx_torch::TypeProto* temp = elem_type_;
  elem_type_ = NULL;
  return temp;
}
inline ::onnx_torch::TypeProto* TypeProto_Sequence::mutable_elem_type() {
  set_has_elem_type();
  if (elem_type_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TypeProto>(GetArenaNoVirtual());
    elem_type_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.Sequence.elem_type)
  return elem_type_;
}
inline void TypeProto_Sequence::set_allocated_elem_type(::onnx_torch::TypeProto* elem_type) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete elem_type_;
  }
  if (elem_type) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      elem_type = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, elem_type, submessage_arena);
    }
    set_has_elem_type();
  } else {
    clear_has_elem_type();
  }
  elem_type_ = elem_type;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.Sequence.elem_type)
}

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

// TypeProto_Map

// optional int32 key_type = 1;
inline bool TypeProto_Map::has_key_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TypeProto_Map::set_has_key_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TypeProto_Map::clear_has_key_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TypeProto_Map::clear_key_type() {
  key_type_ = 0;
  clear_has_key_type();
}
inline ::google::protobuf::int32 TypeProto_Map::key_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Map.key_type)
  return key_type_;
}
inline void TypeProto_Map::set_key_type(::google::protobuf::int32 value) {
  set_has_key_type();
  key_type_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.Map.key_type)
}

// optional .onnx_torch.TypeProto value_type = 2;
inline bool TypeProto_Map::has_value_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto_Map::set_has_value_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto_Map::clear_has_value_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto_Map::clear_value_type() {
  if (value_type_ != NULL) value_type_->Clear();
  clear_has_value_type();
}
inline const ::onnx_torch::TypeProto& TypeProto_Map::_internal_value_type() const {
  return *value_type_;
}
inline const ::onnx_torch::TypeProto& TypeProto_Map::value_type() const {
  const ::onnx_torch::TypeProto* p = value_type_;
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Map.value_type)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TypeProto*>(
      &::onnx_torch::_TypeProto_default_instance_);
}
inline ::onnx_torch::TypeProto* TypeProto_Map::release_value_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.Map.value_type)
  clear_has_value_type();
  ::onnx_torch::TypeProto* temp = value_type_;
  value_type_ = NULL;
  return temp;
}
inline ::onnx_torch::TypeProto* TypeProto_Map::mutable_value_type() {
  set_has_value_type();
  if (value_type_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TypeProto>(GetArenaNoVirtual());
    value_type_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.Map.value_type)
  return value_type_;
}
inline void TypeProto_Map::set_allocated_value_type(::onnx_torch::TypeProto* value_type) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete value_type_;
  }
  if (value_type) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      value_type = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, value_type, submessage_arena);
    }
    set_has_value_type();
  } else {
    clear_has_value_type();
  }
  value_type_ = value_type;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.Map.value_type)
}

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

// TypeProto_Opaque

// optional string domain = 1;
inline bool TypeProto_Opaque::has_domain() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto_Opaque::set_has_domain() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto_Opaque::clear_has_domain() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto_Opaque::clear_domain() {
  domain_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_domain();
}
inline const ::std::string& TypeProto_Opaque::domain() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Opaque.domain)
  return domain_.GetNoArena();
}
inline void TypeProto_Opaque::set_domain(const ::std::string& value) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.Opaque.domain)
}
#if LANG_CXX11
inline void TypeProto_Opaque::set_domain(::std::string&& value) {
  set_has_domain();
  domain_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TypeProto.Opaque.domain)
}
#endif
inline void TypeProto_Opaque::set_domain(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TypeProto.Opaque.domain)
}
inline void TypeProto_Opaque::set_domain(const char* value, size_t size) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TypeProto.Opaque.domain)
}
inline ::std::string* TypeProto_Opaque::mutable_domain() {
  set_has_domain();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.Opaque.domain)
  return domain_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TypeProto_Opaque::release_domain() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.Opaque.domain)
  if (!has_domain()) {
    return NULL;
  }
  clear_has_domain();
  return domain_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TypeProto_Opaque::set_allocated_domain(::std::string* domain) {
  if (domain != NULL) {
    set_has_domain();
  } else {
    clear_has_domain();
  }
  domain_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), domain);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.Opaque.domain)
}

// optional string name = 2;
inline bool TypeProto_Opaque::has_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TypeProto_Opaque::set_has_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TypeProto_Opaque::clear_has_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TypeProto_Opaque::clear_name() {
  name_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& TypeProto_Opaque::name() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.Opaque.name)
  return name_.GetNoArena();
}
inline void TypeProto_Opaque::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.Opaque.name)
}
#if LANG_CXX11
inline void TypeProto_Opaque::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TypeProto.Opaque.name)
}
#endif
inline void TypeProto_Opaque::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TypeProto.Opaque.name)
}
inline void TypeProto_Opaque::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TypeProto.Opaque.name)
}
inline ::std::string* TypeProto_Opaque::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.Opaque.name)
  return name_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TypeProto_Opaque::release_name() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.Opaque.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TypeProto_Opaque::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.Opaque.name)
}

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

// TypeProto_SparseTensor

// optional int32 elem_type = 1;
inline bool TypeProto_SparseTensor::has_elem_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TypeProto_SparseTensor::set_has_elem_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TypeProto_SparseTensor::clear_has_elem_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TypeProto_SparseTensor::clear_elem_type() {
  elem_type_ = 0;
  clear_has_elem_type();
}
inline ::google::protobuf::int32 TypeProto_SparseTensor::elem_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.SparseTensor.elem_type)
  return elem_type_;
}
inline void TypeProto_SparseTensor::set_elem_type(::google::protobuf::int32 value) {
  set_has_elem_type();
  elem_type_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.SparseTensor.elem_type)
}

// optional .onnx_torch.TensorShapeProto shape = 2;
inline bool TypeProto_SparseTensor::has_shape() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto_SparseTensor::set_has_shape() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto_SparseTensor::clear_has_shape() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto_SparseTensor::clear_shape() {
  if (shape_ != NULL) shape_->Clear();
  clear_has_shape();
}
inline const ::onnx_torch::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
  return *shape_;
}
inline const ::onnx_torch::TensorShapeProto& TypeProto_SparseTensor::shape() const {
  const ::onnx_torch::TensorShapeProto* p = shape_;
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.SparseTensor.shape)
  return p != NULL ? *p : *reinterpret_cast<const ::onnx_torch::TensorShapeProto*>(
      &::onnx_torch::_TensorShapeProto_default_instance_);
}
inline ::onnx_torch::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.SparseTensor.shape)
  clear_has_shape();
  ::onnx_torch::TensorShapeProto* temp = shape_;
  shape_ = NULL;
  return temp;
}
inline ::onnx_torch::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() {
  set_has_shape();
  if (shape_ == NULL) {
    auto* p = CreateMaybeMessage<::onnx_torch::TensorShapeProto>(GetArenaNoVirtual());
    shape_ = p;
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.SparseTensor.shape)
  return shape_;
}
inline void TypeProto_SparseTensor::set_allocated_shape(::onnx_torch::TensorShapeProto* shape) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete shape_;
  }
  if (shape) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      shape = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    set_has_shape();
  } else {
    clear_has_shape();
  }
  shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.SparseTensor.shape)
}

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

// TypeProto

// optional .onnx_torch.TypeProto.Tensor tensor_type = 1;
inline bool TypeProto::has_tensor_type() const {
  return value_case() == kTensorType;
}
inline void TypeProto::set_has_tensor_type() {
  _oneof_case_[0] = kTensorType;
}
inline void TypeProto::clear_tensor_type() {
  if (has_tensor_type()) {
    delete value_.tensor_type_;
    clear_has_value();
  }
}
inline const ::onnx_torch::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
  return *value_.tensor_type_;
}
inline ::onnx_torch::TypeProto_Tensor* TypeProto::release_tensor_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.tensor_type)
  if (has_tensor_type()) {
    clear_has_value();
      ::onnx_torch::TypeProto_Tensor* temp = value_.tensor_type_;
    value_.tensor_type_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::onnx_torch::TypeProto_Tensor& TypeProto::tensor_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.tensor_type)
  return has_tensor_type()
      ? *value_.tensor_type_
      : *reinterpret_cast< ::onnx_torch::TypeProto_Tensor*>(&::onnx_torch::_TypeProto_Tensor_default_instance_);
}
inline ::onnx_torch::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
  if (!has_tensor_type()) {
    clear_value();
    set_has_tensor_type();
    value_.tensor_type_ = CreateMaybeMessage< ::onnx_torch::TypeProto_Tensor >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.tensor_type)
  return value_.tensor_type_;
}

// optional .onnx_torch.TypeProto.Sequence sequence_type = 4;
inline bool TypeProto::has_sequence_type() const {
  return value_case() == kSequenceType;
}
inline void TypeProto::set_has_sequence_type() {
  _oneof_case_[0] = kSequenceType;
}
inline void TypeProto::clear_sequence_type() {
  if (has_sequence_type()) {
    delete value_.sequence_type_;
    clear_has_value();
  }
}
inline const ::onnx_torch::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
  return *value_.sequence_type_;
}
inline ::onnx_torch::TypeProto_Sequence* TypeProto::release_sequence_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.sequence_type)
  if (has_sequence_type()) {
    clear_has_value();
      ::onnx_torch::TypeProto_Sequence* temp = value_.sequence_type_;
    value_.sequence_type_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::onnx_torch::TypeProto_Sequence& TypeProto::sequence_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.sequence_type)
  return has_sequence_type()
      ? *value_.sequence_type_
      : *reinterpret_cast< ::onnx_torch::TypeProto_Sequence*>(&::onnx_torch::_TypeProto_Sequence_default_instance_);
}
inline ::onnx_torch::TypeProto_Sequence* TypeProto::mutable_sequence_type() {
  if (!has_sequence_type()) {
    clear_value();
    set_has_sequence_type();
    value_.sequence_type_ = CreateMaybeMessage< ::onnx_torch::TypeProto_Sequence >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.sequence_type)
  return value_.sequence_type_;
}

// optional .onnx_torch.TypeProto.Map map_type = 5;
inline bool TypeProto::has_map_type() const {
  return value_case() == kMapType;
}
inline void TypeProto::set_has_map_type() {
  _oneof_case_[0] = kMapType;
}
inline void TypeProto::clear_map_type() {
  if (has_map_type()) {
    delete value_.map_type_;
    clear_has_value();
  }
}
inline const ::onnx_torch::TypeProto_Map& TypeProto::_internal_map_type() const {
  return *value_.map_type_;
}
inline ::onnx_torch::TypeProto_Map* TypeProto::release_map_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.map_type)
  if (has_map_type()) {
    clear_has_value();
      ::onnx_torch::TypeProto_Map* temp = value_.map_type_;
    value_.map_type_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::onnx_torch::TypeProto_Map& TypeProto::map_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.map_type)
  return has_map_type()
      ? *value_.map_type_
      : *reinterpret_cast< ::onnx_torch::TypeProto_Map*>(&::onnx_torch::_TypeProto_Map_default_instance_);
}
inline ::onnx_torch::TypeProto_Map* TypeProto::mutable_map_type() {
  if (!has_map_type()) {
    clear_value();
    set_has_map_type();
    value_.map_type_ = CreateMaybeMessage< ::onnx_torch::TypeProto_Map >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.map_type)
  return value_.map_type_;
}

// optional .onnx_torch.TypeProto.Opaque opaque_type = 7;
inline bool TypeProto::has_opaque_type() const {
  return value_case() == kOpaqueType;
}
inline void TypeProto::set_has_opaque_type() {
  _oneof_case_[0] = kOpaqueType;
}
inline void TypeProto::clear_opaque_type() {
  if (has_opaque_type()) {
    delete value_.opaque_type_;
    clear_has_value();
  }
}
inline const ::onnx_torch::TypeProto_Opaque& TypeProto::_internal_opaque_type() const {
  return *value_.opaque_type_;
}
inline ::onnx_torch::TypeProto_Opaque* TypeProto::release_opaque_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.opaque_type)
  if (has_opaque_type()) {
    clear_has_value();
      ::onnx_torch::TypeProto_Opaque* temp = value_.opaque_type_;
    value_.opaque_type_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::onnx_torch::TypeProto_Opaque& TypeProto::opaque_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.opaque_type)
  return has_opaque_type()
      ? *value_.opaque_type_
      : *reinterpret_cast< ::onnx_torch::TypeProto_Opaque*>(&::onnx_torch::_TypeProto_Opaque_default_instance_);
}
inline ::onnx_torch::TypeProto_Opaque* TypeProto::mutable_opaque_type() {
  if (!has_opaque_type()) {
    clear_value();
    set_has_opaque_type();
    value_.opaque_type_ = CreateMaybeMessage< ::onnx_torch::TypeProto_Opaque >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.opaque_type)
  return value_.opaque_type_;
}

// optional .onnx_torch.TypeProto.SparseTensor sparse_tensor_type = 8;
inline bool TypeProto::has_sparse_tensor_type() const {
  return value_case() == kSparseTensorType;
}
inline void TypeProto::set_has_sparse_tensor_type() {
  _oneof_case_[0] = kSparseTensorType;
}
inline void TypeProto::clear_sparse_tensor_type() {
  if (has_sparse_tensor_type()) {
    delete value_.sparse_tensor_type_;
    clear_has_value();
  }
}
inline const ::onnx_torch::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
  return *value_.sparse_tensor_type_;
}
inline ::onnx_torch::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.sparse_tensor_type)
  if (has_sparse_tensor_type()) {
    clear_has_value();
      ::onnx_torch::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
    value_.sparse_tensor_type_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::onnx_torch::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.sparse_tensor_type)
  return has_sparse_tensor_type()
      ? *value_.sparse_tensor_type_
      : *reinterpret_cast< ::onnx_torch::TypeProto_SparseTensor*>(&::onnx_torch::_TypeProto_SparseTensor_default_instance_);
}
inline ::onnx_torch::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() {
  if (!has_sparse_tensor_type()) {
    clear_value();
    set_has_sparse_tensor_type();
    value_.sparse_tensor_type_ = CreateMaybeMessage< ::onnx_torch::TypeProto_SparseTensor >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.sparse_tensor_type)
  return value_.sparse_tensor_type_;
}

// optional string denotation = 6;
inline bool TypeProto::has_denotation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TypeProto::set_has_denotation() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TypeProto::clear_has_denotation() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TypeProto::clear_denotation() {
  denotation_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_denotation();
}
inline const ::std::string& TypeProto::denotation() const {
  // @@protoc_insertion_point(field_get:onnx_torch.TypeProto.denotation)
  return denotation_.GetNoArena();
}
inline void TypeProto::set_denotation(const ::std::string& value) {
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.TypeProto.denotation)
}
#if LANG_CXX11
inline void TypeProto::set_denotation(::std::string&& value) {
  set_has_denotation();
  denotation_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.TypeProto.denotation)
}
#endif
inline void TypeProto::set_denotation(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.TypeProto.denotation)
}
inline void TypeProto::set_denotation(const char* value, size_t size) {
  set_has_denotation();
  denotation_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.TypeProto.denotation)
}
inline ::std::string* TypeProto::mutable_denotation() {
  set_has_denotation();
  // @@protoc_insertion_point(field_mutable:onnx_torch.TypeProto.denotation)
  return denotation_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* TypeProto::release_denotation() {
  // @@protoc_insertion_point(field_release:onnx_torch.TypeProto.denotation)
  if (!has_denotation()) {
    return NULL;
  }
  clear_has_denotation();
  return denotation_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void TypeProto::set_allocated_denotation(::std::string* denotation) {
  if (denotation != NULL) {
    set_has_denotation();
  } else {
    clear_has_denotation();
  }
  denotation_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), denotation);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.TypeProto.denotation)
}

inline bool TypeProto::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void TypeProto::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline TypeProto::ValueCase TypeProto::value_case() const {
  return TypeProto::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// OperatorSetIdProto

// optional string domain = 1;
inline bool OperatorSetIdProto::has_domain() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperatorSetIdProto::set_has_domain() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperatorSetIdProto::clear_has_domain() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperatorSetIdProto::clear_domain() {
  domain_.ClearToEmptyNoArena(&GetEmptyStringAlreadyInited());
  clear_has_domain();
}
inline const ::std::string& OperatorSetIdProto::domain() const {
  // @@protoc_insertion_point(field_get:onnx_torch.OperatorSetIdProto.domain)
  return domain_.GetNoArena();
}
inline void OperatorSetIdProto::set_domain(const ::std::string& value) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:onnx_torch.OperatorSetIdProto.domain)
}
#if LANG_CXX11
inline void OperatorSetIdProto::set_domain(::std::string&& value) {
  set_has_domain();
  domain_.SetNoArena(
    &GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:onnx_torch.OperatorSetIdProto.domain)
}
#endif
inline void OperatorSetIdProto::set_domain(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:onnx_torch.OperatorSetIdProto.domain)
}
inline void OperatorSetIdProto::set_domain(const char* value, size_t size) {
  set_has_domain();
  domain_.SetNoArena(&GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:onnx_torch.OperatorSetIdProto.domain)
}
inline ::std::string* OperatorSetIdProto::mutable_domain() {
  set_has_domain();
  // @@protoc_insertion_point(field_mutable:onnx_torch.OperatorSetIdProto.domain)
  return domain_.MutableNoArena(&GetEmptyStringAlreadyInited());
}
inline ::std::string* OperatorSetIdProto::release_domain() {
  // @@protoc_insertion_point(field_release:onnx_torch.OperatorSetIdProto.domain)
  if (!has_domain()) {
    return NULL;
  }
  clear_has_domain();
  return domain_.ReleaseNonDefaultNoArena(&GetEmptyStringAlreadyInited());
}
inline void OperatorSetIdProto::set_allocated_domain(::std::string* domain) {
  if (domain != NULL) {
    set_has_domain();
  } else {
    clear_has_domain();
  }
  domain_.SetAllocatedNoArena(&GetEmptyStringAlreadyInited(), domain);
  // @@protoc_insertion_point(field_set_allocated:onnx_torch.OperatorSetIdProto.domain)
}

// optional int64 version = 2;
inline bool OperatorSetIdProto::has_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OperatorSetIdProto::set_has_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OperatorSetIdProto::clear_has_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OperatorSetIdProto::clear_version() {
  version_ = GOOGLE_LONGLONG(0);
  clear_has_version();
}
inline ::google::protobuf::int64 OperatorSetIdProto::version() const {
  // @@protoc_insertion_point(field_get:onnx_torch.OperatorSetIdProto.version)
  return version_;
}
inline void OperatorSetIdProto::set_version(::google::protobuf::int64 value) {
  set_has_version();
  version_ = value;
  // @@protoc_insertion_point(field_set:onnx_torch.OperatorSetIdProto.version)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace onnx_torch

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::onnx_torch::AttributeProto_AttributeType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::AttributeProto_AttributeType>() {
  return ::onnx_torch::AttributeProto_AttributeType_descriptor();
}
template <> struct is_proto_enum< ::onnx_torch::TensorProto_DataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::TensorProto_DataType>() {
  return ::onnx_torch::TensorProto_DataType_descriptor();
}
template <> struct is_proto_enum< ::onnx_torch::TensorProto_DataLocation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::TensorProto_DataLocation>() {
  return ::onnx_torch::TensorProto_DataLocation_descriptor();
}
template <> struct is_proto_enum< ::onnx_torch::Version> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::Version>() {
  return ::onnx_torch::Version_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_onnx_2fonnx_5fonnx_5ftorch_2dml_2eproto
