// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: graph_proto_v2.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv2_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv2_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021005 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_graph_5fproto_5fv2_2eproto XIR_DLLESPEC
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct XIR_DLLESPEC TableStruct_graph_5fproto_5fv2_2eproto {
  static const uint32_t offsets[];
};
XIR_DLLESPEC extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_graph_5fproto_5fv2_2eproto;
namespace serial_v2 {
class AttrDef;
struct AttrDefDefaultTypeInternal;
XIR_DLLESPEC extern AttrDefDefaultTypeInternal _AttrDef_default_instance_;
class AttrValue;
struct AttrValueDefaultTypeInternal;
XIR_DLLESPEC extern AttrValueDefaultTypeInternal _AttrValue_default_instance_;
class BoolVec;
struct BoolVecDefaultTypeInternal;
XIR_DLLESPEC extern BoolVecDefaultTypeInternal _BoolVec_default_instance_;
class Bytes;
struct BytesDefaultTypeInternal;
XIR_DLLESPEC extern BytesDefaultTypeInternal _Bytes_default_instance_;
class BytesVec;
struct BytesVecDefaultTypeInternal;
XIR_DLLESPEC extern BytesVecDefaultTypeInternal _BytesVec_default_instance_;
class DoubleVec;
struct DoubleVecDefaultTypeInternal;
XIR_DLLESPEC extern DoubleVecDefaultTypeInternal _DoubleVec_default_instance_;
class FloatVec;
struct FloatVecDefaultTypeInternal;
XIR_DLLESPEC extern FloatVecDefaultTypeInternal _FloatVec_default_instance_;
class Graph;
struct GraphDefaultTypeInternal;
XIR_DLLESPEC extern GraphDefaultTypeInternal _Graph_default_instance_;
class Graph_GraphAttrEntry_DoNotUse;
struct Graph_GraphAttrEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern Graph_GraphAttrEntry_DoNotUseDefaultTypeInternal _Graph_GraphAttrEntry_DoNotUse_default_instance_;
class Int32Vec;
struct Int32VecDefaultTypeInternal;
XIR_DLLESPEC extern Int32VecDefaultTypeInternal _Int32Vec_default_instance_;
class Int64Vec;
struct Int64VecDefaultTypeInternal;
XIR_DLLESPEC extern Int64VecDefaultTypeInternal _Int64Vec_default_instance_;
class MapString2Bytes;
struct MapString2BytesDefaultTypeInternal;
XIR_DLLESPEC extern MapString2BytesDefaultTypeInternal _MapString2Bytes_default_instance_;
class MapString2BytesVec;
struct MapString2BytesVecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2BytesVecDefaultTypeInternal _MapString2BytesVec_default_instance_;
class MapString2BytesVec_ValueEntry_DoNotUse;
struct MapString2BytesVec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2BytesVec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2BytesVec_ValueEntry_DoNotUse_default_instance_;
class MapString2Bytes_ValueEntry_DoNotUse;
struct MapString2Bytes_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Bytes_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Bytes_ValueEntry_DoNotUse_default_instance_;
class MapString2Int32;
struct MapString2Int32DefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int32DefaultTypeInternal _MapString2Int32_default_instance_;
class MapString2Int32Vec;
struct MapString2Int32VecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int32VecDefaultTypeInternal _MapString2Int32Vec_default_instance_;
class MapString2Int32Vec_ValueEntry_DoNotUse;
struct MapString2Int32Vec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int32Vec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Int32Vec_ValueEntry_DoNotUse_default_instance_;
class MapString2Int32_ValueEntry_DoNotUse;
struct MapString2Int32_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int32_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Int32_ValueEntry_DoNotUse_default_instance_;
class MapString2Int64;
struct MapString2Int64DefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int64DefaultTypeInternal _MapString2Int64_default_instance_;
class MapString2Int64Vec;
struct MapString2Int64VecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int64VecDefaultTypeInternal _MapString2Int64Vec_default_instance_;
class MapString2Int64Vec_ValueEntry_DoNotUse;
struct MapString2Int64Vec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int64Vec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Int64Vec_ValueEntry_DoNotUse_default_instance_;
class MapString2Int64_ValueEntry_DoNotUse;
struct MapString2Int64_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Int64_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Int64_ValueEntry_DoNotUse_default_instance_;
class MapString2String;
struct MapString2StringDefaultTypeInternal;
XIR_DLLESPEC extern MapString2StringDefaultTypeInternal _MapString2String_default_instance_;
class MapString2StringVec;
struct MapString2StringVecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2StringVecDefaultTypeInternal _MapString2StringVec_default_instance_;
class MapString2StringVec_ValueEntry_DoNotUse;
struct MapString2StringVec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2StringVec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2StringVec_ValueEntry_DoNotUse_default_instance_;
class MapString2String_ValueEntry_DoNotUse;
struct MapString2String_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2String_ValueEntry_DoNotUseDefaultTypeInternal _MapString2String_ValueEntry_DoNotUse_default_instance_;
class MapString2Uint32;
struct MapString2Uint32DefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint32DefaultTypeInternal _MapString2Uint32_default_instance_;
class MapString2Uint32Vec;
struct MapString2Uint32VecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint32VecDefaultTypeInternal _MapString2Uint32Vec_default_instance_;
class MapString2Uint32Vec_ValueEntry_DoNotUse;
struct MapString2Uint32Vec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint32Vec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Uint32Vec_ValueEntry_DoNotUse_default_instance_;
class MapString2Uint32_ValueEntry_DoNotUse;
struct MapString2Uint32_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint32_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Uint32_ValueEntry_DoNotUse_default_instance_;
class MapString2Uint64;
struct MapString2Uint64DefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint64DefaultTypeInternal _MapString2Uint64_default_instance_;
class MapString2Uint64Vec;
struct MapString2Uint64VecDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint64VecDefaultTypeInternal _MapString2Uint64Vec_default_instance_;
class MapString2Uint64Vec_ValueEntry_DoNotUse;
struct MapString2Uint64Vec_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint64Vec_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Uint64Vec_ValueEntry_DoNotUse_default_instance_;
class MapString2Uint64_ValueEntry_DoNotUse;
struct MapString2Uint64_ValueEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern MapString2Uint64_ValueEntry_DoNotUseDefaultTypeInternal _MapString2Uint64_ValueEntry_DoNotUse_default_instance_;
class OPNode;
struct OPNodeDefaultTypeInternal;
XIR_DLLESPEC extern OPNodeDefaultTypeInternal _OPNode_default_instance_;
class OPNode_OpAttrEntry_DoNotUse;
struct OPNode_OpAttrEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern OPNode_OpAttrEntry_DoNotUseDefaultTypeInternal _OPNode_OpAttrEntry_DoNotUse_default_instance_;
class OpArg;
struct OpArgDefaultTypeInternal;
XIR_DLLESPEC extern OpArgDefaultTypeInternal _OpArg_default_instance_;
class OpArgDef;
struct OpArgDefDefaultTypeInternal;
XIR_DLLESPEC extern OpArgDefDefaultTypeInternal _OpArgDef_default_instance_;
class OpDef;
struct OpDefDefaultTypeInternal;
XIR_DLLESPEC extern OpDefDefaultTypeInternal _OpDef_default_instance_;
class StringVec;
struct StringVecDefaultTypeInternal;
XIR_DLLESPEC extern StringVecDefaultTypeInternal _StringVec_default_instance_;
class SubGraph;
struct SubGraphDefaultTypeInternal;
XIR_DLLESPEC extern SubGraphDefaultTypeInternal _SubGraph_default_instance_;
class SubGraph_SubgAttrEntry_DoNotUse;
struct SubGraph_SubgAttrEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern SubGraph_SubgAttrEntry_DoNotUseDefaultTypeInternal _SubGraph_SubgAttrEntry_DoNotUse_default_instance_;
class Tensor;
struct TensorDefaultTypeInternal;
XIR_DLLESPEC extern TensorDefaultTypeInternal _Tensor_default_instance_;
class Tensor_TensorAttrEntry_DoNotUse;
struct Tensor_TensorAttrEntry_DoNotUseDefaultTypeInternal;
XIR_DLLESPEC extern Tensor_TensorAttrEntry_DoNotUseDefaultTypeInternal _Tensor_TensorAttrEntry_DoNotUse_default_instance_;
class Uint32Vec;
struct Uint32VecDefaultTypeInternal;
XIR_DLLESPEC extern Uint32VecDefaultTypeInternal _Uint32Vec_default_instance_;
class Uint64Vec;
struct Uint64VecDefaultTypeInternal;
XIR_DLLESPEC extern Uint64VecDefaultTypeInternal _Uint64Vec_default_instance_;
}  // namespace serial_v2
PROTOBUF_NAMESPACE_OPEN
template<> XIR_DLLESPEC ::serial_v2::AttrDef* Arena::CreateMaybeMessage<::serial_v2::AttrDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::AttrValue* Arena::CreateMaybeMessage<::serial_v2::AttrValue>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::BoolVec* Arena::CreateMaybeMessage<::serial_v2::BoolVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Bytes* Arena::CreateMaybeMessage<::serial_v2::Bytes>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::BytesVec* Arena::CreateMaybeMessage<::serial_v2::BytesVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::DoubleVec* Arena::CreateMaybeMessage<::serial_v2::DoubleVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::FloatVec* Arena::CreateMaybeMessage<::serial_v2::FloatVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Graph* Arena::CreateMaybeMessage<::serial_v2::Graph>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Graph_GraphAttrEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::Graph_GraphAttrEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Int32Vec* Arena::CreateMaybeMessage<::serial_v2::Int32Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Int64Vec* Arena::CreateMaybeMessage<::serial_v2::Int64Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Bytes* Arena::CreateMaybeMessage<::serial_v2::MapString2Bytes>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2BytesVec* Arena::CreateMaybeMessage<::serial_v2::MapString2BytesVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2BytesVec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2BytesVec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Bytes_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Bytes_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int32* Arena::CreateMaybeMessage<::serial_v2::MapString2Int32>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int32Vec* Arena::CreateMaybeMessage<::serial_v2::MapString2Int32Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int32Vec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Int32Vec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int32_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Int32_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int64* Arena::CreateMaybeMessage<::serial_v2::MapString2Int64>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int64Vec* Arena::CreateMaybeMessage<::serial_v2::MapString2Int64Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int64Vec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Int64Vec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Int64_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Int64_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2String* Arena::CreateMaybeMessage<::serial_v2::MapString2String>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2StringVec* Arena::CreateMaybeMessage<::serial_v2::MapString2StringVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2StringVec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2StringVec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2String_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2String_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint32* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint32>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint32Vec* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint32Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint32Vec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint32Vec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint32_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint32_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint64* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint64>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint64Vec* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint64Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint64Vec_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint64Vec_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::MapString2Uint64_ValueEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::MapString2Uint64_ValueEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::OPNode* Arena::CreateMaybeMessage<::serial_v2::OPNode>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::OPNode_OpAttrEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::OPNode_OpAttrEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::OpArg* Arena::CreateMaybeMessage<::serial_v2::OpArg>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::OpArgDef* Arena::CreateMaybeMessage<::serial_v2::OpArgDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::OpDef* Arena::CreateMaybeMessage<::serial_v2::OpDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::StringVec* Arena::CreateMaybeMessage<::serial_v2::StringVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::SubGraph* Arena::CreateMaybeMessage<::serial_v2::SubGraph>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::SubGraph_SubgAttrEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::SubGraph_SubgAttrEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Tensor* Arena::CreateMaybeMessage<::serial_v2::Tensor>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Tensor_TensorAttrEntry_DoNotUse* Arena::CreateMaybeMessage<::serial_v2::Tensor_TensorAttrEntry_DoNotUse>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Uint32Vec* Arena::CreateMaybeMessage<::serial_v2::Uint32Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v2::Uint64Vec* Arena::CreateMaybeMessage<::serial_v2::Uint64Vec>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace serial_v2 {

enum AttrDef_OccurType : int {
  AttrDef_OccurType_REQUIRED = 0,
  AttrDef_OccurType_OPTIONAL = 1,
  AttrDef_OccurType_AttrDef_OccurType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  AttrDef_OccurType_AttrDef_OccurType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
XIR_DLLESPEC bool AttrDef_OccurType_IsValid(int value);
constexpr AttrDef_OccurType AttrDef_OccurType_OccurType_MIN = AttrDef_OccurType_REQUIRED;
constexpr AttrDef_OccurType AttrDef_OccurType_OccurType_MAX = AttrDef_OccurType_OPTIONAL;
constexpr int AttrDef_OccurType_OccurType_ARRAYSIZE = AttrDef_OccurType_OccurType_MAX + 1;

XIR_DLLESPEC const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AttrDef_OccurType_descriptor();
template<typename T>
inline const std::string& AttrDef_OccurType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AttrDef_OccurType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AttrDef_OccurType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    AttrDef_OccurType_descriptor(), enum_t_value);
}
inline bool AttrDef_OccurType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttrDef_OccurType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AttrDef_OccurType>(
    AttrDef_OccurType_descriptor(), name, value);
}
enum OpArgDef_OccurType : int {
  OpArgDef_OccurType_REQUIRED = 0,
  OpArgDef_OccurType_OPTIONAL = 1,
  OpArgDef_OccurType_REPEATED = 2,
  OpArgDef_OccurType_REQUIRED_AND_REPEATED = 3,
  OpArgDef_OccurType_OpArgDef_OccurType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  OpArgDef_OccurType_OpArgDef_OccurType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
XIR_DLLESPEC bool OpArgDef_OccurType_IsValid(int value);
constexpr OpArgDef_OccurType OpArgDef_OccurType_OccurType_MIN = OpArgDef_OccurType_REQUIRED;
constexpr OpArgDef_OccurType OpArgDef_OccurType_OccurType_MAX = OpArgDef_OccurType_REQUIRED_AND_REPEATED;
constexpr int OpArgDef_OccurType_OccurType_ARRAYSIZE = OpArgDef_OccurType_OccurType_MAX + 1;

XIR_DLLESPEC const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpArgDef_OccurType_descriptor();
template<typename T>
inline const std::string& OpArgDef_OccurType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OpArgDef_OccurType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OpArgDef_OccurType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OpArgDef_OccurType_descriptor(), enum_t_value);
}
inline bool OpArgDef_OccurType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OpArgDef_OccurType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OpArgDef_OccurType>(
    OpArgDef_OccurType_descriptor(), name, value);
}
// ===================================================================

class Graph_GraphAttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Graph_GraphAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Graph_GraphAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  Graph_GraphAttrEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR Graph_GraphAttrEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit Graph_GraphAttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Graph_GraphAttrEntry_DoNotUse& other);
  static const Graph_GraphAttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Graph_GraphAttrEntry_DoNotUse*>(&_Graph_GraphAttrEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.Graph.GraphAttrEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC Graph final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Graph) */ {
 public:
  inline Graph() : Graph(nullptr) {}
  ~Graph() override;
  explicit PROTOBUF_CONSTEXPR Graph(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Graph(const Graph& from);
  Graph(Graph&& from) noexcept
    : Graph() {
    *this = ::std::move(from);
  }

  inline Graph& operator=(const Graph& from) {
    CopyFrom(from);
    return *this;
  }
  inline Graph& operator=(Graph&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Graph& default_instance() {
    return *internal_default_instance();
  }
  static inline const Graph* internal_default_instance() {
    return reinterpret_cast<const Graph*>(
               &_Graph_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Graph& a, Graph& b) {
    a.Swap(&b);
  }
  inline void Swap(Graph* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Graph* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Graph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Graph>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Graph& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Graph& from) {
    Graph::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Graph* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Graph";
  }
  protected:
  explicit Graph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kOpNodeFieldNumber = 5,
    kGraphAttrFieldNumber = 11,
    kOpDefsFieldNumber = 101,
    kGraphNameFieldNumber = 1,
    kSubgRootFieldNumber = 10,
  };
  // repeated .serial_v2.OPNode op_node = 5;
  int op_node_size() const;
  private:
  int _internal_op_node_size() const;
  public:
  void clear_op_node();
  ::serial_v2::OPNode* mutable_op_node(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OPNode >*
      mutable_op_node();
  private:
  const ::serial_v2::OPNode& _internal_op_node(int index) const;
  ::serial_v2::OPNode* _internal_add_op_node();
  public:
  const ::serial_v2::OPNode& op_node(int index) const;
  ::serial_v2::OPNode* add_op_node();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OPNode >&
      op_node() const;

  // map<string, .serial_v2.AttrValue> graph_attr = 11;
  int graph_attr_size() const;
  private:
  int _internal_graph_attr_size() const;
  public:
  void clear_graph_attr();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      _internal_graph_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      _internal_mutable_graph_attr();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      graph_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      mutable_graph_attr();

  // repeated .serial_v2.OpDef op_defs = 101;
  int op_defs_size() const;
  private:
  int _internal_op_defs_size() const;
  public:
  void clear_op_defs();
  ::serial_v2::OpDef* mutable_op_defs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpDef >*
      mutable_op_defs();
  private:
  const ::serial_v2::OpDef& _internal_op_defs(int index) const;
  ::serial_v2::OpDef* _internal_add_op_defs();
  public:
  const ::serial_v2::OpDef& op_defs(int index) const;
  ::serial_v2::OpDef* add_op_defs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpDef >&
      op_defs() const;

  // string graph_name = 1;
  void clear_graph_name();
  const std::string& graph_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_graph_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_graph_name();
  PROTOBUF_NODISCARD std::string* release_graph_name();
  void set_allocated_graph_name(std::string* graph_name);
  private:
  const std::string& _internal_graph_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph_name(const std::string& value);
  std::string* _internal_mutable_graph_name();
  public:

  // .serial_v2.SubGraph subg_root = 10;
  bool has_subg_root() const;
  private:
  bool _internal_has_subg_root() const;
  public:
  void clear_subg_root();
  const ::serial_v2::SubGraph& subg_root() const;
  PROTOBUF_NODISCARD ::serial_v2::SubGraph* release_subg_root();
  ::serial_v2::SubGraph* mutable_subg_root();
  void set_allocated_subg_root(::serial_v2::SubGraph* subg_root);
  private:
  const ::serial_v2::SubGraph& _internal_subg_root() const;
  ::serial_v2::SubGraph* _internal_mutable_subg_root();
  public:
  void unsafe_arena_set_allocated_subg_root(
      ::serial_v2::SubGraph* subg_root);
  ::serial_v2::SubGraph* unsafe_arena_release_subg_root();

  // @@protoc_insertion_point(class_scope:serial_v2.Graph)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OPNode > op_node_;
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        Graph_GraphAttrEntry_DoNotUse,
        std::string, ::serial_v2::AttrValue,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> graph_attr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpDef > op_defs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_name_;
    ::serial_v2::SubGraph* subg_root_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class OPNode_OpAttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OPNode_OpAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OPNode_OpAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  OPNode_OpAttrEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR OPNode_OpAttrEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit OPNode_OpAttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const OPNode_OpAttrEntry_DoNotUse& other);
  static const OPNode_OpAttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OPNode_OpAttrEntry_DoNotUse*>(&_OPNode_OpAttrEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.OPNode.OpAttrEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC OPNode final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.OPNode) */ {
 public:
  inline OPNode() : OPNode(nullptr) {}
  ~OPNode() override;
  explicit PROTOBUF_CONSTEXPR OPNode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OPNode(const OPNode& from);
  OPNode(OPNode&& from) noexcept
    : OPNode() {
    *this = ::std::move(from);
  }

  inline OPNode& operator=(const OPNode& from) {
    CopyFrom(from);
    return *this;
  }
  inline OPNode& operator=(OPNode&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OPNode& default_instance() {
    return *internal_default_instance();
  }
  static inline const OPNode* internal_default_instance() {
    return reinterpret_cast<const OPNode*>(
               &_OPNode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(OPNode& a, OPNode& b) {
    a.Swap(&b);
  }
  inline void Swap(OPNode* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OPNode* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OPNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OPNode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OPNode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OPNode& from) {
    OPNode::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OPNode* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.OPNode";
  }
  protected:
  explicit OPNode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kOpAttrFieldNumber = 3,
    kArgsFieldNumber = 4,
    kOpNameFieldNumber = 1,
    kOpTypeFieldNumber = 2,
    kOutputTensorFieldNumber = 5,
  };
  // map<string, .serial_v2.AttrValue> op_attr = 3;
  int op_attr_size() const;
  private:
  int _internal_op_attr_size() const;
  public:
  void clear_op_attr();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      _internal_op_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      _internal_mutable_op_attr();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      op_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      mutable_op_attr();

  // repeated .serial_v2.OpArg args = 4;
  int args_size() const;
  private:
  int _internal_args_size() const;
  public:
  void clear_args();
  ::serial_v2::OpArg* mutable_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArg >*
      mutable_args();
  private:
  const ::serial_v2::OpArg& _internal_args(int index) const;
  ::serial_v2::OpArg* _internal_add_args();
  public:
  const ::serial_v2::OpArg& args(int index) const;
  ::serial_v2::OpArg* add_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArg >&
      args() const;

  // string op_name = 1;
  void clear_op_name();
  const std::string& op_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_op_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_op_name();
  PROTOBUF_NODISCARD std::string* release_op_name();
  void set_allocated_op_name(std::string* op_name);
  private:
  const std::string& _internal_op_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_name(const std::string& value);
  std::string* _internal_mutable_op_name();
  public:

  // string op_type = 2;
  void clear_op_type();
  const std::string& op_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_op_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_op_type();
  PROTOBUF_NODISCARD std::string* release_op_type();
  void set_allocated_op_type(std::string* op_type);
  private:
  const std::string& _internal_op_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(const std::string& value);
  std::string* _internal_mutable_op_type();
  public:

  // .serial_v2.Tensor output_tensor = 5;
  bool has_output_tensor() const;
  private:
  bool _internal_has_output_tensor() const;
  public:
  void clear_output_tensor();
  const ::serial_v2::Tensor& output_tensor() const;
  PROTOBUF_NODISCARD ::serial_v2::Tensor* release_output_tensor();
  ::serial_v2::Tensor* mutable_output_tensor();
  void set_allocated_output_tensor(::serial_v2::Tensor* output_tensor);
  private:
  const ::serial_v2::Tensor& _internal_output_tensor() const;
  ::serial_v2::Tensor* _internal_mutable_output_tensor();
  public:
  void unsafe_arena_set_allocated_output_tensor(
      ::serial_v2::Tensor* output_tensor);
  ::serial_v2::Tensor* unsafe_arena_release_output_tensor();

  // @@protoc_insertion_point(class_scope:serial_v2.OPNode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        OPNode_OpAttrEntry_DoNotUse,
        std::string, ::serial_v2::AttrValue,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> op_attr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArg > args_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
    ::serial_v2::Tensor* output_tensor_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OpArg final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.OpArg) */ {
 public:
  inline OpArg() : OpArg(nullptr) {}
  ~OpArg() override;
  explicit PROTOBUF_CONSTEXPR OpArg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OpArg(const OpArg& from);
  OpArg(OpArg&& from) noexcept
    : OpArg() {
    *this = ::std::move(from);
  }

  inline OpArg& operator=(const OpArg& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpArg& operator=(OpArg&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpArg& default_instance() {
    return *internal_default_instance();
  }
  static inline const OpArg* internal_default_instance() {
    return reinterpret_cast<const OpArg*>(
               &_OpArg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(OpArg& a, OpArg& b) {
    a.Swap(&b);
  }
  inline void Swap(OpArg* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpArg* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OpArg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpArg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OpArg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OpArg& from) {
    OpArg::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpArg* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.OpArg";
  }
  protected:
  explicit OpArg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kArgOpsFieldNumber = 2,
    kArgNameFieldNumber = 1,
  };
  // repeated string arg_ops = 2;
  int arg_ops_size() const;
  private:
  int _internal_arg_ops_size() const;
  public:
  void clear_arg_ops();
  const std::string& arg_ops(int index) const;
  std::string* mutable_arg_ops(int index);
  void set_arg_ops(int index, const std::string& value);
  void set_arg_ops(int index, std::string&& value);
  void set_arg_ops(int index, const char* value);
  void set_arg_ops(int index, const char* value, size_t size);
  std::string* add_arg_ops();
  void add_arg_ops(const std::string& value);
  void add_arg_ops(std::string&& value);
  void add_arg_ops(const char* value);
  void add_arg_ops(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& arg_ops() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_arg_ops();
  private:
  const std::string& _internal_arg_ops(int index) const;
  std::string* _internal_add_arg_ops();
  public:

  // string arg_name = 1;
  void clear_arg_name();
  const std::string& arg_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_arg_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_arg_name();
  PROTOBUF_NODISCARD std::string* release_arg_name();
  void set_allocated_arg_name(std::string* arg_name);
  private:
  const std::string& _internal_arg_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_arg_name(const std::string& value);
  std::string* _internal_mutable_arg_name();
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.OpArg)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> arg_ops_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr arg_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class Tensor_TensorAttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Tensor_TensorAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Tensor_TensorAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  Tensor_TensorAttrEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR Tensor_TensorAttrEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit Tensor_TensorAttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Tensor_TensorAttrEntry_DoNotUse& other);
  static const Tensor_TensorAttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Tensor_TensorAttrEntry_DoNotUse*>(&_Tensor_TensorAttrEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.Tensor.TensorAttrEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC Tensor final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Tensor) */ {
 public:
  inline Tensor() : Tensor(nullptr) {}
  ~Tensor() override;
  explicit PROTOBUF_CONSTEXPR Tensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Tensor(const Tensor& from);
  Tensor(Tensor&& from) noexcept
    : Tensor() {
    *this = ::std::move(from);
  }

  inline Tensor& operator=(const Tensor& from) {
    CopyFrom(from);
    return *this;
  }
  inline Tensor& operator=(Tensor&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Tensor& default_instance() {
    return *internal_default_instance();
  }
  static inline const Tensor* internal_default_instance() {
    return reinterpret_cast<const Tensor*>(
               &_Tensor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(Tensor& a, Tensor& b) {
    a.Swap(&b);
  }
  inline void Swap(Tensor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Tensor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Tensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Tensor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Tensor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Tensor& from) {
    Tensor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Tensor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Tensor";
  }
  protected:
  explicit Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kTensorDimFieldNumber = 2,
    kTensorAttrFieldNumber = 10,
    kTensorNameFieldNumber = 1,
    kDataTypeFieldNumber = 5,
    kTensorBitWidthFieldNumber = 6,
  };
  // repeated uint32 tensor_dim = 2;
  int tensor_dim_size() const;
  private:
  int _internal_tensor_dim_size() const;
  public:
  void clear_tensor_dim();
  private:
  uint32_t _internal_tensor_dim(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_tensor_dim() const;
  void _internal_add_tensor_dim(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_tensor_dim();
  public:
  uint32_t tensor_dim(int index) const;
  void set_tensor_dim(int index, uint32_t value);
  void add_tensor_dim(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      tensor_dim() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_tensor_dim();

  // map<string, .serial_v2.AttrValue> tensor_attr = 10;
  int tensor_attr_size() const;
  private:
  int _internal_tensor_attr_size() const;
  public:
  void clear_tensor_attr();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      _internal_tensor_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      _internal_mutable_tensor_attr();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      tensor_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      mutable_tensor_attr();

  // string tensor_name = 1;
  void clear_tensor_name();
  const std::string& tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tensor_name();
  PROTOBUF_NODISCARD std::string* release_tensor_name();
  void set_allocated_tensor_name(std::string* tensor_name);
  private:
  const std::string& _internal_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const std::string& value);
  std::string* _internal_mutable_tensor_name();
  public:

  // int32 data_type = 5;
  void clear_data_type();
  int32_t data_type() const;
  void set_data_type(int32_t value);
  private:
  int32_t _internal_data_type() const;
  void _internal_set_data_type(int32_t value);
  public:

  // int32 tensor_bit_width = 6;
  void clear_tensor_bit_width();
  int32_t tensor_bit_width() const;
  void set_tensor_bit_width(int32_t value);
  private:
  int32_t _internal_tensor_bit_width() const;
  void _internal_set_tensor_bit_width(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.Tensor)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > tensor_dim_;
    mutable std::atomic<int> _tensor_dim_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        Tensor_TensorAttrEntry_DoNotUse,
        std::string, ::serial_v2::AttrValue,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> tensor_attr_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
    int32_t data_type_;
    int32_t tensor_bit_width_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class SubGraph_SubgAttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SubGraph_SubgAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SubGraph_SubgAttrEntry_DoNotUse, 
    std::string, ::serial_v2::AttrValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  SubGraph_SubgAttrEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR SubGraph_SubgAttrEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit SubGraph_SubgAttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const SubGraph_SubgAttrEntry_DoNotUse& other);
  static const SubGraph_SubgAttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SubGraph_SubgAttrEntry_DoNotUse*>(&_SubGraph_SubgAttrEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.SubGraph.SubgAttrEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC SubGraph final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.SubGraph) */ {
 public:
  inline SubGraph() : SubGraph(nullptr) {}
  ~SubGraph() override;
  explicit PROTOBUF_CONSTEXPR SubGraph(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SubGraph(const SubGraph& from);
  SubGraph(SubGraph&& from) noexcept
    : SubGraph() {
    *this = ::std::move(from);
  }

  inline SubGraph& operator=(const SubGraph& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubGraph& operator=(SubGraph&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SubGraph& default_instance() {
    return *internal_default_instance();
  }
  static inline const SubGraph* internal_default_instance() {
    return reinterpret_cast<const SubGraph*>(
               &_SubGraph_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(SubGraph& a, SubGraph& b) {
    a.Swap(&b);
  }
  inline void Swap(SubGraph* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubGraph* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SubGraph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubGraph>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SubGraph& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SubGraph& from) {
    SubGraph::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SubGraph* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.SubGraph";
  }
  protected:
  explicit SubGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kOpNameFieldNumber = 3,
    kSubgAttrFieldNumber = 5,
    kSubgChildFieldNumber = 10,
    kSubgraphNameFieldNumber = 1,
  };
  // repeated string op_name = 3;
  int op_name_size() const;
  private:
  int _internal_op_name_size() const;
  public:
  void clear_op_name();
  const std::string& op_name(int index) const;
  std::string* mutable_op_name(int index);
  void set_op_name(int index, const std::string& value);
  void set_op_name(int index, std::string&& value);
  void set_op_name(int index, const char* value);
  void set_op_name(int index, const char* value, size_t size);
  std::string* add_op_name();
  void add_op_name(const std::string& value);
  void add_op_name(std::string&& value);
  void add_op_name(const char* value);
  void add_op_name(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& op_name() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_op_name();
  private:
  const std::string& _internal_op_name(int index) const;
  std::string* _internal_add_op_name();
  public:

  // map<string, .serial_v2.AttrValue> subg_attr = 5;
  int subg_attr_size() const;
  private:
  int _internal_subg_attr_size() const;
  public:
  void clear_subg_attr();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      _internal_subg_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      _internal_mutable_subg_attr();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
      subg_attr() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
      mutable_subg_attr();

  // repeated .serial_v2.SubGraph subg_child = 10;
  int subg_child_size() const;
  private:
  int _internal_subg_child_size() const;
  public:
  void clear_subg_child();
  ::serial_v2::SubGraph* mutable_subg_child(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::SubGraph >*
      mutable_subg_child();
  private:
  const ::serial_v2::SubGraph& _internal_subg_child(int index) const;
  ::serial_v2::SubGraph* _internal_add_subg_child();
  public:
  const ::serial_v2::SubGraph& subg_child(int index) const;
  ::serial_v2::SubGraph* add_subg_child();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::SubGraph >&
      subg_child() const;

  // string subgraph_name = 1;
  void clear_subgraph_name();
  const std::string& subgraph_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_subgraph_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_subgraph_name();
  PROTOBUF_NODISCARD std::string* release_subgraph_name();
  void set_allocated_subgraph_name(std::string* subgraph_name);
  private:
  const std::string& _internal_subgraph_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subgraph_name(const std::string& value);
  std::string* _internal_mutable_subgraph_name();
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.SubGraph)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> op_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        SubGraph_SubgAttrEntry_DoNotUse,
        std::string, ::serial_v2::AttrValue,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> subg_attr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::SubGraph > subg_child_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subgraph_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OpDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.OpDef) */ {
 public:
  inline OpDef() : OpDef(nullptr) {}
  ~OpDef() override;
  explicit PROTOBUF_CONSTEXPR OpDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OpDef(const OpDef& from);
  OpDef(OpDef&& from) noexcept
    : OpDef() {
    *this = ::std::move(from);
  }

  inline OpDef& operator=(const OpDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpDef& operator=(OpDef&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const OpDef* internal_default_instance() {
    return reinterpret_cast<const OpDef*>(
               &_OpDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(OpDef& a, OpDef& b) {
    a.Swap(&b);
  }
  inline void Swap(OpDef* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OpDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpDef>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OpDef& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OpDef& from) {
    OpDef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpDef* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.OpDef";
  }
  protected:
  explicit OpDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kInputArgsFieldNumber = 2,
    kAttrsFieldNumber = 3,
    kNameFieldNumber = 1,
    kAnnotationFieldNumber = 4,
  };
  // repeated .serial_v2.OpArgDef input_args = 2;
  int input_args_size() const;
  private:
  int _internal_input_args_size() const;
  public:
  void clear_input_args();
  ::serial_v2::OpArgDef* mutable_input_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArgDef >*
      mutable_input_args();
  private:
  const ::serial_v2::OpArgDef& _internal_input_args(int index) const;
  ::serial_v2::OpArgDef* _internal_add_input_args();
  public:
  const ::serial_v2::OpArgDef& input_args(int index) const;
  ::serial_v2::OpArgDef* add_input_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArgDef >&
      input_args() const;

  // repeated .serial_v2.AttrDef attrs = 3;
  int attrs_size() const;
  private:
  int _internal_attrs_size() const;
  public:
  void clear_attrs();
  ::serial_v2::AttrDef* mutable_attrs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::AttrDef >*
      mutable_attrs();
  private:
  const ::serial_v2::AttrDef& _internal_attrs(int index) const;
  ::serial_v2::AttrDef* _internal_add_attrs();
  public:
  const ::serial_v2::AttrDef& attrs(int index) const;
  ::serial_v2::AttrDef* add_attrs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::AttrDef >&
      attrs() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string annotation = 4;
  void clear_annotation();
  const std::string& annotation() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_annotation(ArgT0&& arg0, ArgT... args);
  std::string* mutable_annotation();
  PROTOBUF_NODISCARD std::string* release_annotation();
  void set_allocated_annotation(std::string* annotation);
  private:
  const std::string& _internal_annotation() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_annotation(const std::string& value);
  std::string* _internal_mutable_annotation();
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.OpDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArgDef > input_args_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::AttrDef > attrs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr annotation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC AttrDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.AttrDef) */ {
 public:
  inline AttrDef() : AttrDef(nullptr) {}
  ~AttrDef() override;
  explicit PROTOBUF_CONSTEXPR AttrDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AttrDef(const AttrDef& from);
  AttrDef(AttrDef&& from) noexcept
    : AttrDef() {
    *this = ::std::move(from);
  }

  inline AttrDef& operator=(const AttrDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttrDef& operator=(AttrDef&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AttrDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const AttrDef* internal_default_instance() {
    return reinterpret_cast<const AttrDef*>(
               &_AttrDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(AttrDef& a, AttrDef& b) {
    a.Swap(&b);
  }
  inline void Swap(AttrDef* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AttrDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AttrDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttrDef>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AttrDef& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AttrDef& from) {
    AttrDef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AttrDef* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.AttrDef";
  }
  protected:
  explicit AttrDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef AttrDef_OccurType OccurType;
  static constexpr OccurType REQUIRED =
    AttrDef_OccurType_REQUIRED;
  static constexpr OccurType OPTIONAL =
    AttrDef_OccurType_OPTIONAL;
  static inline bool OccurType_IsValid(int value) {
    return AttrDef_OccurType_IsValid(value);
  }
  static constexpr OccurType OccurType_MIN =
    AttrDef_OccurType_OccurType_MIN;
  static constexpr OccurType OccurType_MAX =
    AttrDef_OccurType_OccurType_MAX;
  static constexpr int OccurType_ARRAYSIZE =
    AttrDef_OccurType_OccurType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OccurType_descriptor() {
    return AttrDef_OccurType_descriptor();
  }
  template<typename T>
  static inline const std::string& OccurType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OccurType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OccurType_Name.");
    return AttrDef_OccurType_Name(enum_t_value);
  }
  static inline bool OccurType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OccurType* value) {
    return AttrDef_OccurType_Parse(name, value);
  }

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

  enum : int {
    kNameFieldNumber = 1,
    kAnnotationFieldNumber = 7,
    kDefaultValueFieldNumber = 4,
    kOccurTypeFieldNumber = 3,
    kListLengthFieldNumber = 6,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string annotation = 7;
  void clear_annotation();
  const std::string& annotation() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_annotation(ArgT0&& arg0, ArgT... args);
  std::string* mutable_annotation();
  PROTOBUF_NODISCARD std::string* release_annotation();
  void set_allocated_annotation(std::string* annotation);
  private:
  const std::string& _internal_annotation() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_annotation(const std::string& value);
  std::string* _internal_mutable_annotation();
  public:

  // .serial_v2.AttrValue default_value = 4;
  bool has_default_value() const;
  private:
  bool _internal_has_default_value() const;
  public:
  void clear_default_value();
  const ::serial_v2::AttrValue& default_value() const;
  PROTOBUF_NODISCARD ::serial_v2::AttrValue* release_default_value();
  ::serial_v2::AttrValue* mutable_default_value();
  void set_allocated_default_value(::serial_v2::AttrValue* default_value);
  private:
  const ::serial_v2::AttrValue& _internal_default_value() const;
  ::serial_v2::AttrValue* _internal_mutable_default_value();
  public:
  void unsafe_arena_set_allocated_default_value(
      ::serial_v2::AttrValue* default_value);
  ::serial_v2::AttrValue* unsafe_arena_release_default_value();

  // .serial_v2.AttrDef.OccurType occur_type = 3;
  void clear_occur_type();
  ::serial_v2::AttrDef_OccurType occur_type() const;
  void set_occur_type(::serial_v2::AttrDef_OccurType value);
  private:
  ::serial_v2::AttrDef_OccurType _internal_occur_type() const;
  void _internal_set_occur_type(::serial_v2::AttrDef_OccurType value);
  public:

  // int32 list_length = 6;
  void clear_list_length();
  int32_t list_length() const;
  void set_list_length(int32_t value);
  private:
  int32_t _internal_list_length() const;
  void _internal_set_list_length(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.AttrDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr annotation_;
    ::serial_v2::AttrValue* default_value_;
    int occur_type_;
    int32_t list_length_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OpArgDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.OpArgDef) */ {
 public:
  inline OpArgDef() : OpArgDef(nullptr) {}
  ~OpArgDef() override;
  explicit PROTOBUF_CONSTEXPR OpArgDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OpArgDef(const OpArgDef& from);
  OpArgDef(OpArgDef&& from) noexcept
    : OpArgDef() {
    *this = ::std::move(from);
  }

  inline OpArgDef& operator=(const OpArgDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpArgDef& operator=(OpArgDef&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpArgDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const OpArgDef* internal_default_instance() {
    return reinterpret_cast<const OpArgDef*>(
               &_OpArgDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(OpArgDef& a, OpArgDef& b) {
    a.Swap(&b);
  }
  inline void Swap(OpArgDef* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpArgDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OpArgDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpArgDef>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OpArgDef& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OpArgDef& from) {
    OpArgDef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpArgDef* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.OpArgDef";
  }
  protected:
  explicit OpArgDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef OpArgDef_OccurType OccurType;
  static constexpr OccurType REQUIRED =
    OpArgDef_OccurType_REQUIRED;
  static constexpr OccurType OPTIONAL =
    OpArgDef_OccurType_OPTIONAL;
  static constexpr OccurType REPEATED =
    OpArgDef_OccurType_REPEATED;
  static constexpr OccurType REQUIRED_AND_REPEATED =
    OpArgDef_OccurType_REQUIRED_AND_REPEATED;
  static inline bool OccurType_IsValid(int value) {
    return OpArgDef_OccurType_IsValid(value);
  }
  static constexpr OccurType OccurType_MIN =
    OpArgDef_OccurType_OccurType_MIN;
  static constexpr OccurType OccurType_MAX =
    OpArgDef_OccurType_OccurType_MAX;
  static constexpr int OccurType_ARRAYSIZE =
    OpArgDef_OccurType_OccurType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OccurType_descriptor() {
    return OpArgDef_OccurType_descriptor();
  }
  template<typename T>
  static inline const std::string& OccurType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OccurType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OccurType_Name.");
    return OpArgDef_OccurType_Name(enum_t_value);
  }
  static inline bool OccurType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OccurType* value) {
    return OpArgDef_OccurType_Parse(name, value);
  }

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

  enum : int {
    kNameFieldNumber = 1,
    kAnnotationFieldNumber = 4,
    kOccurTypeFieldNumber = 2,
    kDataTypeFieldNumber = 3,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string annotation = 4;
  void clear_annotation();
  const std::string& annotation() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_annotation(ArgT0&& arg0, ArgT... args);
  std::string* mutable_annotation();
  PROTOBUF_NODISCARD std::string* release_annotation();
  void set_allocated_annotation(std::string* annotation);
  private:
  const std::string& _internal_annotation() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_annotation(const std::string& value);
  std::string* _internal_mutable_annotation();
  public:

  // .serial_v2.OpArgDef.OccurType occur_type = 2;
  void clear_occur_type();
  ::serial_v2::OpArgDef_OccurType occur_type() const;
  void set_occur_type(::serial_v2::OpArgDef_OccurType value);
  private:
  ::serial_v2::OpArgDef_OccurType _internal_occur_type() const;
  void _internal_set_occur_type(::serial_v2::OpArgDef_OccurType value);
  public:

  // int32 data_type = 3;
  void clear_data_type();
  int32_t data_type() const;
  void set_data_type(int32_t value);
  private:
  int32_t _internal_data_type() const;
  void _internal_set_data_type(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.OpArgDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr annotation_;
    int occur_type_;
    int32_t data_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC AttrValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.AttrValue) */ {
 public:
  inline AttrValue() : AttrValue(nullptr) {}
  ~AttrValue() override;
  explicit PROTOBUF_CONSTEXPR AttrValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AttrValue(const AttrValue& from);
  AttrValue(AttrValue&& from) noexcept
    : AttrValue() {
    *this = ::std::move(from);
  }

  inline AttrValue& operator=(const AttrValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttrValue& operator=(AttrValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AttrValue& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kBoolValue = 4,
    kInt32Value = 5,
    kUint32Value = 6,
    kInt64Value = 7,
    kUint64Value = 8,
    kFloatValue = 9,
    kDoubleValue = 10,
    kStringValue = 11,
    kBytesValue = 12,
    kBoolVecValue = 13,
    kInt32VecValue = 14,
    kUint32VecValue = 15,
    kInt64VecValue = 16,
    kUint64VecValue = 17,
    kFloatVecValue = 18,
    kDoubleVecValue = 19,
    kStringVecValue = 20,
    kBytesVecValue = 21,
    kMapString2Int32Value = 22,
    kMapString2Uint32Value = 23,
    kMapString2Int64Value = 24,
    kMapString2Uint64Value = 25,
    kMapString2StringValue = 26,
    kMapString2BytesValue = 27,
    kMapString2Int32VecValue = 28,
    kMapString2Uint32VecValue = 29,
    kMapString2Int64VecValue = 30,
    kMapString2Uint64VecValue = 31,
    kMapString2StringVecValue = 32,
    VALUE_NOT_SET = 0,
  };

  static inline const AttrValue* internal_default_instance() {
    return reinterpret_cast<const AttrValue*>(
               &_AttrValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(AttrValue& a, AttrValue& b) {
    a.Swap(&b);
  }
  inline void Swap(AttrValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AttrValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AttrValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttrValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AttrValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AttrValue& from) {
    AttrValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AttrValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.AttrValue";
  }
  protected:
  explicit AttrValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kBoolValueFieldNumber = 4,
    kInt32ValueFieldNumber = 5,
    kUint32ValueFieldNumber = 6,
    kInt64ValueFieldNumber = 7,
    kUint64ValueFieldNumber = 8,
    kFloatValueFieldNumber = 9,
    kDoubleValueFieldNumber = 10,
    kStringValueFieldNumber = 11,
    kBytesValueFieldNumber = 12,
    kBoolVecValueFieldNumber = 13,
    kInt32VecValueFieldNumber = 14,
    kUint32VecValueFieldNumber = 15,
    kInt64VecValueFieldNumber = 16,
    kUint64VecValueFieldNumber = 17,
    kFloatVecValueFieldNumber = 18,
    kDoubleVecValueFieldNumber = 19,
    kStringVecValueFieldNumber = 20,
    kBytesVecValueFieldNumber = 21,
    kMapString2Int32ValueFieldNumber = 22,
    kMapString2Uint32ValueFieldNumber = 23,
    kMapString2Int64ValueFieldNumber = 24,
    kMapString2Uint64ValueFieldNumber = 25,
    kMapString2StringValueFieldNumber = 26,
    kMapString2BytesValueFieldNumber = 27,
    kMapString2Int32VecValueFieldNumber = 28,
    kMapString2Uint32VecValueFieldNumber = 29,
    kMapString2Int64VecValueFieldNumber = 30,
    kMapString2Uint64VecValueFieldNumber = 31,
    kMapString2StringVecValueFieldNumber = 32,
  };
  // bool bool_value = 4;
  bool has_bool_value() const;
  private:
  bool _internal_has_bool_value() const;
  public:
  void clear_bool_value();
  bool bool_value() const;
  void set_bool_value(bool value);
  private:
  bool _internal_bool_value() const;
  void _internal_set_bool_value(bool value);
  public:

  // int32 int32_value = 5;
  bool has_int32_value() const;
  private:
  bool _internal_has_int32_value() const;
  public:
  void clear_int32_value();
  int32_t int32_value() const;
  void set_int32_value(int32_t value);
  private:
  int32_t _internal_int32_value() const;
  void _internal_set_int32_value(int32_t value);
  public:

  // uint32 uint32_value = 6;
  bool has_uint32_value() const;
  private:
  bool _internal_has_uint32_value() const;
  public:
  void clear_uint32_value();
  uint32_t uint32_value() const;
  void set_uint32_value(uint32_t value);
  private:
  uint32_t _internal_uint32_value() const;
  void _internal_set_uint32_value(uint32_t value);
  public:

  // int64 int64_value = 7;
  bool has_int64_value() const;
  private:
  bool _internal_has_int64_value() const;
  public:
  void clear_int64_value();
  int64_t int64_value() const;
  void set_int64_value(int64_t value);
  private:
  int64_t _internal_int64_value() const;
  void _internal_set_int64_value(int64_t value);
  public:

  // uint64 uint64_value = 8;
  bool has_uint64_value() const;
  private:
  bool _internal_has_uint64_value() const;
  public:
  void clear_uint64_value();
  uint64_t uint64_value() const;
  void set_uint64_value(uint64_t value);
  private:
  uint64_t _internal_uint64_value() const;
  void _internal_set_uint64_value(uint64_t value);
  public:

  // float float_value = 9;
  bool has_float_value() const;
  private:
  bool _internal_has_float_value() const;
  public:
  void clear_float_value();
  float float_value() const;
  void set_float_value(float value);
  private:
  float _internal_float_value() const;
  void _internal_set_float_value(float value);
  public:

  // double double_value = 10;
  bool has_double_value() const;
  private:
  bool _internal_has_double_value() const;
  public:
  void clear_double_value();
  double double_value() const;
  void set_double_value(double value);
  private:
  double _internal_double_value() const;
  void _internal_set_double_value(double value);
  public:

  // string string_value = 11;
  bool has_string_value() const;
  private:
  bool _internal_has_string_value() const;
  public:
  void clear_string_value();
  const std::string& string_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* string_value);
  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
  std::string* _internal_mutable_string_value();
  public:

  // .serial_v2.Bytes bytes_value = 12;
  bool has_bytes_value() const;
  private:
  bool _internal_has_bytes_value() const;
  public:
  void clear_bytes_value();
  const ::serial_v2::Bytes& bytes_value() const;
  PROTOBUF_NODISCARD ::serial_v2::Bytes* release_bytes_value();
  ::serial_v2::Bytes* mutable_bytes_value();
  void set_allocated_bytes_value(::serial_v2::Bytes* bytes_value);
  private:
  const ::serial_v2::Bytes& _internal_bytes_value() const;
  ::serial_v2::Bytes* _internal_mutable_bytes_value();
  public:
  void unsafe_arena_set_allocated_bytes_value(
      ::serial_v2::Bytes* bytes_value);
  ::serial_v2::Bytes* unsafe_arena_release_bytes_value();

  // .serial_v2.BoolVec bool_vec_value = 13;
  bool has_bool_vec_value() const;
  private:
  bool _internal_has_bool_vec_value() const;
  public:
  void clear_bool_vec_value();
  const ::serial_v2::BoolVec& bool_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::BoolVec* release_bool_vec_value();
  ::serial_v2::BoolVec* mutable_bool_vec_value();
  void set_allocated_bool_vec_value(::serial_v2::BoolVec* bool_vec_value);
  private:
  const ::serial_v2::BoolVec& _internal_bool_vec_value() const;
  ::serial_v2::BoolVec* _internal_mutable_bool_vec_value();
  public:
  void unsafe_arena_set_allocated_bool_vec_value(
      ::serial_v2::BoolVec* bool_vec_value);
  ::serial_v2::BoolVec* unsafe_arena_release_bool_vec_value();

  // .serial_v2.Int32Vec int32_vec_value = 14;
  bool has_int32_vec_value() const;
  private:
  bool _internal_has_int32_vec_value() const;
  public:
  void clear_int32_vec_value();
  const ::serial_v2::Int32Vec& int32_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::Int32Vec* release_int32_vec_value();
  ::serial_v2::Int32Vec* mutable_int32_vec_value();
  void set_allocated_int32_vec_value(::serial_v2::Int32Vec* int32_vec_value);
  private:
  const ::serial_v2::Int32Vec& _internal_int32_vec_value() const;
  ::serial_v2::Int32Vec* _internal_mutable_int32_vec_value();
  public:
  void unsafe_arena_set_allocated_int32_vec_value(
      ::serial_v2::Int32Vec* int32_vec_value);
  ::serial_v2::Int32Vec* unsafe_arena_release_int32_vec_value();

  // .serial_v2.Uint32Vec uint32_vec_value = 15;
  bool has_uint32_vec_value() const;
  private:
  bool _internal_has_uint32_vec_value() const;
  public:
  void clear_uint32_vec_value();
  const ::serial_v2::Uint32Vec& uint32_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::Uint32Vec* release_uint32_vec_value();
  ::serial_v2::Uint32Vec* mutable_uint32_vec_value();
  void set_allocated_uint32_vec_value(::serial_v2::Uint32Vec* uint32_vec_value);
  private:
  const ::serial_v2::Uint32Vec& _internal_uint32_vec_value() const;
  ::serial_v2::Uint32Vec* _internal_mutable_uint32_vec_value();
  public:
  void unsafe_arena_set_allocated_uint32_vec_value(
      ::serial_v2::Uint32Vec* uint32_vec_value);
  ::serial_v2::Uint32Vec* unsafe_arena_release_uint32_vec_value();

  // .serial_v2.Int64Vec int64_vec_value = 16;
  bool has_int64_vec_value() const;
  private:
  bool _internal_has_int64_vec_value() const;
  public:
  void clear_int64_vec_value();
  const ::serial_v2::Int64Vec& int64_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::Int64Vec* release_int64_vec_value();
  ::serial_v2::Int64Vec* mutable_int64_vec_value();
  void set_allocated_int64_vec_value(::serial_v2::Int64Vec* int64_vec_value);
  private:
  const ::serial_v2::Int64Vec& _internal_int64_vec_value() const;
  ::serial_v2::Int64Vec* _internal_mutable_int64_vec_value();
  public:
  void unsafe_arena_set_allocated_int64_vec_value(
      ::serial_v2::Int64Vec* int64_vec_value);
  ::serial_v2::Int64Vec* unsafe_arena_release_int64_vec_value();

  // .serial_v2.Uint64Vec uint64_vec_value = 17;
  bool has_uint64_vec_value() const;
  private:
  bool _internal_has_uint64_vec_value() const;
  public:
  void clear_uint64_vec_value();
  const ::serial_v2::Uint64Vec& uint64_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::Uint64Vec* release_uint64_vec_value();
  ::serial_v2::Uint64Vec* mutable_uint64_vec_value();
  void set_allocated_uint64_vec_value(::serial_v2::Uint64Vec* uint64_vec_value);
  private:
  const ::serial_v2::Uint64Vec& _internal_uint64_vec_value() const;
  ::serial_v2::Uint64Vec* _internal_mutable_uint64_vec_value();
  public:
  void unsafe_arena_set_allocated_uint64_vec_value(
      ::serial_v2::Uint64Vec* uint64_vec_value);
  ::serial_v2::Uint64Vec* unsafe_arena_release_uint64_vec_value();

  // .serial_v2.FloatVec float_vec_value = 18;
  bool has_float_vec_value() const;
  private:
  bool _internal_has_float_vec_value() const;
  public:
  void clear_float_vec_value();
  const ::serial_v2::FloatVec& float_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::FloatVec* release_float_vec_value();
  ::serial_v2::FloatVec* mutable_float_vec_value();
  void set_allocated_float_vec_value(::serial_v2::FloatVec* float_vec_value);
  private:
  const ::serial_v2::FloatVec& _internal_float_vec_value() const;
  ::serial_v2::FloatVec* _internal_mutable_float_vec_value();
  public:
  void unsafe_arena_set_allocated_float_vec_value(
      ::serial_v2::FloatVec* float_vec_value);
  ::serial_v2::FloatVec* unsafe_arena_release_float_vec_value();

  // .serial_v2.DoubleVec double_vec_value = 19;
  bool has_double_vec_value() const;
  private:
  bool _internal_has_double_vec_value() const;
  public:
  void clear_double_vec_value();
  const ::serial_v2::DoubleVec& double_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::DoubleVec* release_double_vec_value();
  ::serial_v2::DoubleVec* mutable_double_vec_value();
  void set_allocated_double_vec_value(::serial_v2::DoubleVec* double_vec_value);
  private:
  const ::serial_v2::DoubleVec& _internal_double_vec_value() const;
  ::serial_v2::DoubleVec* _internal_mutable_double_vec_value();
  public:
  void unsafe_arena_set_allocated_double_vec_value(
      ::serial_v2::DoubleVec* double_vec_value);
  ::serial_v2::DoubleVec* unsafe_arena_release_double_vec_value();

  // .serial_v2.StringVec string_vec_value = 20;
  bool has_string_vec_value() const;
  private:
  bool _internal_has_string_vec_value() const;
  public:
  void clear_string_vec_value();
  const ::serial_v2::StringVec& string_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::StringVec* release_string_vec_value();
  ::serial_v2::StringVec* mutable_string_vec_value();
  void set_allocated_string_vec_value(::serial_v2::StringVec* string_vec_value);
  private:
  const ::serial_v2::StringVec& _internal_string_vec_value() const;
  ::serial_v2::StringVec* _internal_mutable_string_vec_value();
  public:
  void unsafe_arena_set_allocated_string_vec_value(
      ::serial_v2::StringVec* string_vec_value);
  ::serial_v2::StringVec* unsafe_arena_release_string_vec_value();

  // .serial_v2.BytesVec bytes_vec_value = 21;
  bool has_bytes_vec_value() const;
  private:
  bool _internal_has_bytes_vec_value() const;
  public:
  void clear_bytes_vec_value();
  const ::serial_v2::BytesVec& bytes_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::BytesVec* release_bytes_vec_value();
  ::serial_v2::BytesVec* mutable_bytes_vec_value();
  void set_allocated_bytes_vec_value(::serial_v2::BytesVec* bytes_vec_value);
  private:
  const ::serial_v2::BytesVec& _internal_bytes_vec_value() const;
  ::serial_v2::BytesVec* _internal_mutable_bytes_vec_value();
  public:
  void unsafe_arena_set_allocated_bytes_vec_value(
      ::serial_v2::BytesVec* bytes_vec_value);
  ::serial_v2::BytesVec* unsafe_arena_release_bytes_vec_value();

  // .serial_v2.MapString2Int32 map_string_2_int32_value = 22;
  bool has_map_string_2_int32_value() const;
  private:
  bool _internal_has_map_string_2_int32_value() const;
  public:
  void clear_map_string_2_int32_value();
  const ::serial_v2::MapString2Int32& map_string_2_int32_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Int32* release_map_string_2_int32_value();
  ::serial_v2::MapString2Int32* mutable_map_string_2_int32_value();
  void set_allocated_map_string_2_int32_value(::serial_v2::MapString2Int32* map_string_2_int32_value);
  private:
  const ::serial_v2::MapString2Int32& _internal_map_string_2_int32_value() const;
  ::serial_v2::MapString2Int32* _internal_mutable_map_string_2_int32_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_int32_value(
      ::serial_v2::MapString2Int32* map_string_2_int32_value);
  ::serial_v2::MapString2Int32* unsafe_arena_release_map_string_2_int32_value();

  // .serial_v2.MapString2Uint32 map_string_2_uint32_value = 23;
  bool has_map_string_2_uint32_value() const;
  private:
  bool _internal_has_map_string_2_uint32_value() const;
  public:
  void clear_map_string_2_uint32_value();
  const ::serial_v2::MapString2Uint32& map_string_2_uint32_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Uint32* release_map_string_2_uint32_value();
  ::serial_v2::MapString2Uint32* mutable_map_string_2_uint32_value();
  void set_allocated_map_string_2_uint32_value(::serial_v2::MapString2Uint32* map_string_2_uint32_value);
  private:
  const ::serial_v2::MapString2Uint32& _internal_map_string_2_uint32_value() const;
  ::serial_v2::MapString2Uint32* _internal_mutable_map_string_2_uint32_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_uint32_value(
      ::serial_v2::MapString2Uint32* map_string_2_uint32_value);
  ::serial_v2::MapString2Uint32* unsafe_arena_release_map_string_2_uint32_value();

  // .serial_v2.MapString2Int64 map_string_2_int64_value = 24;
  bool has_map_string_2_int64_value() const;
  private:
  bool _internal_has_map_string_2_int64_value() const;
  public:
  void clear_map_string_2_int64_value();
  const ::serial_v2::MapString2Int64& map_string_2_int64_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Int64* release_map_string_2_int64_value();
  ::serial_v2::MapString2Int64* mutable_map_string_2_int64_value();
  void set_allocated_map_string_2_int64_value(::serial_v2::MapString2Int64* map_string_2_int64_value);
  private:
  const ::serial_v2::MapString2Int64& _internal_map_string_2_int64_value() const;
  ::serial_v2::MapString2Int64* _internal_mutable_map_string_2_int64_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_int64_value(
      ::serial_v2::MapString2Int64* map_string_2_int64_value);
  ::serial_v2::MapString2Int64* unsafe_arena_release_map_string_2_int64_value();

  // .serial_v2.MapString2Uint64 map_string_2_uint64_value = 25;
  bool has_map_string_2_uint64_value() const;
  private:
  bool _internal_has_map_string_2_uint64_value() const;
  public:
  void clear_map_string_2_uint64_value();
  const ::serial_v2::MapString2Uint64& map_string_2_uint64_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Uint64* release_map_string_2_uint64_value();
  ::serial_v2::MapString2Uint64* mutable_map_string_2_uint64_value();
  void set_allocated_map_string_2_uint64_value(::serial_v2::MapString2Uint64* map_string_2_uint64_value);
  private:
  const ::serial_v2::MapString2Uint64& _internal_map_string_2_uint64_value() const;
  ::serial_v2::MapString2Uint64* _internal_mutable_map_string_2_uint64_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_uint64_value(
      ::serial_v2::MapString2Uint64* map_string_2_uint64_value);
  ::serial_v2::MapString2Uint64* unsafe_arena_release_map_string_2_uint64_value();

  // .serial_v2.MapString2String map_string_2_string_value = 26;
  bool has_map_string_2_string_value() const;
  private:
  bool _internal_has_map_string_2_string_value() const;
  public:
  void clear_map_string_2_string_value();
  const ::serial_v2::MapString2String& map_string_2_string_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2String* release_map_string_2_string_value();
  ::serial_v2::MapString2String* mutable_map_string_2_string_value();
  void set_allocated_map_string_2_string_value(::serial_v2::MapString2String* map_string_2_string_value);
  private:
  const ::serial_v2::MapString2String& _internal_map_string_2_string_value() const;
  ::serial_v2::MapString2String* _internal_mutable_map_string_2_string_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_string_value(
      ::serial_v2::MapString2String* map_string_2_string_value);
  ::serial_v2::MapString2String* unsafe_arena_release_map_string_2_string_value();

  // .serial_v2.MapString2Bytes map_string_2_bytes_value = 27;
  bool has_map_string_2_bytes_value() const;
  private:
  bool _internal_has_map_string_2_bytes_value() const;
  public:
  void clear_map_string_2_bytes_value();
  const ::serial_v2::MapString2Bytes& map_string_2_bytes_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Bytes* release_map_string_2_bytes_value();
  ::serial_v2::MapString2Bytes* mutable_map_string_2_bytes_value();
  void set_allocated_map_string_2_bytes_value(::serial_v2::MapString2Bytes* map_string_2_bytes_value);
  private:
  const ::serial_v2::MapString2Bytes& _internal_map_string_2_bytes_value() const;
  ::serial_v2::MapString2Bytes* _internal_mutable_map_string_2_bytes_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_bytes_value(
      ::serial_v2::MapString2Bytes* map_string_2_bytes_value);
  ::serial_v2::MapString2Bytes* unsafe_arena_release_map_string_2_bytes_value();

  // .serial_v2.MapString2Int32Vec map_string_2_int32_vec_value = 28;
  bool has_map_string_2_int32_vec_value() const;
  private:
  bool _internal_has_map_string_2_int32_vec_value() const;
  public:
  void clear_map_string_2_int32_vec_value();
  const ::serial_v2::MapString2Int32Vec& map_string_2_int32_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Int32Vec* release_map_string_2_int32_vec_value();
  ::serial_v2::MapString2Int32Vec* mutable_map_string_2_int32_vec_value();
  void set_allocated_map_string_2_int32_vec_value(::serial_v2::MapString2Int32Vec* map_string_2_int32_vec_value);
  private:
  const ::serial_v2::MapString2Int32Vec& _internal_map_string_2_int32_vec_value() const;
  ::serial_v2::MapString2Int32Vec* _internal_mutable_map_string_2_int32_vec_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_int32_vec_value(
      ::serial_v2::MapString2Int32Vec* map_string_2_int32_vec_value);
  ::serial_v2::MapString2Int32Vec* unsafe_arena_release_map_string_2_int32_vec_value();

  // .serial_v2.MapString2Uint32Vec map_string_2_uint32_vec_value = 29;
  bool has_map_string_2_uint32_vec_value() const;
  private:
  bool _internal_has_map_string_2_uint32_vec_value() const;
  public:
  void clear_map_string_2_uint32_vec_value();
  const ::serial_v2::MapString2Uint32Vec& map_string_2_uint32_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Uint32Vec* release_map_string_2_uint32_vec_value();
  ::serial_v2::MapString2Uint32Vec* mutable_map_string_2_uint32_vec_value();
  void set_allocated_map_string_2_uint32_vec_value(::serial_v2::MapString2Uint32Vec* map_string_2_uint32_vec_value);
  private:
  const ::serial_v2::MapString2Uint32Vec& _internal_map_string_2_uint32_vec_value() const;
  ::serial_v2::MapString2Uint32Vec* _internal_mutable_map_string_2_uint32_vec_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_uint32_vec_value(
      ::serial_v2::MapString2Uint32Vec* map_string_2_uint32_vec_value);
  ::serial_v2::MapString2Uint32Vec* unsafe_arena_release_map_string_2_uint32_vec_value();

  // .serial_v2.MapString2Int64Vec map_string_2_int64_vec_value = 30;
  bool has_map_string_2_int64_vec_value() const;
  private:
  bool _internal_has_map_string_2_int64_vec_value() const;
  public:
  void clear_map_string_2_int64_vec_value();
  const ::serial_v2::MapString2Int64Vec& map_string_2_int64_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Int64Vec* release_map_string_2_int64_vec_value();
  ::serial_v2::MapString2Int64Vec* mutable_map_string_2_int64_vec_value();
  void set_allocated_map_string_2_int64_vec_value(::serial_v2::MapString2Int64Vec* map_string_2_int64_vec_value);
  private:
  const ::serial_v2::MapString2Int64Vec& _internal_map_string_2_int64_vec_value() const;
  ::serial_v2::MapString2Int64Vec* _internal_mutable_map_string_2_int64_vec_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_int64_vec_value(
      ::serial_v2::MapString2Int64Vec* map_string_2_int64_vec_value);
  ::serial_v2::MapString2Int64Vec* unsafe_arena_release_map_string_2_int64_vec_value();

  // .serial_v2.MapString2Uint64Vec map_string_2_uint64_vec_value = 31;
  bool has_map_string_2_uint64_vec_value() const;
  private:
  bool _internal_has_map_string_2_uint64_vec_value() const;
  public:
  void clear_map_string_2_uint64_vec_value();
  const ::serial_v2::MapString2Uint64Vec& map_string_2_uint64_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2Uint64Vec* release_map_string_2_uint64_vec_value();
  ::serial_v2::MapString2Uint64Vec* mutable_map_string_2_uint64_vec_value();
  void set_allocated_map_string_2_uint64_vec_value(::serial_v2::MapString2Uint64Vec* map_string_2_uint64_vec_value);
  private:
  const ::serial_v2::MapString2Uint64Vec& _internal_map_string_2_uint64_vec_value() const;
  ::serial_v2::MapString2Uint64Vec* _internal_mutable_map_string_2_uint64_vec_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_uint64_vec_value(
      ::serial_v2::MapString2Uint64Vec* map_string_2_uint64_vec_value);
  ::serial_v2::MapString2Uint64Vec* unsafe_arena_release_map_string_2_uint64_vec_value();

  // .serial_v2.MapString2StringVec map_string_2_string_vec_value = 32;
  bool has_map_string_2_string_vec_value() const;
  private:
  bool _internal_has_map_string_2_string_vec_value() const;
  public:
  void clear_map_string_2_string_vec_value();
  const ::serial_v2::MapString2StringVec& map_string_2_string_vec_value() const;
  PROTOBUF_NODISCARD ::serial_v2::MapString2StringVec* release_map_string_2_string_vec_value();
  ::serial_v2::MapString2StringVec* mutable_map_string_2_string_vec_value();
  void set_allocated_map_string_2_string_vec_value(::serial_v2::MapString2StringVec* map_string_2_string_vec_value);
  private:
  const ::serial_v2::MapString2StringVec& _internal_map_string_2_string_vec_value() const;
  ::serial_v2::MapString2StringVec* _internal_mutable_map_string_2_string_vec_value();
  public:
  void unsafe_arena_set_allocated_map_string_2_string_vec_value(
      ::serial_v2::MapString2StringVec* map_string_2_string_vec_value);
  ::serial_v2::MapString2StringVec* unsafe_arena_release_map_string_2_string_vec_value();

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:serial_v2.AttrValue)
 private:
  class _Internal;
  void set_has_bool_value();
  void set_has_int32_value();
  void set_has_uint32_value();
  void set_has_int64_value();
  void set_has_uint64_value();
  void set_has_float_value();
  void set_has_double_value();
  void set_has_string_value();
  void set_has_bytes_value();
  void set_has_bool_vec_value();
  void set_has_int32_vec_value();
  void set_has_uint32_vec_value();
  void set_has_int64_vec_value();
  void set_has_uint64_vec_value();
  void set_has_float_vec_value();
  void set_has_double_vec_value();
  void set_has_string_vec_value();
  void set_has_bytes_vec_value();
  void set_has_map_string_2_int32_value();
  void set_has_map_string_2_uint32_value();
  void set_has_map_string_2_int64_value();
  void set_has_map_string_2_uint64_value();
  void set_has_map_string_2_string_value();
  void set_has_map_string_2_bytes_value();
  void set_has_map_string_2_int32_vec_value();
  void set_has_map_string_2_uint32_vec_value();
  void set_has_map_string_2_int64_vec_value();
  void set_has_map_string_2_uint64_vec_value();
  void set_has_map_string_2_string_vec_value();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ValueUnion {
      constexpr ValueUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      bool bool_value_;
      int32_t int32_value_;
      uint32_t uint32_value_;
      int64_t int64_value_;
      uint64_t uint64_value_;
      float float_value_;
      double double_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
      ::serial_v2::Bytes* bytes_value_;
      ::serial_v2::BoolVec* bool_vec_value_;
      ::serial_v2::Int32Vec* int32_vec_value_;
      ::serial_v2::Uint32Vec* uint32_vec_value_;
      ::serial_v2::Int64Vec* int64_vec_value_;
      ::serial_v2::Uint64Vec* uint64_vec_value_;
      ::serial_v2::FloatVec* float_vec_value_;
      ::serial_v2::DoubleVec* double_vec_value_;
      ::serial_v2::StringVec* string_vec_value_;
      ::serial_v2::BytesVec* bytes_vec_value_;
      ::serial_v2::MapString2Int32* map_string_2_int32_value_;
      ::serial_v2::MapString2Uint32* map_string_2_uint32_value_;
      ::serial_v2::MapString2Int64* map_string_2_int64_value_;
      ::serial_v2::MapString2Uint64* map_string_2_uint64_value_;
      ::serial_v2::MapString2String* map_string_2_string_value_;
      ::serial_v2::MapString2Bytes* map_string_2_bytes_value_;
      ::serial_v2::MapString2Int32Vec* map_string_2_int32_vec_value_;
      ::serial_v2::MapString2Uint32Vec* map_string_2_uint32_vec_value_;
      ::serial_v2::MapString2Int64Vec* map_string_2_int64_vec_value_;
      ::serial_v2::MapString2Uint64Vec* map_string_2_uint64_vec_value_;
      ::serial_v2::MapString2StringVec* map_string_2_string_vec_value_;
    } value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Bytes final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Bytes) */ {
 public:
  inline Bytes() : Bytes(nullptr) {}
  ~Bytes() override;
  explicit PROTOBUF_CONSTEXPR Bytes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Bytes(const Bytes& from);
  Bytes(Bytes&& from) noexcept
    : Bytes() {
    *this = ::std::move(from);
  }

  inline Bytes& operator=(const Bytes& from) {
    CopyFrom(from);
    return *this;
  }
  inline Bytes& operator=(Bytes&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Bytes& default_instance() {
    return *internal_default_instance();
  }
  static inline const Bytes* internal_default_instance() {
    return reinterpret_cast<const Bytes*>(
               &_Bytes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(Bytes& a, Bytes& b) {
    a.Swap(&b);
  }
  inline void Swap(Bytes* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Bytes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Bytes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Bytes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Bytes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Bytes& from) {
    Bytes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Bytes* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Bytes";
  }
  protected:
  explicit Bytes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // bytes value = 1;
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.Bytes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC BoolVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.BoolVec) */ {
 public:
  inline BoolVec() : BoolVec(nullptr) {}
  ~BoolVec() override;
  explicit PROTOBUF_CONSTEXPR BoolVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BoolVec(const BoolVec& from);
  BoolVec(BoolVec&& from) noexcept
    : BoolVec() {
    *this = ::std::move(from);
  }

  inline BoolVec& operator=(const BoolVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolVec& operator=(BoolVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoolVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const BoolVec* internal_default_instance() {
    return reinterpret_cast<const BoolVec*>(
               &_BoolVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(BoolVec& a, BoolVec& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BoolVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BoolVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BoolVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BoolVec& from) {
    BoolVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.BoolVec";
  }
  protected:
  explicit BoolVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated bool value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  bool _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_value() const;
  void _internal_add_value(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_value();
  public:
  bool value(int index) const;
  void set_value(int index, bool value);
  void add_value(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.BoolVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Int32Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Int32Vec) */ {
 public:
  inline Int32Vec() : Int32Vec(nullptr) {}
  ~Int32Vec() override;
  explicit PROTOBUF_CONSTEXPR Int32Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Int32Vec(const Int32Vec& from);
  Int32Vec(Int32Vec&& from) noexcept
    : Int32Vec() {
    *this = ::std::move(from);
  }

  inline Int32Vec& operator=(const Int32Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline Int32Vec& operator=(Int32Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Int32Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const Int32Vec* internal_default_instance() {
    return reinterpret_cast<const Int32Vec*>(
               &_Int32Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(Int32Vec& a, Int32Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(Int32Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Int32Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Int32Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Int32Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Int32Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Int32Vec& from) {
    Int32Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Int32Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Int32Vec";
  }
  protected:
  explicit Int32Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated int32 value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  int32_t _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_value() const;
  void _internal_add_value(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_value();
  public:
  int32_t value(int index) const;
  void set_value(int index, int32_t value);
  void add_value(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.Int32Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > value_;
    mutable std::atomic<int> _value_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Uint32Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Uint32Vec) */ {
 public:
  inline Uint32Vec() : Uint32Vec(nullptr) {}
  ~Uint32Vec() override;
  explicit PROTOBUF_CONSTEXPR Uint32Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Uint32Vec(const Uint32Vec& from);
  Uint32Vec(Uint32Vec&& from) noexcept
    : Uint32Vec() {
    *this = ::std::move(from);
  }

  inline Uint32Vec& operator=(const Uint32Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline Uint32Vec& operator=(Uint32Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Uint32Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const Uint32Vec* internal_default_instance() {
    return reinterpret_cast<const Uint32Vec*>(
               &_Uint32Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(Uint32Vec& a, Uint32Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(Uint32Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Uint32Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Uint32Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Uint32Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Uint32Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Uint32Vec& from) {
    Uint32Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Uint32Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Uint32Vec";
  }
  protected:
  explicit Uint32Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated uint32 value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  uint32_t _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_value() const;
  void _internal_add_value(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_value();
  public:
  uint32_t value(int index) const;
  void set_value(int index, uint32_t value);
  void add_value(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.Uint32Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > value_;
    mutable std::atomic<int> _value_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Int64Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Int64Vec) */ {
 public:
  inline Int64Vec() : Int64Vec(nullptr) {}
  ~Int64Vec() override;
  explicit PROTOBUF_CONSTEXPR Int64Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Int64Vec(const Int64Vec& from);
  Int64Vec(Int64Vec&& from) noexcept
    : Int64Vec() {
    *this = ::std::move(from);
  }

  inline Int64Vec& operator=(const Int64Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline Int64Vec& operator=(Int64Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Int64Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const Int64Vec* internal_default_instance() {
    return reinterpret_cast<const Int64Vec*>(
               &_Int64Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(Int64Vec& a, Int64Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(Int64Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Int64Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Int64Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Int64Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Int64Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Int64Vec& from) {
    Int64Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Int64Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Int64Vec";
  }
  protected:
  explicit Int64Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated int64 value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  int64_t _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_value() const;
  void _internal_add_value(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_value();
  public:
  int64_t value(int index) const;
  void set_value(int index, int64_t value);
  void add_value(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.Int64Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > value_;
    mutable std::atomic<int> _value_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Uint64Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.Uint64Vec) */ {
 public:
  inline Uint64Vec() : Uint64Vec(nullptr) {}
  ~Uint64Vec() override;
  explicit PROTOBUF_CONSTEXPR Uint64Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Uint64Vec(const Uint64Vec& from);
  Uint64Vec(Uint64Vec&& from) noexcept
    : Uint64Vec() {
    *this = ::std::move(from);
  }

  inline Uint64Vec& operator=(const Uint64Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline Uint64Vec& operator=(Uint64Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Uint64Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const Uint64Vec* internal_default_instance() {
    return reinterpret_cast<const Uint64Vec*>(
               &_Uint64Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(Uint64Vec& a, Uint64Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(Uint64Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Uint64Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Uint64Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Uint64Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Uint64Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Uint64Vec& from) {
    Uint64Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Uint64Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.Uint64Vec";
  }
  protected:
  explicit Uint64Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated uint64 value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  uint64_t _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_value() const;
  void _internal_add_value(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_value();
  public:
  uint64_t value(int index) const;
  void set_value(int index, uint64_t value);
  void add_value(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.Uint64Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > value_;
    mutable std::atomic<int> _value_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC FloatVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.FloatVec) */ {
 public:
  inline FloatVec() : FloatVec(nullptr) {}
  ~FloatVec() override;
  explicit PROTOBUF_CONSTEXPR FloatVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FloatVec(const FloatVec& from);
  FloatVec(FloatVec&& from) noexcept
    : FloatVec() {
    *this = ::std::move(from);
  }

  inline FloatVec& operator=(const FloatVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline FloatVec& operator=(FloatVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FloatVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const FloatVec* internal_default_instance() {
    return reinterpret_cast<const FloatVec*>(
               &_FloatVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(FloatVec& a, FloatVec& b) {
    a.Swap(&b);
  }
  inline void Swap(FloatVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FloatVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FloatVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FloatVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FloatVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FloatVec& from) {
    FloatVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FloatVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.FloatVec";
  }
  protected:
  explicit FloatVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated float value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  float _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_value() const;
  void _internal_add_value(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_value();
  public:
  float value(int index) const;
  void set_value(int index, float value);
  void add_value(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.FloatVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC DoubleVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.DoubleVec) */ {
 public:
  inline DoubleVec() : DoubleVec(nullptr) {}
  ~DoubleVec() override;
  explicit PROTOBUF_CONSTEXPR DoubleVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DoubleVec(const DoubleVec& from);
  DoubleVec(DoubleVec&& from) noexcept
    : DoubleVec() {
    *this = ::std::move(from);
  }

  inline DoubleVec& operator=(const DoubleVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline DoubleVec& operator=(DoubleVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DoubleVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const DoubleVec* internal_default_instance() {
    return reinterpret_cast<const DoubleVec*>(
               &_DoubleVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(DoubleVec& a, DoubleVec& b) {
    a.Swap(&b);
  }
  inline void Swap(DoubleVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DoubleVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DoubleVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DoubleVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DoubleVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DoubleVec& from) {
    DoubleVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DoubleVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.DoubleVec";
  }
  protected:
  explicit DoubleVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated double value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  double _internal_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_value() const;
  void _internal_add_value(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_value();
  public:
  double value(int index) const;
  void set_value(int index, double value);
  void add_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.DoubleVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC StringVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.StringVec) */ {
 public:
  inline StringVec() : StringVec(nullptr) {}
  ~StringVec() override;
  explicit PROTOBUF_CONSTEXPR StringVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StringVec(const StringVec& from);
  StringVec(StringVec&& from) noexcept
    : StringVec() {
    *this = ::std::move(from);
  }

  inline StringVec& operator=(const StringVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringVec& operator=(StringVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StringVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const StringVec* internal_default_instance() {
    return reinterpret_cast<const StringVec*>(
               &_StringVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(StringVec& a, StringVec& b) {
    a.Swap(&b);
  }
  inline void Swap(StringVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StringVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  StringVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StringVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StringVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const StringVec& from) {
    StringVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.StringVec";
  }
  protected:
  explicit StringVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated string value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  const std::string& value(int index) const;
  std::string* mutable_value(int index);
  void set_value(int index, const std::string& value);
  void set_value(int index, std::string&& value);
  void set_value(int index, const char* value);
  void set_value(int index, const char* value, size_t size);
  std::string* add_value();
  void add_value(const std::string& value);
  void add_value(std::string&& value);
  void add_value(const char* value);
  void add_value(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_value();
  private:
  const std::string& _internal_value(int index) const;
  std::string* _internal_add_value();
  public:

  // @@protoc_insertion_point(class_scope:serial_v2.StringVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC BytesVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.BytesVec) */ {
 public:
  inline BytesVec() : BytesVec(nullptr) {}
  ~BytesVec() override;
  explicit PROTOBUF_CONSTEXPR BytesVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BytesVec(const BytesVec& from);
  BytesVec(BytesVec&& from) noexcept
    : BytesVec() {
    *this = ::std::move(from);
  }

  inline BytesVec& operator=(const BytesVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline BytesVec& operator=(BytesVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BytesVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const BytesVec* internal_default_instance() {
    return reinterpret_cast<const BytesVec*>(
               &_BytesVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(BytesVec& a, BytesVec& b) {
    a.Swap(&b);
  }
  inline void Swap(BytesVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BytesVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BytesVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BytesVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BytesVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BytesVec& from) {
    BytesVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BytesVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.BytesVec";
  }
  protected:
  explicit BytesVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // repeated .serial_v2.Bytes value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  ::serial_v2::Bytes* mutable_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::Bytes >*
      mutable_value();
  private:
  const ::serial_v2::Bytes& _internal_value(int index) const;
  ::serial_v2::Bytes* _internal_add_value();
  public:
  const ::serial_v2::Bytes& value(int index) const;
  ::serial_v2::Bytes* add_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::Bytes >&
      value() const;

  // @@protoc_insertion_point(class_scope:serial_v2.BytesVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::Bytes > value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Int32_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int32_ValueEntry_DoNotUse, 
    std::string, int32_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int32_ValueEntry_DoNotUse, 
    std::string, int32_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> SuperType;
  MapString2Int32_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Int32_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Int32_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Int32_ValueEntry_DoNotUse& other);
  static const MapString2Int32_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Int32_ValueEntry_DoNotUse*>(&_MapString2Int32_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Int32.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Int32 final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Int32) */ {
 public:
  inline MapString2Int32() : MapString2Int32(nullptr) {}
  ~MapString2Int32() override;
  explicit PROTOBUF_CONSTEXPR MapString2Int32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Int32(const MapString2Int32& from);
  MapString2Int32(MapString2Int32&& from) noexcept
    : MapString2Int32() {
    *this = ::std::move(from);
  }

  inline MapString2Int32& operator=(const MapString2Int32& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Int32& operator=(MapString2Int32&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Int32& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Int32* internal_default_instance() {
    return reinterpret_cast<const MapString2Int32*>(
               &_MapString2Int32_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(MapString2Int32& a, MapString2Int32& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Int32* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Int32* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Int32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Int32>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Int32& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Int32& from) {
    MapString2Int32::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Int32* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Int32";
  }
  protected:
  explicit MapString2Int32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, int32> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Int32)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Int32_ValueEntry_DoNotUse,
        std::string, int32_t,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Uint32_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint32_ValueEntry_DoNotUse, 
    std::string, uint32_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint32_ValueEntry_DoNotUse, 
    std::string, uint32_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> SuperType;
  MapString2Uint32_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Uint32_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Uint32_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Uint32_ValueEntry_DoNotUse& other);
  static const MapString2Uint32_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Uint32_ValueEntry_DoNotUse*>(&_MapString2Uint32_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Uint32.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Uint32 final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Uint32) */ {
 public:
  inline MapString2Uint32() : MapString2Uint32(nullptr) {}
  ~MapString2Uint32() override;
  explicit PROTOBUF_CONSTEXPR MapString2Uint32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Uint32(const MapString2Uint32& from);
  MapString2Uint32(MapString2Uint32&& from) noexcept
    : MapString2Uint32() {
    *this = ::std::move(from);
  }

  inline MapString2Uint32& operator=(const MapString2Uint32& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Uint32& operator=(MapString2Uint32&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Uint32& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Uint32* internal_default_instance() {
    return reinterpret_cast<const MapString2Uint32*>(
               &_MapString2Uint32_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(MapString2Uint32& a, MapString2Uint32& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Uint32* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Uint32* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Uint32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Uint32>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Uint32& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Uint32& from) {
    MapString2Uint32::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Uint32* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Uint32";
  }
  protected:
  explicit MapString2Uint32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, uint32> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Uint32)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Uint32_ValueEntry_DoNotUse,
        std::string, uint32_t,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Int64_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int64_ValueEntry_DoNotUse, 
    std::string, int64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int64_ValueEntry_DoNotUse, 
    std::string, int64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> SuperType;
  MapString2Int64_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Int64_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Int64_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Int64_ValueEntry_DoNotUse& other);
  static const MapString2Int64_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Int64_ValueEntry_DoNotUse*>(&_MapString2Int64_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Int64.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Int64 final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Int64) */ {
 public:
  inline MapString2Int64() : MapString2Int64(nullptr) {}
  ~MapString2Int64() override;
  explicit PROTOBUF_CONSTEXPR MapString2Int64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Int64(const MapString2Int64& from);
  MapString2Int64(MapString2Int64&& from) noexcept
    : MapString2Int64() {
    *this = ::std::move(from);
  }

  inline MapString2Int64& operator=(const MapString2Int64& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Int64& operator=(MapString2Int64&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Int64& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Int64* internal_default_instance() {
    return reinterpret_cast<const MapString2Int64*>(
               &_MapString2Int64_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(MapString2Int64& a, MapString2Int64& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Int64* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Int64* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Int64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Int64>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Int64& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Int64& from) {
    MapString2Int64::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Int64* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Int64";
  }
  protected:
  explicit MapString2Int64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, int64> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Int64)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Int64_ValueEntry_DoNotUse,
        std::string, int64_t,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Uint64_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint64_ValueEntry_DoNotUse, 
    std::string, uint64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint64_ValueEntry_DoNotUse, 
    std::string, uint64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> SuperType;
  MapString2Uint64_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Uint64_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Uint64_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Uint64_ValueEntry_DoNotUse& other);
  static const MapString2Uint64_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Uint64_ValueEntry_DoNotUse*>(&_MapString2Uint64_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Uint64.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Uint64 final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Uint64) */ {
 public:
  inline MapString2Uint64() : MapString2Uint64(nullptr) {}
  ~MapString2Uint64() override;
  explicit PROTOBUF_CONSTEXPR MapString2Uint64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Uint64(const MapString2Uint64& from);
  MapString2Uint64(MapString2Uint64&& from) noexcept
    : MapString2Uint64() {
    *this = ::std::move(from);
  }

  inline MapString2Uint64& operator=(const MapString2Uint64& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Uint64& operator=(MapString2Uint64&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Uint64& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Uint64* internal_default_instance() {
    return reinterpret_cast<const MapString2Uint64*>(
               &_MapString2Uint64_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(MapString2Uint64& a, MapString2Uint64& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Uint64* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Uint64* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Uint64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Uint64>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Uint64& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Uint64& from) {
    MapString2Uint64::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Uint64* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Uint64";
  }
  protected:
  explicit MapString2Uint64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, uint64> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Uint64)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Uint64_ValueEntry_DoNotUse,
        std::string, uint64_t,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Bytes_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Bytes_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Bytes,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Bytes_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Bytes,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2Bytes_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Bytes_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Bytes_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Bytes_ValueEntry_DoNotUse& other);
  static const MapString2Bytes_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Bytes_ValueEntry_DoNotUse*>(&_MapString2Bytes_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Bytes.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Bytes final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Bytes) */ {
 public:
  inline MapString2Bytes() : MapString2Bytes(nullptr) {}
  ~MapString2Bytes() override;
  explicit PROTOBUF_CONSTEXPR MapString2Bytes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Bytes(const MapString2Bytes& from);
  MapString2Bytes(MapString2Bytes&& from) noexcept
    : MapString2Bytes() {
    *this = ::std::move(from);
  }

  inline MapString2Bytes& operator=(const MapString2Bytes& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Bytes& operator=(MapString2Bytes&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Bytes& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Bytes* internal_default_instance() {
    return reinterpret_cast<const MapString2Bytes*>(
               &_MapString2Bytes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(MapString2Bytes& a, MapString2Bytes& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Bytes* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Bytes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Bytes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Bytes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Bytes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Bytes& from) {
    MapString2Bytes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Bytes* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Bytes";
  }
  protected:
  explicit MapString2Bytes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.Bytes> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Bytes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Bytes_ValueEntry_DoNotUse,
        std::string, ::serial_v2::Bytes,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2String_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2String_ValueEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2String_ValueEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
  MapString2String_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2String_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2String_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2String_ValueEntry_DoNotUse& other);
  static const MapString2String_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2String_ValueEntry_DoNotUse*>(&_MapString2String_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2String.ValueEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2String.ValueEntry.value");
 }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2String final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2String) */ {
 public:
  inline MapString2String() : MapString2String(nullptr) {}
  ~MapString2String() override;
  explicit PROTOBUF_CONSTEXPR MapString2String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2String(const MapString2String& from);
  MapString2String(MapString2String&& from) noexcept
    : MapString2String() {
    *this = ::std::move(from);
  }

  inline MapString2String& operator=(const MapString2String& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2String& operator=(MapString2String&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2String& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2String* internal_default_instance() {
    return reinterpret_cast<const MapString2String*>(
               &_MapString2String_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(MapString2String& a, MapString2String& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2String* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2String* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2String>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2String& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2String& from) {
    MapString2String::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2String* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2String";
  }
  protected:
  explicit MapString2String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, string> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2String)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2String_ValueEntry_DoNotUse,
        std::string, std::string,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Int32Vec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int32Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Int32Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int32Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Int32Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2Int32Vec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Int32Vec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Int32Vec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Int32Vec_ValueEntry_DoNotUse& other);
  static const MapString2Int32Vec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Int32Vec_ValueEntry_DoNotUse*>(&_MapString2Int32Vec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Int32Vec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Int32Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Int32Vec) */ {
 public:
  inline MapString2Int32Vec() : MapString2Int32Vec(nullptr) {}
  ~MapString2Int32Vec() override;
  explicit PROTOBUF_CONSTEXPR MapString2Int32Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Int32Vec(const MapString2Int32Vec& from);
  MapString2Int32Vec(MapString2Int32Vec&& from) noexcept
    : MapString2Int32Vec() {
    *this = ::std::move(from);
  }

  inline MapString2Int32Vec& operator=(const MapString2Int32Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Int32Vec& operator=(MapString2Int32Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Int32Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Int32Vec* internal_default_instance() {
    return reinterpret_cast<const MapString2Int32Vec*>(
               &_MapString2Int32Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(MapString2Int32Vec& a, MapString2Int32Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Int32Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Int32Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Int32Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Int32Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Int32Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Int32Vec& from) {
    MapString2Int32Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Int32Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Int32Vec";
  }
  protected:
  explicit MapString2Int32Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.Int32Vec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Int32Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Int32Vec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::Int32Vec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Uint32Vec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint32Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Uint32Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint32Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Uint32Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2Uint32Vec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Uint32Vec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Uint32Vec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Uint32Vec_ValueEntry_DoNotUse& other);
  static const MapString2Uint32Vec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Uint32Vec_ValueEntry_DoNotUse*>(&_MapString2Uint32Vec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Uint32Vec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Uint32Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Uint32Vec) */ {
 public:
  inline MapString2Uint32Vec() : MapString2Uint32Vec(nullptr) {}
  ~MapString2Uint32Vec() override;
  explicit PROTOBUF_CONSTEXPR MapString2Uint32Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Uint32Vec(const MapString2Uint32Vec& from);
  MapString2Uint32Vec(MapString2Uint32Vec&& from) noexcept
    : MapString2Uint32Vec() {
    *this = ::std::move(from);
  }

  inline MapString2Uint32Vec& operator=(const MapString2Uint32Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Uint32Vec& operator=(MapString2Uint32Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Uint32Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Uint32Vec* internal_default_instance() {
    return reinterpret_cast<const MapString2Uint32Vec*>(
               &_MapString2Uint32Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(MapString2Uint32Vec& a, MapString2Uint32Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Uint32Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Uint32Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Uint32Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Uint32Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Uint32Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Uint32Vec& from) {
    MapString2Uint32Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Uint32Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Uint32Vec";
  }
  protected:
  explicit MapString2Uint32Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.Uint32Vec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Uint32Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Uint32Vec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::Uint32Vec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Int64Vec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int64Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Int64Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Int64Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Int64Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2Int64Vec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Int64Vec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Int64Vec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Int64Vec_ValueEntry_DoNotUse& other);
  static const MapString2Int64Vec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Int64Vec_ValueEntry_DoNotUse*>(&_MapString2Int64Vec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Int64Vec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Int64Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Int64Vec) */ {
 public:
  inline MapString2Int64Vec() : MapString2Int64Vec(nullptr) {}
  ~MapString2Int64Vec() override;
  explicit PROTOBUF_CONSTEXPR MapString2Int64Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Int64Vec(const MapString2Int64Vec& from);
  MapString2Int64Vec(MapString2Int64Vec&& from) noexcept
    : MapString2Int64Vec() {
    *this = ::std::move(from);
  }

  inline MapString2Int64Vec& operator=(const MapString2Int64Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Int64Vec& operator=(MapString2Int64Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Int64Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Int64Vec* internal_default_instance() {
    return reinterpret_cast<const MapString2Int64Vec*>(
               &_MapString2Int64Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(MapString2Int64Vec& a, MapString2Int64Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Int64Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Int64Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Int64Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Int64Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Int64Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Int64Vec& from) {
    MapString2Int64Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Int64Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Int64Vec";
  }
  protected:
  explicit MapString2Int64Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.Int64Vec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Int64Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Int64Vec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::Int64Vec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2Uint64Vec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint64Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Uint64Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2Uint64Vec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::Uint64Vec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2Uint64Vec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2Uint64Vec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2Uint64Vec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2Uint64Vec_ValueEntry_DoNotUse& other);
  static const MapString2Uint64Vec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2Uint64Vec_ValueEntry_DoNotUse*>(&_MapString2Uint64Vec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2Uint64Vec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2Uint64Vec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2Uint64Vec) */ {
 public:
  inline MapString2Uint64Vec() : MapString2Uint64Vec(nullptr) {}
  ~MapString2Uint64Vec() override;
  explicit PROTOBUF_CONSTEXPR MapString2Uint64Vec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2Uint64Vec(const MapString2Uint64Vec& from);
  MapString2Uint64Vec(MapString2Uint64Vec&& from) noexcept
    : MapString2Uint64Vec() {
    *this = ::std::move(from);
  }

  inline MapString2Uint64Vec& operator=(const MapString2Uint64Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2Uint64Vec& operator=(MapString2Uint64Vec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2Uint64Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2Uint64Vec* internal_default_instance() {
    return reinterpret_cast<const MapString2Uint64Vec*>(
               &_MapString2Uint64Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(MapString2Uint64Vec& a, MapString2Uint64Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2Uint64Vec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2Uint64Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2Uint64Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2Uint64Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2Uint64Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2Uint64Vec& from) {
    MapString2Uint64Vec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2Uint64Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2Uint64Vec";
  }
  protected:
  explicit MapString2Uint64Vec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.Uint64Vec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2Uint64Vec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2Uint64Vec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::Uint64Vec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2BytesVec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2BytesVec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::BytesVec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2BytesVec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::BytesVec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2BytesVec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2BytesVec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2BytesVec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2BytesVec_ValueEntry_DoNotUse& other);
  static const MapString2BytesVec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2BytesVec_ValueEntry_DoNotUse*>(&_MapString2BytesVec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2BytesVec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2BytesVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2BytesVec) */ {
 public:
  inline MapString2BytesVec() : MapString2BytesVec(nullptr) {}
  ~MapString2BytesVec() override;
  explicit PROTOBUF_CONSTEXPR MapString2BytesVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2BytesVec(const MapString2BytesVec& from);
  MapString2BytesVec(MapString2BytesVec&& from) noexcept
    : MapString2BytesVec() {
    *this = ::std::move(from);
  }

  inline MapString2BytesVec& operator=(const MapString2BytesVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2BytesVec& operator=(MapString2BytesVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2BytesVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2BytesVec* internal_default_instance() {
    return reinterpret_cast<const MapString2BytesVec*>(
               &_MapString2BytesVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(MapString2BytesVec& a, MapString2BytesVec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2BytesVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2BytesVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2BytesVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2BytesVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2BytesVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2BytesVec& from) {
    MapString2BytesVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2BytesVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2BytesVec";
  }
  protected:
  explicit MapString2BytesVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.BytesVec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2BytesVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2BytesVec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::BytesVec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// -------------------------------------------------------------------

class MapString2StringVec_ValueEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2StringVec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::StringVec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapString2StringVec_ValueEntry_DoNotUse, 
    std::string, ::serial_v2::StringVec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MapString2StringVec_ValueEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MapString2StringVec_ValueEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MapString2StringVec_ValueEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MapString2StringVec_ValueEntry_DoNotUse& other);
  static const MapString2StringVec_ValueEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapString2StringVec_ValueEntry_DoNotUse*>(&_MapString2StringVec_ValueEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "serial_v2.MapString2StringVec.ValueEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};

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

class XIR_DLLESPEC MapString2StringVec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v2.MapString2StringVec) */ {
 public:
  inline MapString2StringVec() : MapString2StringVec(nullptr) {}
  ~MapString2StringVec() override;
  explicit PROTOBUF_CONSTEXPR MapString2StringVec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MapString2StringVec(const MapString2StringVec& from);
  MapString2StringVec(MapString2StringVec&& from) noexcept
    : MapString2StringVec() {
    *this = ::std::move(from);
  }

  inline MapString2StringVec& operator=(const MapString2StringVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapString2StringVec& operator=(MapString2StringVec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MapString2StringVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const MapString2StringVec* internal_default_instance() {
    return reinterpret_cast<const MapString2StringVec*>(
               &_MapString2StringVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(MapString2StringVec& a, MapString2StringVec& b) {
    a.Swap(&b);
  }
  inline void Swap(MapString2StringVec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapString2StringVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MapString2StringVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MapString2StringVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MapString2StringVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MapString2StringVec& from) {
    MapString2StringVec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapString2StringVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v2.MapString2StringVec";
  }
  protected:
  explicit MapString2StringVec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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


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

  enum : int {
    kValueFieldNumber = 1,
  };
  // map<string, .serial_v2.StringVec> value = 1;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >&
      _internal_value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >*
      _internal_mutable_value();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >&
      value() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >*
      mutable_value();

  // @@protoc_insertion_point(class_scope:serial_v2.MapString2StringVec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        MapString2StringVec_ValueEntry_DoNotUse,
        std::string, ::serial_v2::StringVec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv2_2eproto;
};
// ===================================================================


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

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

// Graph

// string graph_name = 1;
inline void Graph::clear_graph_name() {
  _impl_.graph_name_.ClearToEmpty();
}
inline const std::string& Graph::graph_name() const {
  // @@protoc_insertion_point(field_get:serial_v2.Graph.graph_name)
  return _internal_graph_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Graph::set_graph_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.graph_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.Graph.graph_name)
}
inline std::string* Graph::mutable_graph_name() {
  std::string* _s = _internal_mutable_graph_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.Graph.graph_name)
  return _s;
}
inline const std::string& Graph::_internal_graph_name() const {
  return _impl_.graph_name_.Get();
}
inline void Graph::_internal_set_graph_name(const std::string& value) {
  
  _impl_.graph_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Graph::_internal_mutable_graph_name() {
  
  return _impl_.graph_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Graph::release_graph_name() {
  // @@protoc_insertion_point(field_release:serial_v2.Graph.graph_name)
  return _impl_.graph_name_.Release();
}
inline void Graph::set_allocated_graph_name(std::string* graph_name) {
  if (graph_name != nullptr) {
    
  } else {
    
  }
  _impl_.graph_name_.SetAllocated(graph_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.graph_name_.IsDefault()) {
    _impl_.graph_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.Graph.graph_name)
}

// repeated .serial_v2.OPNode op_node = 5;
inline int Graph::_internal_op_node_size() const {
  return _impl_.op_node_.size();
}
inline int Graph::op_node_size() const {
  return _internal_op_node_size();
}
inline void Graph::clear_op_node() {
  _impl_.op_node_.Clear();
}
inline ::serial_v2::OPNode* Graph::mutable_op_node(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.Graph.op_node)
  return _impl_.op_node_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OPNode >*
Graph::mutable_op_node() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Graph.op_node)
  return &_impl_.op_node_;
}
inline const ::serial_v2::OPNode& Graph::_internal_op_node(int index) const {
  return _impl_.op_node_.Get(index);
}
inline const ::serial_v2::OPNode& Graph::op_node(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Graph.op_node)
  return _internal_op_node(index);
}
inline ::serial_v2::OPNode* Graph::_internal_add_op_node() {
  return _impl_.op_node_.Add();
}
inline ::serial_v2::OPNode* Graph::add_op_node() {
  ::serial_v2::OPNode* _add = _internal_add_op_node();
  // @@protoc_insertion_point(field_add:serial_v2.Graph.op_node)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OPNode >&
Graph::op_node() const {
  // @@protoc_insertion_point(field_list:serial_v2.Graph.op_node)
  return _impl_.op_node_;
}

// .serial_v2.SubGraph subg_root = 10;
inline bool Graph::_internal_has_subg_root() const {
  return this != internal_default_instance() && _impl_.subg_root_ != nullptr;
}
inline bool Graph::has_subg_root() const {
  return _internal_has_subg_root();
}
inline void Graph::clear_subg_root() {
  if (GetArenaForAllocation() == nullptr && _impl_.subg_root_ != nullptr) {
    delete _impl_.subg_root_;
  }
  _impl_.subg_root_ = nullptr;
}
inline const ::serial_v2::SubGraph& Graph::_internal_subg_root() const {
  const ::serial_v2::SubGraph* p = _impl_.subg_root_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v2::SubGraph&>(
      ::serial_v2::_SubGraph_default_instance_);
}
inline const ::serial_v2::SubGraph& Graph::subg_root() const {
  // @@protoc_insertion_point(field_get:serial_v2.Graph.subg_root)
  return _internal_subg_root();
}
inline void Graph::unsafe_arena_set_allocated_subg_root(
    ::serial_v2::SubGraph* subg_root) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subg_root_);
  }
  _impl_.subg_root_ = subg_root;
  if (subg_root) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.Graph.subg_root)
}
inline ::serial_v2::SubGraph* Graph::release_subg_root() {
  
  ::serial_v2::SubGraph* temp = _impl_.subg_root_;
  _impl_.subg_root_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::serial_v2::SubGraph* Graph::unsafe_arena_release_subg_root() {
  // @@protoc_insertion_point(field_release:serial_v2.Graph.subg_root)
  
  ::serial_v2::SubGraph* temp = _impl_.subg_root_;
  _impl_.subg_root_ = nullptr;
  return temp;
}
inline ::serial_v2::SubGraph* Graph::_internal_mutable_subg_root() {
  
  if (_impl_.subg_root_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v2::SubGraph>(GetArenaForAllocation());
    _impl_.subg_root_ = p;
  }
  return _impl_.subg_root_;
}
inline ::serial_v2::SubGraph* Graph::mutable_subg_root() {
  ::serial_v2::SubGraph* _msg = _internal_mutable_subg_root();
  // @@protoc_insertion_point(field_mutable:serial_v2.Graph.subg_root)
  return _msg;
}
inline void Graph::set_allocated_subg_root(::serial_v2::SubGraph* subg_root) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.subg_root_;
  }
  if (subg_root) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subg_root);
    if (message_arena != submessage_arena) {
      subg_root = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subg_root, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.subg_root_ = subg_root;
  // @@protoc_insertion_point(field_set_allocated:serial_v2.Graph.subg_root)
}

// map<string, .serial_v2.AttrValue> graph_attr = 11;
inline int Graph::_internal_graph_attr_size() const {
  return _impl_.graph_attr_.size();
}
inline int Graph::graph_attr_size() const {
  return _internal_graph_attr_size();
}
inline void Graph::clear_graph_attr() {
  _impl_.graph_attr_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
Graph::_internal_graph_attr() const {
  return _impl_.graph_attr_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
Graph::graph_attr() const {
  // @@protoc_insertion_point(field_map:serial_v2.Graph.graph_attr)
  return _internal_graph_attr();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
Graph::_internal_mutable_graph_attr() {
  return _impl_.graph_attr_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
Graph::mutable_graph_attr() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.Graph.graph_attr)
  return _internal_mutable_graph_attr();
}

// repeated .serial_v2.OpDef op_defs = 101;
inline int Graph::_internal_op_defs_size() const {
  return _impl_.op_defs_.size();
}
inline int Graph::op_defs_size() const {
  return _internal_op_defs_size();
}
inline void Graph::clear_op_defs() {
  _impl_.op_defs_.Clear();
}
inline ::serial_v2::OpDef* Graph::mutable_op_defs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.Graph.op_defs)
  return _impl_.op_defs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpDef >*
Graph::mutable_op_defs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Graph.op_defs)
  return &_impl_.op_defs_;
}
inline const ::serial_v2::OpDef& Graph::_internal_op_defs(int index) const {
  return _impl_.op_defs_.Get(index);
}
inline const ::serial_v2::OpDef& Graph::op_defs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Graph.op_defs)
  return _internal_op_defs(index);
}
inline ::serial_v2::OpDef* Graph::_internal_add_op_defs() {
  return _impl_.op_defs_.Add();
}
inline ::serial_v2::OpDef* Graph::add_op_defs() {
  ::serial_v2::OpDef* _add = _internal_add_op_defs();
  // @@protoc_insertion_point(field_add:serial_v2.Graph.op_defs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpDef >&
Graph::op_defs() const {
  // @@protoc_insertion_point(field_list:serial_v2.Graph.op_defs)
  return _impl_.op_defs_;
}

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

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

// OPNode

// string op_name = 1;
inline void OPNode::clear_op_name() {
  _impl_.op_name_.ClearToEmpty();
}
inline const std::string& OPNode::op_name() const {
  // @@protoc_insertion_point(field_get:serial_v2.OPNode.op_name)
  return _internal_op_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OPNode::set_op_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.op_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OPNode.op_name)
}
inline std::string* OPNode::mutable_op_name() {
  std::string* _s = _internal_mutable_op_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.OPNode.op_name)
  return _s;
}
inline const std::string& OPNode::_internal_op_name() const {
  return _impl_.op_name_.Get();
}
inline void OPNode::_internal_set_op_name(const std::string& value) {
  
  _impl_.op_name_.Set(value, GetArenaForAllocation());
}
inline std::string* OPNode::_internal_mutable_op_name() {
  
  return _impl_.op_name_.Mutable(GetArenaForAllocation());
}
inline std::string* OPNode::release_op_name() {
  // @@protoc_insertion_point(field_release:serial_v2.OPNode.op_name)
  return _impl_.op_name_.Release();
}
inline void OPNode::set_allocated_op_name(std::string* op_name) {
  if (op_name != nullptr) {
    
  } else {
    
  }
  _impl_.op_name_.SetAllocated(op_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.op_name_.IsDefault()) {
    _impl_.op_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OPNode.op_name)
}

// string op_type = 2;
inline void OPNode::clear_op_type() {
  _impl_.op_type_.ClearToEmpty();
}
inline const std::string& OPNode::op_type() const {
  // @@protoc_insertion_point(field_get:serial_v2.OPNode.op_type)
  return _internal_op_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OPNode::set_op_type(ArgT0&& arg0, ArgT... args) {
 
 _impl_.op_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OPNode.op_type)
}
inline std::string* OPNode::mutable_op_type() {
  std::string* _s = _internal_mutable_op_type();
  // @@protoc_insertion_point(field_mutable:serial_v2.OPNode.op_type)
  return _s;
}
inline const std::string& OPNode::_internal_op_type() const {
  return _impl_.op_type_.Get();
}
inline void OPNode::_internal_set_op_type(const std::string& value) {
  
  _impl_.op_type_.Set(value, GetArenaForAllocation());
}
inline std::string* OPNode::_internal_mutable_op_type() {
  
  return _impl_.op_type_.Mutable(GetArenaForAllocation());
}
inline std::string* OPNode::release_op_type() {
  // @@protoc_insertion_point(field_release:serial_v2.OPNode.op_type)
  return _impl_.op_type_.Release();
}
inline void OPNode::set_allocated_op_type(std::string* op_type) {
  if (op_type != nullptr) {
    
  } else {
    
  }
  _impl_.op_type_.SetAllocated(op_type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.op_type_.IsDefault()) {
    _impl_.op_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OPNode.op_type)
}

// map<string, .serial_v2.AttrValue> op_attr = 3;
inline int OPNode::_internal_op_attr_size() const {
  return _impl_.op_attr_.size();
}
inline int OPNode::op_attr_size() const {
  return _internal_op_attr_size();
}
inline void OPNode::clear_op_attr() {
  _impl_.op_attr_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
OPNode::_internal_op_attr() const {
  return _impl_.op_attr_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
OPNode::op_attr() const {
  // @@protoc_insertion_point(field_map:serial_v2.OPNode.op_attr)
  return _internal_op_attr();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
OPNode::_internal_mutable_op_attr() {
  return _impl_.op_attr_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
OPNode::mutable_op_attr() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.OPNode.op_attr)
  return _internal_mutable_op_attr();
}

// repeated .serial_v2.OpArg args = 4;
inline int OPNode::_internal_args_size() const {
  return _impl_.args_.size();
}
inline int OPNode::args_size() const {
  return _internal_args_size();
}
inline void OPNode::clear_args() {
  _impl_.args_.Clear();
}
inline ::serial_v2::OpArg* OPNode::mutable_args(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.OPNode.args)
  return _impl_.args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArg >*
OPNode::mutable_args() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.OPNode.args)
  return &_impl_.args_;
}
inline const ::serial_v2::OpArg& OPNode::_internal_args(int index) const {
  return _impl_.args_.Get(index);
}
inline const ::serial_v2::OpArg& OPNode::args(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.OPNode.args)
  return _internal_args(index);
}
inline ::serial_v2::OpArg* OPNode::_internal_add_args() {
  return _impl_.args_.Add();
}
inline ::serial_v2::OpArg* OPNode::add_args() {
  ::serial_v2::OpArg* _add = _internal_add_args();
  // @@protoc_insertion_point(field_add:serial_v2.OPNode.args)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArg >&
OPNode::args() const {
  // @@protoc_insertion_point(field_list:serial_v2.OPNode.args)
  return _impl_.args_;
}

// .serial_v2.Tensor output_tensor = 5;
inline bool OPNode::_internal_has_output_tensor() const {
  return this != internal_default_instance() && _impl_.output_tensor_ != nullptr;
}
inline bool OPNode::has_output_tensor() const {
  return _internal_has_output_tensor();
}
inline void OPNode::clear_output_tensor() {
  if (GetArenaForAllocation() == nullptr && _impl_.output_tensor_ != nullptr) {
    delete _impl_.output_tensor_;
  }
  _impl_.output_tensor_ = nullptr;
}
inline const ::serial_v2::Tensor& OPNode::_internal_output_tensor() const {
  const ::serial_v2::Tensor* p = _impl_.output_tensor_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v2::Tensor&>(
      ::serial_v2::_Tensor_default_instance_);
}
inline const ::serial_v2::Tensor& OPNode::output_tensor() const {
  // @@protoc_insertion_point(field_get:serial_v2.OPNode.output_tensor)
  return _internal_output_tensor();
}
inline void OPNode::unsafe_arena_set_allocated_output_tensor(
    ::serial_v2::Tensor* output_tensor) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.output_tensor_);
  }
  _impl_.output_tensor_ = output_tensor;
  if (output_tensor) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.OPNode.output_tensor)
}
inline ::serial_v2::Tensor* OPNode::release_output_tensor() {
  
  ::serial_v2::Tensor* temp = _impl_.output_tensor_;
  _impl_.output_tensor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::serial_v2::Tensor* OPNode::unsafe_arena_release_output_tensor() {
  // @@protoc_insertion_point(field_release:serial_v2.OPNode.output_tensor)
  
  ::serial_v2::Tensor* temp = _impl_.output_tensor_;
  _impl_.output_tensor_ = nullptr;
  return temp;
}
inline ::serial_v2::Tensor* OPNode::_internal_mutable_output_tensor() {
  
  if (_impl_.output_tensor_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v2::Tensor>(GetArenaForAllocation());
    _impl_.output_tensor_ = p;
  }
  return _impl_.output_tensor_;
}
inline ::serial_v2::Tensor* OPNode::mutable_output_tensor() {
  ::serial_v2::Tensor* _msg = _internal_mutable_output_tensor();
  // @@protoc_insertion_point(field_mutable:serial_v2.OPNode.output_tensor)
  return _msg;
}
inline void OPNode::set_allocated_output_tensor(::serial_v2::Tensor* output_tensor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.output_tensor_;
  }
  if (output_tensor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(output_tensor);
    if (message_arena != submessage_arena) {
      output_tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output_tensor, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.output_tensor_ = output_tensor;
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OPNode.output_tensor)
}

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

// OpArg

// string arg_name = 1;
inline void OpArg::clear_arg_name() {
  _impl_.arg_name_.ClearToEmpty();
}
inline const std::string& OpArg::arg_name() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArg.arg_name)
  return _internal_arg_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OpArg::set_arg_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.arg_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OpArg.arg_name)
}
inline std::string* OpArg::mutable_arg_name() {
  std::string* _s = _internal_mutable_arg_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.OpArg.arg_name)
  return _s;
}
inline const std::string& OpArg::_internal_arg_name() const {
  return _impl_.arg_name_.Get();
}
inline void OpArg::_internal_set_arg_name(const std::string& value) {
  
  _impl_.arg_name_.Set(value, GetArenaForAllocation());
}
inline std::string* OpArg::_internal_mutable_arg_name() {
  
  return _impl_.arg_name_.Mutable(GetArenaForAllocation());
}
inline std::string* OpArg::release_arg_name() {
  // @@protoc_insertion_point(field_release:serial_v2.OpArg.arg_name)
  return _impl_.arg_name_.Release();
}
inline void OpArg::set_allocated_arg_name(std::string* arg_name) {
  if (arg_name != nullptr) {
    
  } else {
    
  }
  _impl_.arg_name_.SetAllocated(arg_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.arg_name_.IsDefault()) {
    _impl_.arg_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OpArg.arg_name)
}

// repeated string arg_ops = 2;
inline int OpArg::_internal_arg_ops_size() const {
  return _impl_.arg_ops_.size();
}
inline int OpArg::arg_ops_size() const {
  return _internal_arg_ops_size();
}
inline void OpArg::clear_arg_ops() {
  _impl_.arg_ops_.Clear();
}
inline std::string* OpArg::add_arg_ops() {
  std::string* _s = _internal_add_arg_ops();
  // @@protoc_insertion_point(field_add_mutable:serial_v2.OpArg.arg_ops)
  return _s;
}
inline const std::string& OpArg::_internal_arg_ops(int index) const {
  return _impl_.arg_ops_.Get(index);
}
inline const std::string& OpArg::arg_ops(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArg.arg_ops)
  return _internal_arg_ops(index);
}
inline std::string* OpArg::mutable_arg_ops(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.OpArg.arg_ops)
  return _impl_.arg_ops_.Mutable(index);
}
inline void OpArg::set_arg_ops(int index, const std::string& value) {
  _impl_.arg_ops_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v2.OpArg.arg_ops)
}
inline void OpArg::set_arg_ops(int index, std::string&& value) {
  _impl_.arg_ops_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v2.OpArg.arg_ops)
}
inline void OpArg::set_arg_ops(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.arg_ops_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:serial_v2.OpArg.arg_ops)
}
inline void OpArg::set_arg_ops(int index, const char* value, size_t size) {
  _impl_.arg_ops_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:serial_v2.OpArg.arg_ops)
}
inline std::string* OpArg::_internal_add_arg_ops() {
  return _impl_.arg_ops_.Add();
}
inline void OpArg::add_arg_ops(const std::string& value) {
  _impl_.arg_ops_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v2.OpArg.arg_ops)
}
inline void OpArg::add_arg_ops(std::string&& value) {
  _impl_.arg_ops_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v2.OpArg.arg_ops)
}
inline void OpArg::add_arg_ops(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.arg_ops_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v2.OpArg.arg_ops)
}
inline void OpArg::add_arg_ops(const char* value, size_t size) {
  _impl_.arg_ops_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:serial_v2.OpArg.arg_ops)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
OpArg::arg_ops() const {
  // @@protoc_insertion_point(field_list:serial_v2.OpArg.arg_ops)
  return _impl_.arg_ops_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
OpArg::mutable_arg_ops() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.OpArg.arg_ops)
  return &_impl_.arg_ops_;
}

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

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

// Tensor

// string tensor_name = 1;
inline void Tensor::clear_tensor_name() {
  _impl_.tensor_name_.ClearToEmpty();
}
inline const std::string& Tensor::tensor_name() const {
  // @@protoc_insertion_point(field_get:serial_v2.Tensor.tensor_name)
  return _internal_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Tensor::set_tensor_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.Tensor.tensor_name)
}
inline std::string* Tensor::mutable_tensor_name() {
  std::string* _s = _internal_mutable_tensor_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.Tensor.tensor_name)
  return _s;
}
inline const std::string& Tensor::_internal_tensor_name() const {
  return _impl_.tensor_name_.Get();
}
inline void Tensor::_internal_set_tensor_name(const std::string& value) {
  
  _impl_.tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Tensor::_internal_mutable_tensor_name() {
  
  return _impl_.tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Tensor::release_tensor_name() {
  // @@protoc_insertion_point(field_release:serial_v2.Tensor.tensor_name)
  return _impl_.tensor_name_.Release();
}
inline void Tensor::set_allocated_tensor_name(std::string* tensor_name) {
  if (tensor_name != nullptr) {
    
  } else {
    
  }
  _impl_.tensor_name_.SetAllocated(tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tensor_name_.IsDefault()) {
    _impl_.tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.Tensor.tensor_name)
}

// repeated uint32 tensor_dim = 2;
inline int Tensor::_internal_tensor_dim_size() const {
  return _impl_.tensor_dim_.size();
}
inline int Tensor::tensor_dim_size() const {
  return _internal_tensor_dim_size();
}
inline void Tensor::clear_tensor_dim() {
  _impl_.tensor_dim_.Clear();
}
inline uint32_t Tensor::_internal_tensor_dim(int index) const {
  return _impl_.tensor_dim_.Get(index);
}
inline uint32_t Tensor::tensor_dim(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Tensor.tensor_dim)
  return _internal_tensor_dim(index);
}
inline void Tensor::set_tensor_dim(int index, uint32_t value) {
  _impl_.tensor_dim_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.Tensor.tensor_dim)
}
inline void Tensor::_internal_add_tensor_dim(uint32_t value) {
  _impl_.tensor_dim_.Add(value);
}
inline void Tensor::add_tensor_dim(uint32_t value) {
  _internal_add_tensor_dim(value);
  // @@protoc_insertion_point(field_add:serial_v2.Tensor.tensor_dim)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Tensor::_internal_tensor_dim() const {
  return _impl_.tensor_dim_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Tensor::tensor_dim() const {
  // @@protoc_insertion_point(field_list:serial_v2.Tensor.tensor_dim)
  return _internal_tensor_dim();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Tensor::_internal_mutable_tensor_dim() {
  return &_impl_.tensor_dim_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Tensor::mutable_tensor_dim() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Tensor.tensor_dim)
  return _internal_mutable_tensor_dim();
}

// int32 data_type = 5;
inline void Tensor::clear_data_type() {
  _impl_.data_type_ = 0;
}
inline int32_t Tensor::_internal_data_type() const {
  return _impl_.data_type_;
}
inline int32_t Tensor::data_type() const {
  // @@protoc_insertion_point(field_get:serial_v2.Tensor.data_type)
  return _internal_data_type();
}
inline void Tensor::_internal_set_data_type(int32_t value) {
  
  _impl_.data_type_ = value;
}
inline void Tensor::set_data_type(int32_t value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:serial_v2.Tensor.data_type)
}

// int32 tensor_bit_width = 6;
inline void Tensor::clear_tensor_bit_width() {
  _impl_.tensor_bit_width_ = 0;
}
inline int32_t Tensor::_internal_tensor_bit_width() const {
  return _impl_.tensor_bit_width_;
}
inline int32_t Tensor::tensor_bit_width() const {
  // @@protoc_insertion_point(field_get:serial_v2.Tensor.tensor_bit_width)
  return _internal_tensor_bit_width();
}
inline void Tensor::_internal_set_tensor_bit_width(int32_t value) {
  
  _impl_.tensor_bit_width_ = value;
}
inline void Tensor::set_tensor_bit_width(int32_t value) {
  _internal_set_tensor_bit_width(value);
  // @@protoc_insertion_point(field_set:serial_v2.Tensor.tensor_bit_width)
}

// map<string, .serial_v2.AttrValue> tensor_attr = 10;
inline int Tensor::_internal_tensor_attr_size() const {
  return _impl_.tensor_attr_.size();
}
inline int Tensor::tensor_attr_size() const {
  return _internal_tensor_attr_size();
}
inline void Tensor::clear_tensor_attr() {
  _impl_.tensor_attr_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
Tensor::_internal_tensor_attr() const {
  return _impl_.tensor_attr_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
Tensor::tensor_attr() const {
  // @@protoc_insertion_point(field_map:serial_v2.Tensor.tensor_attr)
  return _internal_tensor_attr();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
Tensor::_internal_mutable_tensor_attr() {
  return _impl_.tensor_attr_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
Tensor::mutable_tensor_attr() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.Tensor.tensor_attr)
  return _internal_mutable_tensor_attr();
}

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

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

// SubGraph

// string subgraph_name = 1;
inline void SubGraph::clear_subgraph_name() {
  _impl_.subgraph_name_.ClearToEmpty();
}
inline const std::string& SubGraph::subgraph_name() const {
  // @@protoc_insertion_point(field_get:serial_v2.SubGraph.subgraph_name)
  return _internal_subgraph_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SubGraph::set_subgraph_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.subgraph_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.SubGraph.subgraph_name)
}
inline std::string* SubGraph::mutable_subgraph_name() {
  std::string* _s = _internal_mutable_subgraph_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.SubGraph.subgraph_name)
  return _s;
}
inline const std::string& SubGraph::_internal_subgraph_name() const {
  return _impl_.subgraph_name_.Get();
}
inline void SubGraph::_internal_set_subgraph_name(const std::string& value) {
  
  _impl_.subgraph_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SubGraph::_internal_mutable_subgraph_name() {
  
  return _impl_.subgraph_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SubGraph::release_subgraph_name() {
  // @@protoc_insertion_point(field_release:serial_v2.SubGraph.subgraph_name)
  return _impl_.subgraph_name_.Release();
}
inline void SubGraph::set_allocated_subgraph_name(std::string* subgraph_name) {
  if (subgraph_name != nullptr) {
    
  } else {
    
  }
  _impl_.subgraph_name_.SetAllocated(subgraph_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.subgraph_name_.IsDefault()) {
    _impl_.subgraph_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.SubGraph.subgraph_name)
}

// repeated string op_name = 3;
inline int SubGraph::_internal_op_name_size() const {
  return _impl_.op_name_.size();
}
inline int SubGraph::op_name_size() const {
  return _internal_op_name_size();
}
inline void SubGraph::clear_op_name() {
  _impl_.op_name_.Clear();
}
inline std::string* SubGraph::add_op_name() {
  std::string* _s = _internal_add_op_name();
  // @@protoc_insertion_point(field_add_mutable:serial_v2.SubGraph.op_name)
  return _s;
}
inline const std::string& SubGraph::_internal_op_name(int index) const {
  return _impl_.op_name_.Get(index);
}
inline const std::string& SubGraph::op_name(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.SubGraph.op_name)
  return _internal_op_name(index);
}
inline std::string* SubGraph::mutable_op_name(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.SubGraph.op_name)
  return _impl_.op_name_.Mutable(index);
}
inline void SubGraph::set_op_name(int index, const std::string& value) {
  _impl_.op_name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v2.SubGraph.op_name)
}
inline void SubGraph::set_op_name(int index, std::string&& value) {
  _impl_.op_name_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v2.SubGraph.op_name)
}
inline void SubGraph::set_op_name(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.op_name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:serial_v2.SubGraph.op_name)
}
inline void SubGraph::set_op_name(int index, const char* value, size_t size) {
  _impl_.op_name_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:serial_v2.SubGraph.op_name)
}
inline std::string* SubGraph::_internal_add_op_name() {
  return _impl_.op_name_.Add();
}
inline void SubGraph::add_op_name(const std::string& value) {
  _impl_.op_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v2.SubGraph.op_name)
}
inline void SubGraph::add_op_name(std::string&& value) {
  _impl_.op_name_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v2.SubGraph.op_name)
}
inline void SubGraph::add_op_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.op_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v2.SubGraph.op_name)
}
inline void SubGraph::add_op_name(const char* value, size_t size) {
  _impl_.op_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:serial_v2.SubGraph.op_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SubGraph::op_name() const {
  // @@protoc_insertion_point(field_list:serial_v2.SubGraph.op_name)
  return _impl_.op_name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SubGraph::mutable_op_name() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.SubGraph.op_name)
  return &_impl_.op_name_;
}

// map<string, .serial_v2.AttrValue> subg_attr = 5;
inline int SubGraph::_internal_subg_attr_size() const {
  return _impl_.subg_attr_.size();
}
inline int SubGraph::subg_attr_size() const {
  return _internal_subg_attr_size();
}
inline void SubGraph::clear_subg_attr() {
  _impl_.subg_attr_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
SubGraph::_internal_subg_attr() const {
  return _impl_.subg_attr_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >&
SubGraph::subg_attr() const {
  // @@protoc_insertion_point(field_map:serial_v2.SubGraph.subg_attr)
  return _internal_subg_attr();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
SubGraph::_internal_mutable_subg_attr() {
  return _impl_.subg_attr_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::AttrValue >*
SubGraph::mutable_subg_attr() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.SubGraph.subg_attr)
  return _internal_mutable_subg_attr();
}

// repeated .serial_v2.SubGraph subg_child = 10;
inline int SubGraph::_internal_subg_child_size() const {
  return _impl_.subg_child_.size();
}
inline int SubGraph::subg_child_size() const {
  return _internal_subg_child_size();
}
inline void SubGraph::clear_subg_child() {
  _impl_.subg_child_.Clear();
}
inline ::serial_v2::SubGraph* SubGraph::mutable_subg_child(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.SubGraph.subg_child)
  return _impl_.subg_child_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::SubGraph >*
SubGraph::mutable_subg_child() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.SubGraph.subg_child)
  return &_impl_.subg_child_;
}
inline const ::serial_v2::SubGraph& SubGraph::_internal_subg_child(int index) const {
  return _impl_.subg_child_.Get(index);
}
inline const ::serial_v2::SubGraph& SubGraph::subg_child(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.SubGraph.subg_child)
  return _internal_subg_child(index);
}
inline ::serial_v2::SubGraph* SubGraph::_internal_add_subg_child() {
  return _impl_.subg_child_.Add();
}
inline ::serial_v2::SubGraph* SubGraph::add_subg_child() {
  ::serial_v2::SubGraph* _add = _internal_add_subg_child();
  // @@protoc_insertion_point(field_add:serial_v2.SubGraph.subg_child)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::SubGraph >&
SubGraph::subg_child() const {
  // @@protoc_insertion_point(field_list:serial_v2.SubGraph.subg_child)
  return _impl_.subg_child_;
}

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

// OpDef

// string name = 1;
inline void OpDef::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& OpDef::name() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpDef.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OpDef::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OpDef.name)
}
inline std::string* OpDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.OpDef.name)
  return _s;
}
inline const std::string& OpDef::_internal_name() const {
  return _impl_.name_.Get();
}
inline void OpDef::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* OpDef::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* OpDef::release_name() {
  // @@protoc_insertion_point(field_release:serial_v2.OpDef.name)
  return _impl_.name_.Release();
}
inline void OpDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OpDef.name)
}

// repeated .serial_v2.OpArgDef input_args = 2;
inline int OpDef::_internal_input_args_size() const {
  return _impl_.input_args_.size();
}
inline int OpDef::input_args_size() const {
  return _internal_input_args_size();
}
inline void OpDef::clear_input_args() {
  _impl_.input_args_.Clear();
}
inline ::serial_v2::OpArgDef* OpDef::mutable_input_args(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.OpDef.input_args)
  return _impl_.input_args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArgDef >*
OpDef::mutable_input_args() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.OpDef.input_args)
  return &_impl_.input_args_;
}
inline const ::serial_v2::OpArgDef& OpDef::_internal_input_args(int index) const {
  return _impl_.input_args_.Get(index);
}
inline const ::serial_v2::OpArgDef& OpDef::input_args(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.OpDef.input_args)
  return _internal_input_args(index);
}
inline ::serial_v2::OpArgDef* OpDef::_internal_add_input_args() {
  return _impl_.input_args_.Add();
}
inline ::serial_v2::OpArgDef* OpDef::add_input_args() {
  ::serial_v2::OpArgDef* _add = _internal_add_input_args();
  // @@protoc_insertion_point(field_add:serial_v2.OpDef.input_args)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::OpArgDef >&
OpDef::input_args() const {
  // @@protoc_insertion_point(field_list:serial_v2.OpDef.input_args)
  return _impl_.input_args_;
}

// repeated .serial_v2.AttrDef attrs = 3;
inline int OpDef::_internal_attrs_size() const {
  return _impl_.attrs_.size();
}
inline int OpDef::attrs_size() const {
  return _internal_attrs_size();
}
inline void OpDef::clear_attrs() {
  _impl_.attrs_.Clear();
}
inline ::serial_v2::AttrDef* OpDef::mutable_attrs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.OpDef.attrs)
  return _impl_.attrs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::AttrDef >*
OpDef::mutable_attrs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.OpDef.attrs)
  return &_impl_.attrs_;
}
inline const ::serial_v2::AttrDef& OpDef::_internal_attrs(int index) const {
  return _impl_.attrs_.Get(index);
}
inline const ::serial_v2::AttrDef& OpDef::attrs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.OpDef.attrs)
  return _internal_attrs(index);
}
inline ::serial_v2::AttrDef* OpDef::_internal_add_attrs() {
  return _impl_.attrs_.Add();
}
inline ::serial_v2::AttrDef* OpDef::add_attrs() {
  ::serial_v2::AttrDef* _add = _internal_add_attrs();
  // @@protoc_insertion_point(field_add:serial_v2.OpDef.attrs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::AttrDef >&
OpDef::attrs() const {
  // @@protoc_insertion_point(field_list:serial_v2.OpDef.attrs)
  return _impl_.attrs_;
}

// string annotation = 4;
inline void OpDef::clear_annotation() {
  _impl_.annotation_.ClearToEmpty();
}
inline const std::string& OpDef::annotation() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpDef.annotation)
  return _internal_annotation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OpDef::set_annotation(ArgT0&& arg0, ArgT... args) {
 
 _impl_.annotation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OpDef.annotation)
}
inline std::string* OpDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v2.OpDef.annotation)
  return _s;
}
inline const std::string& OpDef::_internal_annotation() const {
  return _impl_.annotation_.Get();
}
inline void OpDef::_internal_set_annotation(const std::string& value) {
  
  _impl_.annotation_.Set(value, GetArenaForAllocation());
}
inline std::string* OpDef::_internal_mutable_annotation() {
  
  return _impl_.annotation_.Mutable(GetArenaForAllocation());
}
inline std::string* OpDef::release_annotation() {
  // @@protoc_insertion_point(field_release:serial_v2.OpDef.annotation)
  return _impl_.annotation_.Release();
}
inline void OpDef::set_allocated_annotation(std::string* annotation) {
  if (annotation != nullptr) {
    
  } else {
    
  }
  _impl_.annotation_.SetAllocated(annotation, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.annotation_.IsDefault()) {
    _impl_.annotation_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OpDef.annotation)
}

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

// AttrDef

// string name = 1;
inline void AttrDef::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& AttrDef::name() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrDef.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrDef::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.AttrDef.name)
}
inline std::string* AttrDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrDef.name)
  return _s;
}
inline const std::string& AttrDef::_internal_name() const {
  return _impl_.name_.Get();
}
inline void AttrDef::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrDef::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrDef::release_name() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrDef.name)
  return _impl_.name_.Release();
}
inline void AttrDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.AttrDef.name)
}

// .serial_v2.AttrDef.OccurType occur_type = 3;
inline void AttrDef::clear_occur_type() {
  _impl_.occur_type_ = 0;
}
inline ::serial_v2::AttrDef_OccurType AttrDef::_internal_occur_type() const {
  return static_cast< ::serial_v2::AttrDef_OccurType >(_impl_.occur_type_);
}
inline ::serial_v2::AttrDef_OccurType AttrDef::occur_type() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrDef.occur_type)
  return _internal_occur_type();
}
inline void AttrDef::_internal_set_occur_type(::serial_v2::AttrDef_OccurType value) {
  
  _impl_.occur_type_ = value;
}
inline void AttrDef::set_occur_type(::serial_v2::AttrDef_OccurType value) {
  _internal_set_occur_type(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrDef.occur_type)
}

// .serial_v2.AttrValue default_value = 4;
inline bool AttrDef::_internal_has_default_value() const {
  return this != internal_default_instance() && _impl_.default_value_ != nullptr;
}
inline bool AttrDef::has_default_value() const {
  return _internal_has_default_value();
}
inline void AttrDef::clear_default_value() {
  if (GetArenaForAllocation() == nullptr && _impl_.default_value_ != nullptr) {
    delete _impl_.default_value_;
  }
  _impl_.default_value_ = nullptr;
}
inline const ::serial_v2::AttrValue& AttrDef::_internal_default_value() const {
  const ::serial_v2::AttrValue* p = _impl_.default_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v2::AttrValue&>(
      ::serial_v2::_AttrValue_default_instance_);
}
inline const ::serial_v2::AttrValue& AttrDef::default_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrDef.default_value)
  return _internal_default_value();
}
inline void AttrDef::unsafe_arena_set_allocated_default_value(
    ::serial_v2::AttrValue* default_value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
  }
  _impl_.default_value_ = default_value;
  if (default_value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrDef.default_value)
}
inline ::serial_v2::AttrValue* AttrDef::release_default_value() {
  
  ::serial_v2::AttrValue* temp = _impl_.default_value_;
  _impl_.default_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::serial_v2::AttrValue* AttrDef::unsafe_arena_release_default_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrDef.default_value)
  
  ::serial_v2::AttrValue* temp = _impl_.default_value_;
  _impl_.default_value_ = nullptr;
  return temp;
}
inline ::serial_v2::AttrValue* AttrDef::_internal_mutable_default_value() {
  
  if (_impl_.default_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v2::AttrValue>(GetArenaForAllocation());
    _impl_.default_value_ = p;
  }
  return _impl_.default_value_;
}
inline ::serial_v2::AttrValue* AttrDef::mutable_default_value() {
  ::serial_v2::AttrValue* _msg = _internal_mutable_default_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrDef.default_value)
  return _msg;
}
inline void AttrDef::set_allocated_default_value(::serial_v2::AttrValue* default_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.default_value_;
  }
  if (default_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(default_value);
    if (message_arena != submessage_arena) {
      default_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, default_value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.default_value_ = default_value;
  // @@protoc_insertion_point(field_set_allocated:serial_v2.AttrDef.default_value)
}

// int32 list_length = 6;
inline void AttrDef::clear_list_length() {
  _impl_.list_length_ = 0;
}
inline int32_t AttrDef::_internal_list_length() const {
  return _impl_.list_length_;
}
inline int32_t AttrDef::list_length() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrDef.list_length)
  return _internal_list_length();
}
inline void AttrDef::_internal_set_list_length(int32_t value) {
  
  _impl_.list_length_ = value;
}
inline void AttrDef::set_list_length(int32_t value) {
  _internal_set_list_length(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrDef.list_length)
}

// string annotation = 7;
inline void AttrDef::clear_annotation() {
  _impl_.annotation_.ClearToEmpty();
}
inline const std::string& AttrDef::annotation() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrDef.annotation)
  return _internal_annotation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrDef::set_annotation(ArgT0&& arg0, ArgT... args) {
 
 _impl_.annotation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.AttrDef.annotation)
}
inline std::string* AttrDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrDef.annotation)
  return _s;
}
inline const std::string& AttrDef::_internal_annotation() const {
  return _impl_.annotation_.Get();
}
inline void AttrDef::_internal_set_annotation(const std::string& value) {
  
  _impl_.annotation_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrDef::_internal_mutable_annotation() {
  
  return _impl_.annotation_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrDef::release_annotation() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrDef.annotation)
  return _impl_.annotation_.Release();
}
inline void AttrDef::set_allocated_annotation(std::string* annotation) {
  if (annotation != nullptr) {
    
  } else {
    
  }
  _impl_.annotation_.SetAllocated(annotation, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.annotation_.IsDefault()) {
    _impl_.annotation_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.AttrDef.annotation)
}

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

// OpArgDef

// string name = 1;
inline void OpArgDef::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& OpArgDef::name() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArgDef.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OpArgDef::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OpArgDef.name)
}
inline std::string* OpArgDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v2.OpArgDef.name)
  return _s;
}
inline const std::string& OpArgDef::_internal_name() const {
  return _impl_.name_.Get();
}
inline void OpArgDef::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* OpArgDef::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* OpArgDef::release_name() {
  // @@protoc_insertion_point(field_release:serial_v2.OpArgDef.name)
  return _impl_.name_.Release();
}
inline void OpArgDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OpArgDef.name)
}

// .serial_v2.OpArgDef.OccurType occur_type = 2;
inline void OpArgDef::clear_occur_type() {
  _impl_.occur_type_ = 0;
}
inline ::serial_v2::OpArgDef_OccurType OpArgDef::_internal_occur_type() const {
  return static_cast< ::serial_v2::OpArgDef_OccurType >(_impl_.occur_type_);
}
inline ::serial_v2::OpArgDef_OccurType OpArgDef::occur_type() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArgDef.occur_type)
  return _internal_occur_type();
}
inline void OpArgDef::_internal_set_occur_type(::serial_v2::OpArgDef_OccurType value) {
  
  _impl_.occur_type_ = value;
}
inline void OpArgDef::set_occur_type(::serial_v2::OpArgDef_OccurType value) {
  _internal_set_occur_type(value);
  // @@protoc_insertion_point(field_set:serial_v2.OpArgDef.occur_type)
}

// int32 data_type = 3;
inline void OpArgDef::clear_data_type() {
  _impl_.data_type_ = 0;
}
inline int32_t OpArgDef::_internal_data_type() const {
  return _impl_.data_type_;
}
inline int32_t OpArgDef::data_type() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArgDef.data_type)
  return _internal_data_type();
}
inline void OpArgDef::_internal_set_data_type(int32_t value) {
  
  _impl_.data_type_ = value;
}
inline void OpArgDef::set_data_type(int32_t value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:serial_v2.OpArgDef.data_type)
}

// string annotation = 4;
inline void OpArgDef::clear_annotation() {
  _impl_.annotation_.ClearToEmpty();
}
inline const std::string& OpArgDef::annotation() const {
  // @@protoc_insertion_point(field_get:serial_v2.OpArgDef.annotation)
  return _internal_annotation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OpArgDef::set_annotation(ArgT0&& arg0, ArgT... args) {
 
 _impl_.annotation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.OpArgDef.annotation)
}
inline std::string* OpArgDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v2.OpArgDef.annotation)
  return _s;
}
inline const std::string& OpArgDef::_internal_annotation() const {
  return _impl_.annotation_.Get();
}
inline void OpArgDef::_internal_set_annotation(const std::string& value) {
  
  _impl_.annotation_.Set(value, GetArenaForAllocation());
}
inline std::string* OpArgDef::_internal_mutable_annotation() {
  
  return _impl_.annotation_.Mutable(GetArenaForAllocation());
}
inline std::string* OpArgDef::release_annotation() {
  // @@protoc_insertion_point(field_release:serial_v2.OpArgDef.annotation)
  return _impl_.annotation_.Release();
}
inline void OpArgDef::set_allocated_annotation(std::string* annotation) {
  if (annotation != nullptr) {
    
  } else {
    
  }
  _impl_.annotation_.SetAllocated(annotation, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.annotation_.IsDefault()) {
    _impl_.annotation_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.OpArgDef.annotation)
}

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

// AttrValue

// bool bool_value = 4;
inline bool AttrValue::_internal_has_bool_value() const {
  return value_case() == kBoolValue;
}
inline bool AttrValue::has_bool_value() const {
  return _internal_has_bool_value();
}
inline void AttrValue::set_has_bool_value() {
  _impl_._oneof_case_[0] = kBoolValue;
}
inline void AttrValue::clear_bool_value() {
  if (_internal_has_bool_value()) {
    _impl_.value_.bool_value_ = false;
    clear_has_value();
  }
}
inline bool AttrValue::_internal_bool_value() const {
  if (_internal_has_bool_value()) {
    return _impl_.value_.bool_value_;
  }
  return false;
}
inline void AttrValue::_internal_set_bool_value(bool value) {
  if (!_internal_has_bool_value()) {
    clear_value();
    set_has_bool_value();
  }
  _impl_.value_.bool_value_ = value;
}
inline bool AttrValue::bool_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.bool_value)
  return _internal_bool_value();
}
inline void AttrValue::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.bool_value)
}

// int32 int32_value = 5;
inline bool AttrValue::_internal_has_int32_value() const {
  return value_case() == kInt32Value;
}
inline bool AttrValue::has_int32_value() const {
  return _internal_has_int32_value();
}
inline void AttrValue::set_has_int32_value() {
  _impl_._oneof_case_[0] = kInt32Value;
}
inline void AttrValue::clear_int32_value() {
  if (_internal_has_int32_value()) {
    _impl_.value_.int32_value_ = 0;
    clear_has_value();
  }
}
inline int32_t AttrValue::_internal_int32_value() const {
  if (_internal_has_int32_value()) {
    return _impl_.value_.int32_value_;
  }
  return 0;
}
inline void AttrValue::_internal_set_int32_value(int32_t value) {
  if (!_internal_has_int32_value()) {
    clear_value();
    set_has_int32_value();
  }
  _impl_.value_.int32_value_ = value;
}
inline int32_t AttrValue::int32_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.int32_value)
  return _internal_int32_value();
}
inline void AttrValue::set_int32_value(int32_t value) {
  _internal_set_int32_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.int32_value)
}

// uint32 uint32_value = 6;
inline bool AttrValue::_internal_has_uint32_value() const {
  return value_case() == kUint32Value;
}
inline bool AttrValue::has_uint32_value() const {
  return _internal_has_uint32_value();
}
inline void AttrValue::set_has_uint32_value() {
  _impl_._oneof_case_[0] = kUint32Value;
}
inline void AttrValue::clear_uint32_value() {
  if (_internal_has_uint32_value()) {
    _impl_.value_.uint32_value_ = 0u;
    clear_has_value();
  }
}
inline uint32_t AttrValue::_internal_uint32_value() const {
  if (_internal_has_uint32_value()) {
    return _impl_.value_.uint32_value_;
  }
  return 0u;
}
inline void AttrValue::_internal_set_uint32_value(uint32_t value) {
  if (!_internal_has_uint32_value()) {
    clear_value();
    set_has_uint32_value();
  }
  _impl_.value_.uint32_value_ = value;
}
inline uint32_t AttrValue::uint32_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.uint32_value)
  return _internal_uint32_value();
}
inline void AttrValue::set_uint32_value(uint32_t value) {
  _internal_set_uint32_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.uint32_value)
}

// int64 int64_value = 7;
inline bool AttrValue::_internal_has_int64_value() const {
  return value_case() == kInt64Value;
}
inline bool AttrValue::has_int64_value() const {
  return _internal_has_int64_value();
}
inline void AttrValue::set_has_int64_value() {
  _impl_._oneof_case_[0] = kInt64Value;
}
inline void AttrValue::clear_int64_value() {
  if (_internal_has_int64_value()) {
    _impl_.value_.int64_value_ = int64_t{0};
    clear_has_value();
  }
}
inline int64_t AttrValue::_internal_int64_value() const {
  if (_internal_has_int64_value()) {
    return _impl_.value_.int64_value_;
  }
  return int64_t{0};
}
inline void AttrValue::_internal_set_int64_value(int64_t value) {
  if (!_internal_has_int64_value()) {
    clear_value();
    set_has_int64_value();
  }
  _impl_.value_.int64_value_ = value;
}
inline int64_t AttrValue::int64_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.int64_value)
  return _internal_int64_value();
}
inline void AttrValue::set_int64_value(int64_t value) {
  _internal_set_int64_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.int64_value)
}

// uint64 uint64_value = 8;
inline bool AttrValue::_internal_has_uint64_value() const {
  return value_case() == kUint64Value;
}
inline bool AttrValue::has_uint64_value() const {
  return _internal_has_uint64_value();
}
inline void AttrValue::set_has_uint64_value() {
  _impl_._oneof_case_[0] = kUint64Value;
}
inline void AttrValue::clear_uint64_value() {
  if (_internal_has_uint64_value()) {
    _impl_.value_.uint64_value_ = uint64_t{0u};
    clear_has_value();
  }
}
inline uint64_t AttrValue::_internal_uint64_value() const {
  if (_internal_has_uint64_value()) {
    return _impl_.value_.uint64_value_;
  }
  return uint64_t{0u};
}
inline void AttrValue::_internal_set_uint64_value(uint64_t value) {
  if (!_internal_has_uint64_value()) {
    clear_value();
    set_has_uint64_value();
  }
  _impl_.value_.uint64_value_ = value;
}
inline uint64_t AttrValue::uint64_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.uint64_value)
  return _internal_uint64_value();
}
inline void AttrValue::set_uint64_value(uint64_t value) {
  _internal_set_uint64_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.uint64_value)
}

// float float_value = 9;
inline bool AttrValue::_internal_has_float_value() const {
  return value_case() == kFloatValue;
}
inline bool AttrValue::has_float_value() const {
  return _internal_has_float_value();
}
inline void AttrValue::set_has_float_value() {
  _impl_._oneof_case_[0] = kFloatValue;
}
inline void AttrValue::clear_float_value() {
  if (_internal_has_float_value()) {
    _impl_.value_.float_value_ = 0;
    clear_has_value();
  }
}
inline float AttrValue::_internal_float_value() const {
  if (_internal_has_float_value()) {
    return _impl_.value_.float_value_;
  }
  return 0;
}
inline void AttrValue::_internal_set_float_value(float value) {
  if (!_internal_has_float_value()) {
    clear_value();
    set_has_float_value();
  }
  _impl_.value_.float_value_ = value;
}
inline float AttrValue::float_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.float_value)
  return _internal_float_value();
}
inline void AttrValue::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.float_value)
}

// double double_value = 10;
inline bool AttrValue::_internal_has_double_value() const {
  return value_case() == kDoubleValue;
}
inline bool AttrValue::has_double_value() const {
  return _internal_has_double_value();
}
inline void AttrValue::set_has_double_value() {
  _impl_._oneof_case_[0] = kDoubleValue;
}
inline void AttrValue::clear_double_value() {
  if (_internal_has_double_value()) {
    _impl_.value_.double_value_ = 0;
    clear_has_value();
  }
}
inline double AttrValue::_internal_double_value() const {
  if (_internal_has_double_value()) {
    return _impl_.value_.double_value_;
  }
  return 0;
}
inline void AttrValue::_internal_set_double_value(double value) {
  if (!_internal_has_double_value()) {
    clear_value();
    set_has_double_value();
  }
  _impl_.value_.double_value_ = value;
}
inline double AttrValue::double_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.double_value)
  return _internal_double_value();
}
inline void AttrValue::set_double_value(double value) {
  _internal_set_double_value(value);
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.double_value)
}

// string string_value = 11;
inline bool AttrValue::_internal_has_string_value() const {
  return value_case() == kStringValue;
}
inline bool AttrValue::has_string_value() const {
  return _internal_has_string_value();
}
inline void AttrValue::set_has_string_value() {
  _impl_._oneof_case_[0] = kStringValue;
}
inline void AttrValue::clear_string_value() {
  if (_internal_has_string_value()) {
    _impl_.value_.string_value_.Destroy();
    clear_has_value();
  }
}
inline const std::string& AttrValue::string_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline void AttrValue::set_string_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_string_value()) {
    clear_value();
    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  _impl_.value_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.AttrValue.string_value)
}
inline std::string* AttrValue::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.string_value)
  return _s;
}
inline const std::string& AttrValue::_internal_string_value() const {
  if (_internal_has_string_value()) {
    return _impl_.value_.string_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void AttrValue::_internal_set_string_value(const std::string& value) {
  if (!_internal_has_string_value()) {
    clear_value();
    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  _impl_.value_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue::_internal_mutable_string_value() {
  if (!_internal_has_string_value()) {
    clear_value();
    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  return _impl_.value_.string_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* AttrValue::release_string_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.string_value)
  if (_internal_has_string_value()) {
    clear_has_value();
    return _impl_.value_.string_value_.Release();
  } else {
    return nullptr;
  }
}
inline void AttrValue::set_allocated_string_value(std::string* string_value) {
  if (has_value()) {
    clear_value();
  }
  if (string_value != nullptr) {
    set_has_string_value();
    _impl_.value_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:serial_v2.AttrValue.string_value)
}

// .serial_v2.Bytes bytes_value = 12;
inline bool AttrValue::_internal_has_bytes_value() const {
  return value_case() == kBytesValue;
}
inline bool AttrValue::has_bytes_value() const {
  return _internal_has_bytes_value();
}
inline void AttrValue::set_has_bytes_value() {
  _impl_._oneof_case_[0] = kBytesValue;
}
inline void AttrValue::clear_bytes_value() {
  if (_internal_has_bytes_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.bytes_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::Bytes* AttrValue::release_bytes_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.bytes_value)
  if (_internal_has_bytes_value()) {
    clear_has_value();
    ::serial_v2::Bytes* temp = _impl_.value_.bytes_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.bytes_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::Bytes& AttrValue::_internal_bytes_value() const {
  return _internal_has_bytes_value()
      ? *_impl_.value_.bytes_value_
      : reinterpret_cast< ::serial_v2::Bytes&>(::serial_v2::_Bytes_default_instance_);
}
inline const ::serial_v2::Bytes& AttrValue::bytes_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.bytes_value)
  return _internal_bytes_value();
}
inline ::serial_v2::Bytes* AttrValue::unsafe_arena_release_bytes_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.bytes_value)
  if (_internal_has_bytes_value()) {
    clear_has_value();
    ::serial_v2::Bytes* temp = _impl_.value_.bytes_value_;
    _impl_.value_.bytes_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_bytes_value(::serial_v2::Bytes* bytes_value) {
  clear_value();
  if (bytes_value) {
    set_has_bytes_value();
    _impl_.value_.bytes_value_ = bytes_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.bytes_value)
}
inline ::serial_v2::Bytes* AttrValue::_internal_mutable_bytes_value() {
  if (!_internal_has_bytes_value()) {
    clear_value();
    set_has_bytes_value();
    _impl_.value_.bytes_value_ = CreateMaybeMessage< ::serial_v2::Bytes >(GetArenaForAllocation());
  }
  return _impl_.value_.bytes_value_;
}
inline ::serial_v2::Bytes* AttrValue::mutable_bytes_value() {
  ::serial_v2::Bytes* _msg = _internal_mutable_bytes_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.bytes_value)
  return _msg;
}

// .serial_v2.BoolVec bool_vec_value = 13;
inline bool AttrValue::_internal_has_bool_vec_value() const {
  return value_case() == kBoolVecValue;
}
inline bool AttrValue::has_bool_vec_value() const {
  return _internal_has_bool_vec_value();
}
inline void AttrValue::set_has_bool_vec_value() {
  _impl_._oneof_case_[0] = kBoolVecValue;
}
inline void AttrValue::clear_bool_vec_value() {
  if (_internal_has_bool_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.bool_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::BoolVec* AttrValue::release_bool_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.bool_vec_value)
  if (_internal_has_bool_vec_value()) {
    clear_has_value();
    ::serial_v2::BoolVec* temp = _impl_.value_.bool_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.bool_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::BoolVec& AttrValue::_internal_bool_vec_value() const {
  return _internal_has_bool_vec_value()
      ? *_impl_.value_.bool_vec_value_
      : reinterpret_cast< ::serial_v2::BoolVec&>(::serial_v2::_BoolVec_default_instance_);
}
inline const ::serial_v2::BoolVec& AttrValue::bool_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.bool_vec_value)
  return _internal_bool_vec_value();
}
inline ::serial_v2::BoolVec* AttrValue::unsafe_arena_release_bool_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.bool_vec_value)
  if (_internal_has_bool_vec_value()) {
    clear_has_value();
    ::serial_v2::BoolVec* temp = _impl_.value_.bool_vec_value_;
    _impl_.value_.bool_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_bool_vec_value(::serial_v2::BoolVec* bool_vec_value) {
  clear_value();
  if (bool_vec_value) {
    set_has_bool_vec_value();
    _impl_.value_.bool_vec_value_ = bool_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.bool_vec_value)
}
inline ::serial_v2::BoolVec* AttrValue::_internal_mutable_bool_vec_value() {
  if (!_internal_has_bool_vec_value()) {
    clear_value();
    set_has_bool_vec_value();
    _impl_.value_.bool_vec_value_ = CreateMaybeMessage< ::serial_v2::BoolVec >(GetArenaForAllocation());
  }
  return _impl_.value_.bool_vec_value_;
}
inline ::serial_v2::BoolVec* AttrValue::mutable_bool_vec_value() {
  ::serial_v2::BoolVec* _msg = _internal_mutable_bool_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.bool_vec_value)
  return _msg;
}

// .serial_v2.Int32Vec int32_vec_value = 14;
inline bool AttrValue::_internal_has_int32_vec_value() const {
  return value_case() == kInt32VecValue;
}
inline bool AttrValue::has_int32_vec_value() const {
  return _internal_has_int32_vec_value();
}
inline void AttrValue::set_has_int32_vec_value() {
  _impl_._oneof_case_[0] = kInt32VecValue;
}
inline void AttrValue::clear_int32_vec_value() {
  if (_internal_has_int32_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.int32_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::Int32Vec* AttrValue::release_int32_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.int32_vec_value)
  if (_internal_has_int32_vec_value()) {
    clear_has_value();
    ::serial_v2::Int32Vec* temp = _impl_.value_.int32_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.int32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::Int32Vec& AttrValue::_internal_int32_vec_value() const {
  return _internal_has_int32_vec_value()
      ? *_impl_.value_.int32_vec_value_
      : reinterpret_cast< ::serial_v2::Int32Vec&>(::serial_v2::_Int32Vec_default_instance_);
}
inline const ::serial_v2::Int32Vec& AttrValue::int32_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.int32_vec_value)
  return _internal_int32_vec_value();
}
inline ::serial_v2::Int32Vec* AttrValue::unsafe_arena_release_int32_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.int32_vec_value)
  if (_internal_has_int32_vec_value()) {
    clear_has_value();
    ::serial_v2::Int32Vec* temp = _impl_.value_.int32_vec_value_;
    _impl_.value_.int32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_int32_vec_value(::serial_v2::Int32Vec* int32_vec_value) {
  clear_value();
  if (int32_vec_value) {
    set_has_int32_vec_value();
    _impl_.value_.int32_vec_value_ = int32_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.int32_vec_value)
}
inline ::serial_v2::Int32Vec* AttrValue::_internal_mutable_int32_vec_value() {
  if (!_internal_has_int32_vec_value()) {
    clear_value();
    set_has_int32_vec_value();
    _impl_.value_.int32_vec_value_ = CreateMaybeMessage< ::serial_v2::Int32Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.int32_vec_value_;
}
inline ::serial_v2::Int32Vec* AttrValue::mutable_int32_vec_value() {
  ::serial_v2::Int32Vec* _msg = _internal_mutable_int32_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.int32_vec_value)
  return _msg;
}

// .serial_v2.Uint32Vec uint32_vec_value = 15;
inline bool AttrValue::_internal_has_uint32_vec_value() const {
  return value_case() == kUint32VecValue;
}
inline bool AttrValue::has_uint32_vec_value() const {
  return _internal_has_uint32_vec_value();
}
inline void AttrValue::set_has_uint32_vec_value() {
  _impl_._oneof_case_[0] = kUint32VecValue;
}
inline void AttrValue::clear_uint32_vec_value() {
  if (_internal_has_uint32_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.uint32_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::Uint32Vec* AttrValue::release_uint32_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.uint32_vec_value)
  if (_internal_has_uint32_vec_value()) {
    clear_has_value();
    ::serial_v2::Uint32Vec* temp = _impl_.value_.uint32_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.uint32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::Uint32Vec& AttrValue::_internal_uint32_vec_value() const {
  return _internal_has_uint32_vec_value()
      ? *_impl_.value_.uint32_vec_value_
      : reinterpret_cast< ::serial_v2::Uint32Vec&>(::serial_v2::_Uint32Vec_default_instance_);
}
inline const ::serial_v2::Uint32Vec& AttrValue::uint32_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.uint32_vec_value)
  return _internal_uint32_vec_value();
}
inline ::serial_v2::Uint32Vec* AttrValue::unsafe_arena_release_uint32_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.uint32_vec_value)
  if (_internal_has_uint32_vec_value()) {
    clear_has_value();
    ::serial_v2::Uint32Vec* temp = _impl_.value_.uint32_vec_value_;
    _impl_.value_.uint32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_uint32_vec_value(::serial_v2::Uint32Vec* uint32_vec_value) {
  clear_value();
  if (uint32_vec_value) {
    set_has_uint32_vec_value();
    _impl_.value_.uint32_vec_value_ = uint32_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.uint32_vec_value)
}
inline ::serial_v2::Uint32Vec* AttrValue::_internal_mutable_uint32_vec_value() {
  if (!_internal_has_uint32_vec_value()) {
    clear_value();
    set_has_uint32_vec_value();
    _impl_.value_.uint32_vec_value_ = CreateMaybeMessage< ::serial_v2::Uint32Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.uint32_vec_value_;
}
inline ::serial_v2::Uint32Vec* AttrValue::mutable_uint32_vec_value() {
  ::serial_v2::Uint32Vec* _msg = _internal_mutable_uint32_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.uint32_vec_value)
  return _msg;
}

// .serial_v2.Int64Vec int64_vec_value = 16;
inline bool AttrValue::_internal_has_int64_vec_value() const {
  return value_case() == kInt64VecValue;
}
inline bool AttrValue::has_int64_vec_value() const {
  return _internal_has_int64_vec_value();
}
inline void AttrValue::set_has_int64_vec_value() {
  _impl_._oneof_case_[0] = kInt64VecValue;
}
inline void AttrValue::clear_int64_vec_value() {
  if (_internal_has_int64_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.int64_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::Int64Vec* AttrValue::release_int64_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.int64_vec_value)
  if (_internal_has_int64_vec_value()) {
    clear_has_value();
    ::serial_v2::Int64Vec* temp = _impl_.value_.int64_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.int64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::Int64Vec& AttrValue::_internal_int64_vec_value() const {
  return _internal_has_int64_vec_value()
      ? *_impl_.value_.int64_vec_value_
      : reinterpret_cast< ::serial_v2::Int64Vec&>(::serial_v2::_Int64Vec_default_instance_);
}
inline const ::serial_v2::Int64Vec& AttrValue::int64_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.int64_vec_value)
  return _internal_int64_vec_value();
}
inline ::serial_v2::Int64Vec* AttrValue::unsafe_arena_release_int64_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.int64_vec_value)
  if (_internal_has_int64_vec_value()) {
    clear_has_value();
    ::serial_v2::Int64Vec* temp = _impl_.value_.int64_vec_value_;
    _impl_.value_.int64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_int64_vec_value(::serial_v2::Int64Vec* int64_vec_value) {
  clear_value();
  if (int64_vec_value) {
    set_has_int64_vec_value();
    _impl_.value_.int64_vec_value_ = int64_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.int64_vec_value)
}
inline ::serial_v2::Int64Vec* AttrValue::_internal_mutable_int64_vec_value() {
  if (!_internal_has_int64_vec_value()) {
    clear_value();
    set_has_int64_vec_value();
    _impl_.value_.int64_vec_value_ = CreateMaybeMessage< ::serial_v2::Int64Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.int64_vec_value_;
}
inline ::serial_v2::Int64Vec* AttrValue::mutable_int64_vec_value() {
  ::serial_v2::Int64Vec* _msg = _internal_mutable_int64_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.int64_vec_value)
  return _msg;
}

// .serial_v2.Uint64Vec uint64_vec_value = 17;
inline bool AttrValue::_internal_has_uint64_vec_value() const {
  return value_case() == kUint64VecValue;
}
inline bool AttrValue::has_uint64_vec_value() const {
  return _internal_has_uint64_vec_value();
}
inline void AttrValue::set_has_uint64_vec_value() {
  _impl_._oneof_case_[0] = kUint64VecValue;
}
inline void AttrValue::clear_uint64_vec_value() {
  if (_internal_has_uint64_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.uint64_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::Uint64Vec* AttrValue::release_uint64_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.uint64_vec_value)
  if (_internal_has_uint64_vec_value()) {
    clear_has_value();
    ::serial_v2::Uint64Vec* temp = _impl_.value_.uint64_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.uint64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::Uint64Vec& AttrValue::_internal_uint64_vec_value() const {
  return _internal_has_uint64_vec_value()
      ? *_impl_.value_.uint64_vec_value_
      : reinterpret_cast< ::serial_v2::Uint64Vec&>(::serial_v2::_Uint64Vec_default_instance_);
}
inline const ::serial_v2::Uint64Vec& AttrValue::uint64_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.uint64_vec_value)
  return _internal_uint64_vec_value();
}
inline ::serial_v2::Uint64Vec* AttrValue::unsafe_arena_release_uint64_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.uint64_vec_value)
  if (_internal_has_uint64_vec_value()) {
    clear_has_value();
    ::serial_v2::Uint64Vec* temp = _impl_.value_.uint64_vec_value_;
    _impl_.value_.uint64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_uint64_vec_value(::serial_v2::Uint64Vec* uint64_vec_value) {
  clear_value();
  if (uint64_vec_value) {
    set_has_uint64_vec_value();
    _impl_.value_.uint64_vec_value_ = uint64_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.uint64_vec_value)
}
inline ::serial_v2::Uint64Vec* AttrValue::_internal_mutable_uint64_vec_value() {
  if (!_internal_has_uint64_vec_value()) {
    clear_value();
    set_has_uint64_vec_value();
    _impl_.value_.uint64_vec_value_ = CreateMaybeMessage< ::serial_v2::Uint64Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.uint64_vec_value_;
}
inline ::serial_v2::Uint64Vec* AttrValue::mutable_uint64_vec_value() {
  ::serial_v2::Uint64Vec* _msg = _internal_mutable_uint64_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.uint64_vec_value)
  return _msg;
}

// .serial_v2.FloatVec float_vec_value = 18;
inline bool AttrValue::_internal_has_float_vec_value() const {
  return value_case() == kFloatVecValue;
}
inline bool AttrValue::has_float_vec_value() const {
  return _internal_has_float_vec_value();
}
inline void AttrValue::set_has_float_vec_value() {
  _impl_._oneof_case_[0] = kFloatVecValue;
}
inline void AttrValue::clear_float_vec_value() {
  if (_internal_has_float_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.float_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::FloatVec* AttrValue::release_float_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.float_vec_value)
  if (_internal_has_float_vec_value()) {
    clear_has_value();
    ::serial_v2::FloatVec* temp = _impl_.value_.float_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.float_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::FloatVec& AttrValue::_internal_float_vec_value() const {
  return _internal_has_float_vec_value()
      ? *_impl_.value_.float_vec_value_
      : reinterpret_cast< ::serial_v2::FloatVec&>(::serial_v2::_FloatVec_default_instance_);
}
inline const ::serial_v2::FloatVec& AttrValue::float_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.float_vec_value)
  return _internal_float_vec_value();
}
inline ::serial_v2::FloatVec* AttrValue::unsafe_arena_release_float_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.float_vec_value)
  if (_internal_has_float_vec_value()) {
    clear_has_value();
    ::serial_v2::FloatVec* temp = _impl_.value_.float_vec_value_;
    _impl_.value_.float_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_float_vec_value(::serial_v2::FloatVec* float_vec_value) {
  clear_value();
  if (float_vec_value) {
    set_has_float_vec_value();
    _impl_.value_.float_vec_value_ = float_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.float_vec_value)
}
inline ::serial_v2::FloatVec* AttrValue::_internal_mutable_float_vec_value() {
  if (!_internal_has_float_vec_value()) {
    clear_value();
    set_has_float_vec_value();
    _impl_.value_.float_vec_value_ = CreateMaybeMessage< ::serial_v2::FloatVec >(GetArenaForAllocation());
  }
  return _impl_.value_.float_vec_value_;
}
inline ::serial_v2::FloatVec* AttrValue::mutable_float_vec_value() {
  ::serial_v2::FloatVec* _msg = _internal_mutable_float_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.float_vec_value)
  return _msg;
}

// .serial_v2.DoubleVec double_vec_value = 19;
inline bool AttrValue::_internal_has_double_vec_value() const {
  return value_case() == kDoubleVecValue;
}
inline bool AttrValue::has_double_vec_value() const {
  return _internal_has_double_vec_value();
}
inline void AttrValue::set_has_double_vec_value() {
  _impl_._oneof_case_[0] = kDoubleVecValue;
}
inline void AttrValue::clear_double_vec_value() {
  if (_internal_has_double_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.double_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::DoubleVec* AttrValue::release_double_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.double_vec_value)
  if (_internal_has_double_vec_value()) {
    clear_has_value();
    ::serial_v2::DoubleVec* temp = _impl_.value_.double_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.double_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::DoubleVec& AttrValue::_internal_double_vec_value() const {
  return _internal_has_double_vec_value()
      ? *_impl_.value_.double_vec_value_
      : reinterpret_cast< ::serial_v2::DoubleVec&>(::serial_v2::_DoubleVec_default_instance_);
}
inline const ::serial_v2::DoubleVec& AttrValue::double_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.double_vec_value)
  return _internal_double_vec_value();
}
inline ::serial_v2::DoubleVec* AttrValue::unsafe_arena_release_double_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.double_vec_value)
  if (_internal_has_double_vec_value()) {
    clear_has_value();
    ::serial_v2::DoubleVec* temp = _impl_.value_.double_vec_value_;
    _impl_.value_.double_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_double_vec_value(::serial_v2::DoubleVec* double_vec_value) {
  clear_value();
  if (double_vec_value) {
    set_has_double_vec_value();
    _impl_.value_.double_vec_value_ = double_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.double_vec_value)
}
inline ::serial_v2::DoubleVec* AttrValue::_internal_mutable_double_vec_value() {
  if (!_internal_has_double_vec_value()) {
    clear_value();
    set_has_double_vec_value();
    _impl_.value_.double_vec_value_ = CreateMaybeMessage< ::serial_v2::DoubleVec >(GetArenaForAllocation());
  }
  return _impl_.value_.double_vec_value_;
}
inline ::serial_v2::DoubleVec* AttrValue::mutable_double_vec_value() {
  ::serial_v2::DoubleVec* _msg = _internal_mutable_double_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.double_vec_value)
  return _msg;
}

// .serial_v2.StringVec string_vec_value = 20;
inline bool AttrValue::_internal_has_string_vec_value() const {
  return value_case() == kStringVecValue;
}
inline bool AttrValue::has_string_vec_value() const {
  return _internal_has_string_vec_value();
}
inline void AttrValue::set_has_string_vec_value() {
  _impl_._oneof_case_[0] = kStringVecValue;
}
inline void AttrValue::clear_string_vec_value() {
  if (_internal_has_string_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.string_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::StringVec* AttrValue::release_string_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.string_vec_value)
  if (_internal_has_string_vec_value()) {
    clear_has_value();
    ::serial_v2::StringVec* temp = _impl_.value_.string_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.string_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::StringVec& AttrValue::_internal_string_vec_value() const {
  return _internal_has_string_vec_value()
      ? *_impl_.value_.string_vec_value_
      : reinterpret_cast< ::serial_v2::StringVec&>(::serial_v2::_StringVec_default_instance_);
}
inline const ::serial_v2::StringVec& AttrValue::string_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.string_vec_value)
  return _internal_string_vec_value();
}
inline ::serial_v2::StringVec* AttrValue::unsafe_arena_release_string_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.string_vec_value)
  if (_internal_has_string_vec_value()) {
    clear_has_value();
    ::serial_v2::StringVec* temp = _impl_.value_.string_vec_value_;
    _impl_.value_.string_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_string_vec_value(::serial_v2::StringVec* string_vec_value) {
  clear_value();
  if (string_vec_value) {
    set_has_string_vec_value();
    _impl_.value_.string_vec_value_ = string_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.string_vec_value)
}
inline ::serial_v2::StringVec* AttrValue::_internal_mutable_string_vec_value() {
  if (!_internal_has_string_vec_value()) {
    clear_value();
    set_has_string_vec_value();
    _impl_.value_.string_vec_value_ = CreateMaybeMessage< ::serial_v2::StringVec >(GetArenaForAllocation());
  }
  return _impl_.value_.string_vec_value_;
}
inline ::serial_v2::StringVec* AttrValue::mutable_string_vec_value() {
  ::serial_v2::StringVec* _msg = _internal_mutable_string_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.string_vec_value)
  return _msg;
}

// .serial_v2.BytesVec bytes_vec_value = 21;
inline bool AttrValue::_internal_has_bytes_vec_value() const {
  return value_case() == kBytesVecValue;
}
inline bool AttrValue::has_bytes_vec_value() const {
  return _internal_has_bytes_vec_value();
}
inline void AttrValue::set_has_bytes_vec_value() {
  _impl_._oneof_case_[0] = kBytesVecValue;
}
inline void AttrValue::clear_bytes_vec_value() {
  if (_internal_has_bytes_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.bytes_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::BytesVec* AttrValue::release_bytes_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.bytes_vec_value)
  if (_internal_has_bytes_vec_value()) {
    clear_has_value();
    ::serial_v2::BytesVec* temp = _impl_.value_.bytes_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.bytes_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::BytesVec& AttrValue::_internal_bytes_vec_value() const {
  return _internal_has_bytes_vec_value()
      ? *_impl_.value_.bytes_vec_value_
      : reinterpret_cast< ::serial_v2::BytesVec&>(::serial_v2::_BytesVec_default_instance_);
}
inline const ::serial_v2::BytesVec& AttrValue::bytes_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.bytes_vec_value)
  return _internal_bytes_vec_value();
}
inline ::serial_v2::BytesVec* AttrValue::unsafe_arena_release_bytes_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.bytes_vec_value)
  if (_internal_has_bytes_vec_value()) {
    clear_has_value();
    ::serial_v2::BytesVec* temp = _impl_.value_.bytes_vec_value_;
    _impl_.value_.bytes_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_bytes_vec_value(::serial_v2::BytesVec* bytes_vec_value) {
  clear_value();
  if (bytes_vec_value) {
    set_has_bytes_vec_value();
    _impl_.value_.bytes_vec_value_ = bytes_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.bytes_vec_value)
}
inline ::serial_v2::BytesVec* AttrValue::_internal_mutable_bytes_vec_value() {
  if (!_internal_has_bytes_vec_value()) {
    clear_value();
    set_has_bytes_vec_value();
    _impl_.value_.bytes_vec_value_ = CreateMaybeMessage< ::serial_v2::BytesVec >(GetArenaForAllocation());
  }
  return _impl_.value_.bytes_vec_value_;
}
inline ::serial_v2::BytesVec* AttrValue::mutable_bytes_vec_value() {
  ::serial_v2::BytesVec* _msg = _internal_mutable_bytes_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.bytes_vec_value)
  return _msg;
}

// .serial_v2.MapString2Int32 map_string_2_int32_value = 22;
inline bool AttrValue::_internal_has_map_string_2_int32_value() const {
  return value_case() == kMapString2Int32Value;
}
inline bool AttrValue::has_map_string_2_int32_value() const {
  return _internal_has_map_string_2_int32_value();
}
inline void AttrValue::set_has_map_string_2_int32_value() {
  _impl_._oneof_case_[0] = kMapString2Int32Value;
}
inline void AttrValue::clear_map_string_2_int32_value() {
  if (_internal_has_map_string_2_int32_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_int32_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Int32* AttrValue::release_map_string_2_int32_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_int32_value)
  if (_internal_has_map_string_2_int32_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int32* temp = _impl_.value_.map_string_2_int32_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_int32_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Int32& AttrValue::_internal_map_string_2_int32_value() const {
  return _internal_has_map_string_2_int32_value()
      ? *_impl_.value_.map_string_2_int32_value_
      : reinterpret_cast< ::serial_v2::MapString2Int32&>(::serial_v2::_MapString2Int32_default_instance_);
}
inline const ::serial_v2::MapString2Int32& AttrValue::map_string_2_int32_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_int32_value)
  return _internal_map_string_2_int32_value();
}
inline ::serial_v2::MapString2Int32* AttrValue::unsafe_arena_release_map_string_2_int32_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_int32_value)
  if (_internal_has_map_string_2_int32_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int32* temp = _impl_.value_.map_string_2_int32_value_;
    _impl_.value_.map_string_2_int32_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_int32_value(::serial_v2::MapString2Int32* map_string_2_int32_value) {
  clear_value();
  if (map_string_2_int32_value) {
    set_has_map_string_2_int32_value();
    _impl_.value_.map_string_2_int32_value_ = map_string_2_int32_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_int32_value)
}
inline ::serial_v2::MapString2Int32* AttrValue::_internal_mutable_map_string_2_int32_value() {
  if (!_internal_has_map_string_2_int32_value()) {
    clear_value();
    set_has_map_string_2_int32_value();
    _impl_.value_.map_string_2_int32_value_ = CreateMaybeMessage< ::serial_v2::MapString2Int32 >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_int32_value_;
}
inline ::serial_v2::MapString2Int32* AttrValue::mutable_map_string_2_int32_value() {
  ::serial_v2::MapString2Int32* _msg = _internal_mutable_map_string_2_int32_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_int32_value)
  return _msg;
}

// .serial_v2.MapString2Uint32 map_string_2_uint32_value = 23;
inline bool AttrValue::_internal_has_map_string_2_uint32_value() const {
  return value_case() == kMapString2Uint32Value;
}
inline bool AttrValue::has_map_string_2_uint32_value() const {
  return _internal_has_map_string_2_uint32_value();
}
inline void AttrValue::set_has_map_string_2_uint32_value() {
  _impl_._oneof_case_[0] = kMapString2Uint32Value;
}
inline void AttrValue::clear_map_string_2_uint32_value() {
  if (_internal_has_map_string_2_uint32_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_uint32_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Uint32* AttrValue::release_map_string_2_uint32_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_uint32_value)
  if (_internal_has_map_string_2_uint32_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint32* temp = _impl_.value_.map_string_2_uint32_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_uint32_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Uint32& AttrValue::_internal_map_string_2_uint32_value() const {
  return _internal_has_map_string_2_uint32_value()
      ? *_impl_.value_.map_string_2_uint32_value_
      : reinterpret_cast< ::serial_v2::MapString2Uint32&>(::serial_v2::_MapString2Uint32_default_instance_);
}
inline const ::serial_v2::MapString2Uint32& AttrValue::map_string_2_uint32_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_uint32_value)
  return _internal_map_string_2_uint32_value();
}
inline ::serial_v2::MapString2Uint32* AttrValue::unsafe_arena_release_map_string_2_uint32_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_uint32_value)
  if (_internal_has_map_string_2_uint32_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint32* temp = _impl_.value_.map_string_2_uint32_value_;
    _impl_.value_.map_string_2_uint32_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_uint32_value(::serial_v2::MapString2Uint32* map_string_2_uint32_value) {
  clear_value();
  if (map_string_2_uint32_value) {
    set_has_map_string_2_uint32_value();
    _impl_.value_.map_string_2_uint32_value_ = map_string_2_uint32_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_uint32_value)
}
inline ::serial_v2::MapString2Uint32* AttrValue::_internal_mutable_map_string_2_uint32_value() {
  if (!_internal_has_map_string_2_uint32_value()) {
    clear_value();
    set_has_map_string_2_uint32_value();
    _impl_.value_.map_string_2_uint32_value_ = CreateMaybeMessage< ::serial_v2::MapString2Uint32 >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_uint32_value_;
}
inline ::serial_v2::MapString2Uint32* AttrValue::mutable_map_string_2_uint32_value() {
  ::serial_v2::MapString2Uint32* _msg = _internal_mutable_map_string_2_uint32_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_uint32_value)
  return _msg;
}

// .serial_v2.MapString2Int64 map_string_2_int64_value = 24;
inline bool AttrValue::_internal_has_map_string_2_int64_value() const {
  return value_case() == kMapString2Int64Value;
}
inline bool AttrValue::has_map_string_2_int64_value() const {
  return _internal_has_map_string_2_int64_value();
}
inline void AttrValue::set_has_map_string_2_int64_value() {
  _impl_._oneof_case_[0] = kMapString2Int64Value;
}
inline void AttrValue::clear_map_string_2_int64_value() {
  if (_internal_has_map_string_2_int64_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_int64_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Int64* AttrValue::release_map_string_2_int64_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_int64_value)
  if (_internal_has_map_string_2_int64_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int64* temp = _impl_.value_.map_string_2_int64_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_int64_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Int64& AttrValue::_internal_map_string_2_int64_value() const {
  return _internal_has_map_string_2_int64_value()
      ? *_impl_.value_.map_string_2_int64_value_
      : reinterpret_cast< ::serial_v2::MapString2Int64&>(::serial_v2::_MapString2Int64_default_instance_);
}
inline const ::serial_v2::MapString2Int64& AttrValue::map_string_2_int64_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_int64_value)
  return _internal_map_string_2_int64_value();
}
inline ::serial_v2::MapString2Int64* AttrValue::unsafe_arena_release_map_string_2_int64_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_int64_value)
  if (_internal_has_map_string_2_int64_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int64* temp = _impl_.value_.map_string_2_int64_value_;
    _impl_.value_.map_string_2_int64_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_int64_value(::serial_v2::MapString2Int64* map_string_2_int64_value) {
  clear_value();
  if (map_string_2_int64_value) {
    set_has_map_string_2_int64_value();
    _impl_.value_.map_string_2_int64_value_ = map_string_2_int64_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_int64_value)
}
inline ::serial_v2::MapString2Int64* AttrValue::_internal_mutable_map_string_2_int64_value() {
  if (!_internal_has_map_string_2_int64_value()) {
    clear_value();
    set_has_map_string_2_int64_value();
    _impl_.value_.map_string_2_int64_value_ = CreateMaybeMessage< ::serial_v2::MapString2Int64 >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_int64_value_;
}
inline ::serial_v2::MapString2Int64* AttrValue::mutable_map_string_2_int64_value() {
  ::serial_v2::MapString2Int64* _msg = _internal_mutable_map_string_2_int64_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_int64_value)
  return _msg;
}

// .serial_v2.MapString2Uint64 map_string_2_uint64_value = 25;
inline bool AttrValue::_internal_has_map_string_2_uint64_value() const {
  return value_case() == kMapString2Uint64Value;
}
inline bool AttrValue::has_map_string_2_uint64_value() const {
  return _internal_has_map_string_2_uint64_value();
}
inline void AttrValue::set_has_map_string_2_uint64_value() {
  _impl_._oneof_case_[0] = kMapString2Uint64Value;
}
inline void AttrValue::clear_map_string_2_uint64_value() {
  if (_internal_has_map_string_2_uint64_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_uint64_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Uint64* AttrValue::release_map_string_2_uint64_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_uint64_value)
  if (_internal_has_map_string_2_uint64_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint64* temp = _impl_.value_.map_string_2_uint64_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_uint64_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Uint64& AttrValue::_internal_map_string_2_uint64_value() const {
  return _internal_has_map_string_2_uint64_value()
      ? *_impl_.value_.map_string_2_uint64_value_
      : reinterpret_cast< ::serial_v2::MapString2Uint64&>(::serial_v2::_MapString2Uint64_default_instance_);
}
inline const ::serial_v2::MapString2Uint64& AttrValue::map_string_2_uint64_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_uint64_value)
  return _internal_map_string_2_uint64_value();
}
inline ::serial_v2::MapString2Uint64* AttrValue::unsafe_arena_release_map_string_2_uint64_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_uint64_value)
  if (_internal_has_map_string_2_uint64_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint64* temp = _impl_.value_.map_string_2_uint64_value_;
    _impl_.value_.map_string_2_uint64_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_uint64_value(::serial_v2::MapString2Uint64* map_string_2_uint64_value) {
  clear_value();
  if (map_string_2_uint64_value) {
    set_has_map_string_2_uint64_value();
    _impl_.value_.map_string_2_uint64_value_ = map_string_2_uint64_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_uint64_value)
}
inline ::serial_v2::MapString2Uint64* AttrValue::_internal_mutable_map_string_2_uint64_value() {
  if (!_internal_has_map_string_2_uint64_value()) {
    clear_value();
    set_has_map_string_2_uint64_value();
    _impl_.value_.map_string_2_uint64_value_ = CreateMaybeMessage< ::serial_v2::MapString2Uint64 >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_uint64_value_;
}
inline ::serial_v2::MapString2Uint64* AttrValue::mutable_map_string_2_uint64_value() {
  ::serial_v2::MapString2Uint64* _msg = _internal_mutable_map_string_2_uint64_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_uint64_value)
  return _msg;
}

// .serial_v2.MapString2String map_string_2_string_value = 26;
inline bool AttrValue::_internal_has_map_string_2_string_value() const {
  return value_case() == kMapString2StringValue;
}
inline bool AttrValue::has_map_string_2_string_value() const {
  return _internal_has_map_string_2_string_value();
}
inline void AttrValue::set_has_map_string_2_string_value() {
  _impl_._oneof_case_[0] = kMapString2StringValue;
}
inline void AttrValue::clear_map_string_2_string_value() {
  if (_internal_has_map_string_2_string_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_string_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2String* AttrValue::release_map_string_2_string_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_string_value)
  if (_internal_has_map_string_2_string_value()) {
    clear_has_value();
    ::serial_v2::MapString2String* temp = _impl_.value_.map_string_2_string_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_string_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2String& AttrValue::_internal_map_string_2_string_value() const {
  return _internal_has_map_string_2_string_value()
      ? *_impl_.value_.map_string_2_string_value_
      : reinterpret_cast< ::serial_v2::MapString2String&>(::serial_v2::_MapString2String_default_instance_);
}
inline const ::serial_v2::MapString2String& AttrValue::map_string_2_string_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_string_value)
  return _internal_map_string_2_string_value();
}
inline ::serial_v2::MapString2String* AttrValue::unsafe_arena_release_map_string_2_string_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_string_value)
  if (_internal_has_map_string_2_string_value()) {
    clear_has_value();
    ::serial_v2::MapString2String* temp = _impl_.value_.map_string_2_string_value_;
    _impl_.value_.map_string_2_string_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_string_value(::serial_v2::MapString2String* map_string_2_string_value) {
  clear_value();
  if (map_string_2_string_value) {
    set_has_map_string_2_string_value();
    _impl_.value_.map_string_2_string_value_ = map_string_2_string_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_string_value)
}
inline ::serial_v2::MapString2String* AttrValue::_internal_mutable_map_string_2_string_value() {
  if (!_internal_has_map_string_2_string_value()) {
    clear_value();
    set_has_map_string_2_string_value();
    _impl_.value_.map_string_2_string_value_ = CreateMaybeMessage< ::serial_v2::MapString2String >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_string_value_;
}
inline ::serial_v2::MapString2String* AttrValue::mutable_map_string_2_string_value() {
  ::serial_v2::MapString2String* _msg = _internal_mutable_map_string_2_string_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_string_value)
  return _msg;
}

// .serial_v2.MapString2Bytes map_string_2_bytes_value = 27;
inline bool AttrValue::_internal_has_map_string_2_bytes_value() const {
  return value_case() == kMapString2BytesValue;
}
inline bool AttrValue::has_map_string_2_bytes_value() const {
  return _internal_has_map_string_2_bytes_value();
}
inline void AttrValue::set_has_map_string_2_bytes_value() {
  _impl_._oneof_case_[0] = kMapString2BytesValue;
}
inline void AttrValue::clear_map_string_2_bytes_value() {
  if (_internal_has_map_string_2_bytes_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_bytes_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Bytes* AttrValue::release_map_string_2_bytes_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_bytes_value)
  if (_internal_has_map_string_2_bytes_value()) {
    clear_has_value();
    ::serial_v2::MapString2Bytes* temp = _impl_.value_.map_string_2_bytes_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_bytes_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Bytes& AttrValue::_internal_map_string_2_bytes_value() const {
  return _internal_has_map_string_2_bytes_value()
      ? *_impl_.value_.map_string_2_bytes_value_
      : reinterpret_cast< ::serial_v2::MapString2Bytes&>(::serial_v2::_MapString2Bytes_default_instance_);
}
inline const ::serial_v2::MapString2Bytes& AttrValue::map_string_2_bytes_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_bytes_value)
  return _internal_map_string_2_bytes_value();
}
inline ::serial_v2::MapString2Bytes* AttrValue::unsafe_arena_release_map_string_2_bytes_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_bytes_value)
  if (_internal_has_map_string_2_bytes_value()) {
    clear_has_value();
    ::serial_v2::MapString2Bytes* temp = _impl_.value_.map_string_2_bytes_value_;
    _impl_.value_.map_string_2_bytes_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_bytes_value(::serial_v2::MapString2Bytes* map_string_2_bytes_value) {
  clear_value();
  if (map_string_2_bytes_value) {
    set_has_map_string_2_bytes_value();
    _impl_.value_.map_string_2_bytes_value_ = map_string_2_bytes_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_bytes_value)
}
inline ::serial_v2::MapString2Bytes* AttrValue::_internal_mutable_map_string_2_bytes_value() {
  if (!_internal_has_map_string_2_bytes_value()) {
    clear_value();
    set_has_map_string_2_bytes_value();
    _impl_.value_.map_string_2_bytes_value_ = CreateMaybeMessage< ::serial_v2::MapString2Bytes >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_bytes_value_;
}
inline ::serial_v2::MapString2Bytes* AttrValue::mutable_map_string_2_bytes_value() {
  ::serial_v2::MapString2Bytes* _msg = _internal_mutable_map_string_2_bytes_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_bytes_value)
  return _msg;
}

// .serial_v2.MapString2Int32Vec map_string_2_int32_vec_value = 28;
inline bool AttrValue::_internal_has_map_string_2_int32_vec_value() const {
  return value_case() == kMapString2Int32VecValue;
}
inline bool AttrValue::has_map_string_2_int32_vec_value() const {
  return _internal_has_map_string_2_int32_vec_value();
}
inline void AttrValue::set_has_map_string_2_int32_vec_value() {
  _impl_._oneof_case_[0] = kMapString2Int32VecValue;
}
inline void AttrValue::clear_map_string_2_int32_vec_value() {
  if (_internal_has_map_string_2_int32_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_int32_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Int32Vec* AttrValue::release_map_string_2_int32_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_int32_vec_value)
  if (_internal_has_map_string_2_int32_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int32Vec* temp = _impl_.value_.map_string_2_int32_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_int32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Int32Vec& AttrValue::_internal_map_string_2_int32_vec_value() const {
  return _internal_has_map_string_2_int32_vec_value()
      ? *_impl_.value_.map_string_2_int32_vec_value_
      : reinterpret_cast< ::serial_v2::MapString2Int32Vec&>(::serial_v2::_MapString2Int32Vec_default_instance_);
}
inline const ::serial_v2::MapString2Int32Vec& AttrValue::map_string_2_int32_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_int32_vec_value)
  return _internal_map_string_2_int32_vec_value();
}
inline ::serial_v2::MapString2Int32Vec* AttrValue::unsafe_arena_release_map_string_2_int32_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_int32_vec_value)
  if (_internal_has_map_string_2_int32_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int32Vec* temp = _impl_.value_.map_string_2_int32_vec_value_;
    _impl_.value_.map_string_2_int32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_int32_vec_value(::serial_v2::MapString2Int32Vec* map_string_2_int32_vec_value) {
  clear_value();
  if (map_string_2_int32_vec_value) {
    set_has_map_string_2_int32_vec_value();
    _impl_.value_.map_string_2_int32_vec_value_ = map_string_2_int32_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_int32_vec_value)
}
inline ::serial_v2::MapString2Int32Vec* AttrValue::_internal_mutable_map_string_2_int32_vec_value() {
  if (!_internal_has_map_string_2_int32_vec_value()) {
    clear_value();
    set_has_map_string_2_int32_vec_value();
    _impl_.value_.map_string_2_int32_vec_value_ = CreateMaybeMessage< ::serial_v2::MapString2Int32Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_int32_vec_value_;
}
inline ::serial_v2::MapString2Int32Vec* AttrValue::mutable_map_string_2_int32_vec_value() {
  ::serial_v2::MapString2Int32Vec* _msg = _internal_mutable_map_string_2_int32_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_int32_vec_value)
  return _msg;
}

// .serial_v2.MapString2Uint32Vec map_string_2_uint32_vec_value = 29;
inline bool AttrValue::_internal_has_map_string_2_uint32_vec_value() const {
  return value_case() == kMapString2Uint32VecValue;
}
inline bool AttrValue::has_map_string_2_uint32_vec_value() const {
  return _internal_has_map_string_2_uint32_vec_value();
}
inline void AttrValue::set_has_map_string_2_uint32_vec_value() {
  _impl_._oneof_case_[0] = kMapString2Uint32VecValue;
}
inline void AttrValue::clear_map_string_2_uint32_vec_value() {
  if (_internal_has_map_string_2_uint32_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_uint32_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Uint32Vec* AttrValue::release_map_string_2_uint32_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_uint32_vec_value)
  if (_internal_has_map_string_2_uint32_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint32Vec* temp = _impl_.value_.map_string_2_uint32_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_uint32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Uint32Vec& AttrValue::_internal_map_string_2_uint32_vec_value() const {
  return _internal_has_map_string_2_uint32_vec_value()
      ? *_impl_.value_.map_string_2_uint32_vec_value_
      : reinterpret_cast< ::serial_v2::MapString2Uint32Vec&>(::serial_v2::_MapString2Uint32Vec_default_instance_);
}
inline const ::serial_v2::MapString2Uint32Vec& AttrValue::map_string_2_uint32_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_uint32_vec_value)
  return _internal_map_string_2_uint32_vec_value();
}
inline ::serial_v2::MapString2Uint32Vec* AttrValue::unsafe_arena_release_map_string_2_uint32_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_uint32_vec_value)
  if (_internal_has_map_string_2_uint32_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint32Vec* temp = _impl_.value_.map_string_2_uint32_vec_value_;
    _impl_.value_.map_string_2_uint32_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_uint32_vec_value(::serial_v2::MapString2Uint32Vec* map_string_2_uint32_vec_value) {
  clear_value();
  if (map_string_2_uint32_vec_value) {
    set_has_map_string_2_uint32_vec_value();
    _impl_.value_.map_string_2_uint32_vec_value_ = map_string_2_uint32_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_uint32_vec_value)
}
inline ::serial_v2::MapString2Uint32Vec* AttrValue::_internal_mutable_map_string_2_uint32_vec_value() {
  if (!_internal_has_map_string_2_uint32_vec_value()) {
    clear_value();
    set_has_map_string_2_uint32_vec_value();
    _impl_.value_.map_string_2_uint32_vec_value_ = CreateMaybeMessage< ::serial_v2::MapString2Uint32Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_uint32_vec_value_;
}
inline ::serial_v2::MapString2Uint32Vec* AttrValue::mutable_map_string_2_uint32_vec_value() {
  ::serial_v2::MapString2Uint32Vec* _msg = _internal_mutable_map_string_2_uint32_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_uint32_vec_value)
  return _msg;
}

// .serial_v2.MapString2Int64Vec map_string_2_int64_vec_value = 30;
inline bool AttrValue::_internal_has_map_string_2_int64_vec_value() const {
  return value_case() == kMapString2Int64VecValue;
}
inline bool AttrValue::has_map_string_2_int64_vec_value() const {
  return _internal_has_map_string_2_int64_vec_value();
}
inline void AttrValue::set_has_map_string_2_int64_vec_value() {
  _impl_._oneof_case_[0] = kMapString2Int64VecValue;
}
inline void AttrValue::clear_map_string_2_int64_vec_value() {
  if (_internal_has_map_string_2_int64_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_int64_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Int64Vec* AttrValue::release_map_string_2_int64_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_int64_vec_value)
  if (_internal_has_map_string_2_int64_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int64Vec* temp = _impl_.value_.map_string_2_int64_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_int64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Int64Vec& AttrValue::_internal_map_string_2_int64_vec_value() const {
  return _internal_has_map_string_2_int64_vec_value()
      ? *_impl_.value_.map_string_2_int64_vec_value_
      : reinterpret_cast< ::serial_v2::MapString2Int64Vec&>(::serial_v2::_MapString2Int64Vec_default_instance_);
}
inline const ::serial_v2::MapString2Int64Vec& AttrValue::map_string_2_int64_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_int64_vec_value)
  return _internal_map_string_2_int64_vec_value();
}
inline ::serial_v2::MapString2Int64Vec* AttrValue::unsafe_arena_release_map_string_2_int64_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_int64_vec_value)
  if (_internal_has_map_string_2_int64_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Int64Vec* temp = _impl_.value_.map_string_2_int64_vec_value_;
    _impl_.value_.map_string_2_int64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_int64_vec_value(::serial_v2::MapString2Int64Vec* map_string_2_int64_vec_value) {
  clear_value();
  if (map_string_2_int64_vec_value) {
    set_has_map_string_2_int64_vec_value();
    _impl_.value_.map_string_2_int64_vec_value_ = map_string_2_int64_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_int64_vec_value)
}
inline ::serial_v2::MapString2Int64Vec* AttrValue::_internal_mutable_map_string_2_int64_vec_value() {
  if (!_internal_has_map_string_2_int64_vec_value()) {
    clear_value();
    set_has_map_string_2_int64_vec_value();
    _impl_.value_.map_string_2_int64_vec_value_ = CreateMaybeMessage< ::serial_v2::MapString2Int64Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_int64_vec_value_;
}
inline ::serial_v2::MapString2Int64Vec* AttrValue::mutable_map_string_2_int64_vec_value() {
  ::serial_v2::MapString2Int64Vec* _msg = _internal_mutable_map_string_2_int64_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_int64_vec_value)
  return _msg;
}

// .serial_v2.MapString2Uint64Vec map_string_2_uint64_vec_value = 31;
inline bool AttrValue::_internal_has_map_string_2_uint64_vec_value() const {
  return value_case() == kMapString2Uint64VecValue;
}
inline bool AttrValue::has_map_string_2_uint64_vec_value() const {
  return _internal_has_map_string_2_uint64_vec_value();
}
inline void AttrValue::set_has_map_string_2_uint64_vec_value() {
  _impl_._oneof_case_[0] = kMapString2Uint64VecValue;
}
inline void AttrValue::clear_map_string_2_uint64_vec_value() {
  if (_internal_has_map_string_2_uint64_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_uint64_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2Uint64Vec* AttrValue::release_map_string_2_uint64_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_uint64_vec_value)
  if (_internal_has_map_string_2_uint64_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint64Vec* temp = _impl_.value_.map_string_2_uint64_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_uint64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2Uint64Vec& AttrValue::_internal_map_string_2_uint64_vec_value() const {
  return _internal_has_map_string_2_uint64_vec_value()
      ? *_impl_.value_.map_string_2_uint64_vec_value_
      : reinterpret_cast< ::serial_v2::MapString2Uint64Vec&>(::serial_v2::_MapString2Uint64Vec_default_instance_);
}
inline const ::serial_v2::MapString2Uint64Vec& AttrValue::map_string_2_uint64_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_uint64_vec_value)
  return _internal_map_string_2_uint64_vec_value();
}
inline ::serial_v2::MapString2Uint64Vec* AttrValue::unsafe_arena_release_map_string_2_uint64_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_uint64_vec_value)
  if (_internal_has_map_string_2_uint64_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2Uint64Vec* temp = _impl_.value_.map_string_2_uint64_vec_value_;
    _impl_.value_.map_string_2_uint64_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_uint64_vec_value(::serial_v2::MapString2Uint64Vec* map_string_2_uint64_vec_value) {
  clear_value();
  if (map_string_2_uint64_vec_value) {
    set_has_map_string_2_uint64_vec_value();
    _impl_.value_.map_string_2_uint64_vec_value_ = map_string_2_uint64_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_uint64_vec_value)
}
inline ::serial_v2::MapString2Uint64Vec* AttrValue::_internal_mutable_map_string_2_uint64_vec_value() {
  if (!_internal_has_map_string_2_uint64_vec_value()) {
    clear_value();
    set_has_map_string_2_uint64_vec_value();
    _impl_.value_.map_string_2_uint64_vec_value_ = CreateMaybeMessage< ::serial_v2::MapString2Uint64Vec >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_uint64_vec_value_;
}
inline ::serial_v2::MapString2Uint64Vec* AttrValue::mutable_map_string_2_uint64_vec_value() {
  ::serial_v2::MapString2Uint64Vec* _msg = _internal_mutable_map_string_2_uint64_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_uint64_vec_value)
  return _msg;
}

// .serial_v2.MapString2StringVec map_string_2_string_vec_value = 32;
inline bool AttrValue::_internal_has_map_string_2_string_vec_value() const {
  return value_case() == kMapString2StringVecValue;
}
inline bool AttrValue::has_map_string_2_string_vec_value() const {
  return _internal_has_map_string_2_string_vec_value();
}
inline void AttrValue::set_has_map_string_2_string_vec_value() {
  _impl_._oneof_case_[0] = kMapString2StringVecValue;
}
inline void AttrValue::clear_map_string_2_string_vec_value() {
  if (_internal_has_map_string_2_string_vec_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_.map_string_2_string_vec_value_;
    }
    clear_has_value();
  }
}
inline ::serial_v2::MapString2StringVec* AttrValue::release_map_string_2_string_vec_value() {
  // @@protoc_insertion_point(field_release:serial_v2.AttrValue.map_string_2_string_vec_value)
  if (_internal_has_map_string_2_string_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2StringVec* temp = _impl_.value_.map_string_2_string_vec_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_.map_string_2_string_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v2::MapString2StringVec& AttrValue::_internal_map_string_2_string_vec_value() const {
  return _internal_has_map_string_2_string_vec_value()
      ? *_impl_.value_.map_string_2_string_vec_value_
      : reinterpret_cast< ::serial_v2::MapString2StringVec&>(::serial_v2::_MapString2StringVec_default_instance_);
}
inline const ::serial_v2::MapString2StringVec& AttrValue::map_string_2_string_vec_value() const {
  // @@protoc_insertion_point(field_get:serial_v2.AttrValue.map_string_2_string_vec_value)
  return _internal_map_string_2_string_vec_value();
}
inline ::serial_v2::MapString2StringVec* AttrValue::unsafe_arena_release_map_string_2_string_vec_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v2.AttrValue.map_string_2_string_vec_value)
  if (_internal_has_map_string_2_string_vec_value()) {
    clear_has_value();
    ::serial_v2::MapString2StringVec* temp = _impl_.value_.map_string_2_string_vec_value_;
    _impl_.value_.map_string_2_string_vec_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_map_string_2_string_vec_value(::serial_v2::MapString2StringVec* map_string_2_string_vec_value) {
  clear_value();
  if (map_string_2_string_vec_value) {
    set_has_map_string_2_string_vec_value();
    _impl_.value_.map_string_2_string_vec_value_ = map_string_2_string_vec_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v2.AttrValue.map_string_2_string_vec_value)
}
inline ::serial_v2::MapString2StringVec* AttrValue::_internal_mutable_map_string_2_string_vec_value() {
  if (!_internal_has_map_string_2_string_vec_value()) {
    clear_value();
    set_has_map_string_2_string_vec_value();
    _impl_.value_.map_string_2_string_vec_value_ = CreateMaybeMessage< ::serial_v2::MapString2StringVec >(GetArenaForAllocation());
  }
  return _impl_.value_.map_string_2_string_vec_value_;
}
inline ::serial_v2::MapString2StringVec* AttrValue::mutable_map_string_2_string_vec_value() {
  ::serial_v2::MapString2StringVec* _msg = _internal_mutable_map_string_2_string_vec_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.AttrValue.map_string_2_string_vec_value)
  return _msg;
}

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

// Bytes

// bytes value = 1;
inline void Bytes::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& Bytes::value() const {
  // @@protoc_insertion_point(field_get:serial_v2.Bytes.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Bytes::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v2.Bytes.value)
}
inline std::string* Bytes::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:serial_v2.Bytes.value)
  return _s;
}
inline const std::string& Bytes::_internal_value() const {
  return _impl_.value_.Get();
}
inline void Bytes::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Bytes::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Bytes::release_value() {
  // @@protoc_insertion_point(field_release:serial_v2.Bytes.value)
  return _impl_.value_.Release();
}
inline void Bytes::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v2.Bytes.value)
}

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

// BoolVec

// repeated bool value = 1;
inline int BoolVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int BoolVec::value_size() const {
  return _internal_value_size();
}
inline void BoolVec::clear_value() {
  _impl_.value_.Clear();
}
inline bool BoolVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline bool BoolVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.BoolVec.value)
  return _internal_value(index);
}
inline void BoolVec::set_value(int index, bool value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.BoolVec.value)
}
inline void BoolVec::_internal_add_value(bool value) {
  _impl_.value_.Add(value);
}
inline void BoolVec::add_value(bool value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.BoolVec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolVec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.BoolVec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolVec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.BoolVec.value)
  return _internal_mutable_value();
}

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

// Int32Vec

// repeated int32 value = 1;
inline int Int32Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int Int32Vec::value_size() const {
  return _internal_value_size();
}
inline void Int32Vec::clear_value() {
  _impl_.value_.Clear();
}
inline int32_t Int32Vec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline int32_t Int32Vec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Int32Vec.value)
  return _internal_value(index);
}
inline void Int32Vec::set_value(int index, int32_t value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.Int32Vec.value)
}
inline void Int32Vec::_internal_add_value(int32_t value) {
  _impl_.value_.Add(value);
}
inline void Int32Vec::add_value(int32_t value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.Int32Vec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Int32Vec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Int32Vec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.Int32Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Int32Vec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Int32Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Int32Vec.value)
  return _internal_mutable_value();
}

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

// Uint32Vec

// repeated uint32 value = 1;
inline int Uint32Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int Uint32Vec::value_size() const {
  return _internal_value_size();
}
inline void Uint32Vec::clear_value() {
  _impl_.value_.Clear();
}
inline uint32_t Uint32Vec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline uint32_t Uint32Vec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Uint32Vec.value)
  return _internal_value(index);
}
inline void Uint32Vec::set_value(int index, uint32_t value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.Uint32Vec.value)
}
inline void Uint32Vec::_internal_add_value(uint32_t value) {
  _impl_.value_.Add(value);
}
inline void Uint32Vec::add_value(uint32_t value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.Uint32Vec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Uint32Vec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Uint32Vec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.Uint32Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Uint32Vec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Uint32Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Uint32Vec.value)
  return _internal_mutable_value();
}

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

// Int64Vec

// repeated int64 value = 1;
inline int Int64Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int Int64Vec::value_size() const {
  return _internal_value_size();
}
inline void Int64Vec::clear_value() {
  _impl_.value_.Clear();
}
inline int64_t Int64Vec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline int64_t Int64Vec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Int64Vec.value)
  return _internal_value(index);
}
inline void Int64Vec::set_value(int index, int64_t value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.Int64Vec.value)
}
inline void Int64Vec::_internal_add_value(int64_t value) {
  _impl_.value_.Add(value);
}
inline void Int64Vec::add_value(int64_t value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.Int64Vec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Int64Vec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Int64Vec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.Int64Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Int64Vec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Int64Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Int64Vec.value)
  return _internal_mutable_value();
}

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

// Uint64Vec

// repeated uint64 value = 1;
inline int Uint64Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int Uint64Vec::value_size() const {
  return _internal_value_size();
}
inline void Uint64Vec::clear_value() {
  _impl_.value_.Clear();
}
inline uint64_t Uint64Vec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline uint64_t Uint64Vec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.Uint64Vec.value)
  return _internal_value(index);
}
inline void Uint64Vec::set_value(int index, uint64_t value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.Uint64Vec.value)
}
inline void Uint64Vec::_internal_add_value(uint64_t value) {
  _impl_.value_.Add(value);
}
inline void Uint64Vec::add_value(uint64_t value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.Uint64Vec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
Uint64Vec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
Uint64Vec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.Uint64Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
Uint64Vec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
Uint64Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.Uint64Vec.value)
  return _internal_mutable_value();
}

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

// FloatVec

// repeated float value = 1;
inline int FloatVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int FloatVec::value_size() const {
  return _internal_value_size();
}
inline void FloatVec::clear_value() {
  _impl_.value_.Clear();
}
inline float FloatVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline float FloatVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.FloatVec.value)
  return _internal_value(index);
}
inline void FloatVec::set_value(int index, float value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.FloatVec.value)
}
inline void FloatVec::_internal_add_value(float value) {
  _impl_.value_.Add(value);
}
inline void FloatVec::add_value(float value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.FloatVec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
FloatVec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
FloatVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.FloatVec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
FloatVec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
FloatVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.FloatVec.value)
  return _internal_mutable_value();
}

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

// DoubleVec

// repeated double value = 1;
inline int DoubleVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int DoubleVec::value_size() const {
  return _internal_value_size();
}
inline void DoubleVec::clear_value() {
  _impl_.value_.Clear();
}
inline double DoubleVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline double DoubleVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.DoubleVec.value)
  return _internal_value(index);
}
inline void DoubleVec::set_value(int index, double value) {
  _impl_.value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v2.DoubleVec.value)
}
inline void DoubleVec::_internal_add_value(double value) {
  _impl_.value_.Add(value);
}
inline void DoubleVec::add_value(double value) {
  _internal_add_value(value);
  // @@protoc_insertion_point(field_add:serial_v2.DoubleVec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleVec::_internal_value() const {
  return _impl_.value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.DoubleVec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleVec::_internal_mutable_value() {
  return &_impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.DoubleVec.value)
  return _internal_mutable_value();
}

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

// StringVec

// repeated string value = 1;
inline int StringVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int StringVec::value_size() const {
  return _internal_value_size();
}
inline void StringVec::clear_value() {
  _impl_.value_.Clear();
}
inline std::string* StringVec::add_value() {
  std::string* _s = _internal_add_value();
  // @@protoc_insertion_point(field_add_mutable:serial_v2.StringVec.value)
  return _s;
}
inline const std::string& StringVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline const std::string& StringVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.StringVec.value)
  return _internal_value(index);
}
inline std::string* StringVec::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.StringVec.value)
  return _impl_.value_.Mutable(index);
}
inline void StringVec::set_value(int index, const std::string& value) {
  _impl_.value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v2.StringVec.value)
}
inline void StringVec::set_value(int index, std::string&& value) {
  _impl_.value_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v2.StringVec.value)
}
inline void StringVec::set_value(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:serial_v2.StringVec.value)
}
inline void StringVec::set_value(int index, const char* value, size_t size) {
  _impl_.value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:serial_v2.StringVec.value)
}
inline std::string* StringVec::_internal_add_value() {
  return _impl_.value_.Add();
}
inline void StringVec::add_value(const std::string& value) {
  _impl_.value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v2.StringVec.value)
}
inline void StringVec::add_value(std::string&& value) {
  _impl_.value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v2.StringVec.value)
}
inline void StringVec::add_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v2.StringVec.value)
}
inline void StringVec::add_value(const char* value, size_t size) {
  _impl_.value_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:serial_v2.StringVec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
StringVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.StringVec.value)
  return _impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
StringVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.StringVec.value)
  return &_impl_.value_;
}

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

// BytesVec

// repeated .serial_v2.Bytes value = 1;
inline int BytesVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int BytesVec::value_size() const {
  return _internal_value_size();
}
inline void BytesVec::clear_value() {
  _impl_.value_.Clear();
}
inline ::serial_v2::Bytes* BytesVec::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v2.BytesVec.value)
  return _impl_.value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::Bytes >*
BytesVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v2.BytesVec.value)
  return &_impl_.value_;
}
inline const ::serial_v2::Bytes& BytesVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline const ::serial_v2::Bytes& BytesVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v2.BytesVec.value)
  return _internal_value(index);
}
inline ::serial_v2::Bytes* BytesVec::_internal_add_value() {
  return _impl_.value_.Add();
}
inline ::serial_v2::Bytes* BytesVec::add_value() {
  ::serial_v2::Bytes* _add = _internal_add_value();
  // @@protoc_insertion_point(field_add:serial_v2.BytesVec.value)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v2::Bytes >&
BytesVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v2.BytesVec.value)
  return _impl_.value_;
}

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

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

// MapString2Int32

// map<string, int32> value = 1;
inline int MapString2Int32::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Int32::value_size() const {
  return _internal_value_size();
}
inline void MapString2Int32::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
MapString2Int32::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
MapString2Int32::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Int32.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
MapString2Int32::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
MapString2Int32::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Int32.value)
  return _internal_mutable_value();
}

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

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

// MapString2Uint32

// map<string, uint32> value = 1;
inline int MapString2Uint32::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Uint32::value_size() const {
  return _internal_value_size();
}
inline void MapString2Uint32::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >&
MapString2Uint32::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >&
MapString2Uint32::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Uint32.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >*
MapString2Uint32::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint32_t >*
MapString2Uint32::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Uint32.value)
  return _internal_mutable_value();
}

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

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

// MapString2Int64

// map<string, int64> value = 1;
inline int MapString2Int64::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Int64::value_size() const {
  return _internal_value_size();
}
inline void MapString2Int64::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
MapString2Int64::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
MapString2Int64::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Int64.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
MapString2Int64::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
MapString2Int64::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Int64.value)
  return _internal_mutable_value();
}

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

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

// MapString2Uint64

// map<string, uint64> value = 1;
inline int MapString2Uint64::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Uint64::value_size() const {
  return _internal_value_size();
}
inline void MapString2Uint64::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
MapString2Uint64::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
MapString2Uint64::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Uint64.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
MapString2Uint64::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
MapString2Uint64::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Uint64.value)
  return _internal_mutable_value();
}

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

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

// MapString2Bytes

// map<string, .serial_v2.Bytes> value = 1;
inline int MapString2Bytes::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Bytes::value_size() const {
  return _internal_value_size();
}
inline void MapString2Bytes::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >&
MapString2Bytes::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >&
MapString2Bytes::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Bytes.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >*
MapString2Bytes::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Bytes >*
MapString2Bytes::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Bytes.value)
  return _internal_mutable_value();
}

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

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

// MapString2String

// map<string, string> value = 1;
inline int MapString2String::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2String::value_size() const {
  return _internal_value_size();
}
inline void MapString2String::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
MapString2String::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
MapString2String::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2String.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
MapString2String::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
MapString2String::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2String.value)
  return _internal_mutable_value();
}

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

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

// MapString2Int32Vec

// map<string, .serial_v2.Int32Vec> value = 1;
inline int MapString2Int32Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Int32Vec::value_size() const {
  return _internal_value_size();
}
inline void MapString2Int32Vec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >&
MapString2Int32Vec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >&
MapString2Int32Vec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Int32Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >*
MapString2Int32Vec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int32Vec >*
MapString2Int32Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Int32Vec.value)
  return _internal_mutable_value();
}

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

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

// MapString2Uint32Vec

// map<string, .serial_v2.Uint32Vec> value = 1;
inline int MapString2Uint32Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Uint32Vec::value_size() const {
  return _internal_value_size();
}
inline void MapString2Uint32Vec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >&
MapString2Uint32Vec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >&
MapString2Uint32Vec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Uint32Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >*
MapString2Uint32Vec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint32Vec >*
MapString2Uint32Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Uint32Vec.value)
  return _internal_mutable_value();
}

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

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

// MapString2Int64Vec

// map<string, .serial_v2.Int64Vec> value = 1;
inline int MapString2Int64Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Int64Vec::value_size() const {
  return _internal_value_size();
}
inline void MapString2Int64Vec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >&
MapString2Int64Vec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >&
MapString2Int64Vec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Int64Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >*
MapString2Int64Vec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Int64Vec >*
MapString2Int64Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Int64Vec.value)
  return _internal_mutable_value();
}

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

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

// MapString2Uint64Vec

// map<string, .serial_v2.Uint64Vec> value = 1;
inline int MapString2Uint64Vec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2Uint64Vec::value_size() const {
  return _internal_value_size();
}
inline void MapString2Uint64Vec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >&
MapString2Uint64Vec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >&
MapString2Uint64Vec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2Uint64Vec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >*
MapString2Uint64Vec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::Uint64Vec >*
MapString2Uint64Vec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2Uint64Vec.value)
  return _internal_mutable_value();
}

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

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

// MapString2BytesVec

// map<string, .serial_v2.BytesVec> value = 1;
inline int MapString2BytesVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2BytesVec::value_size() const {
  return _internal_value_size();
}
inline void MapString2BytesVec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >&
MapString2BytesVec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >&
MapString2BytesVec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2BytesVec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >*
MapString2BytesVec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::BytesVec >*
MapString2BytesVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2BytesVec.value)
  return _internal_mutable_value();
}

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

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

// MapString2StringVec

// map<string, .serial_v2.StringVec> value = 1;
inline int MapString2StringVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int MapString2StringVec::value_size() const {
  return _internal_value_size();
}
inline void MapString2StringVec::clear_value() {
  _impl_.value_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >&
MapString2StringVec::_internal_value() const {
  return _impl_.value_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >&
MapString2StringVec::value() const {
  // @@protoc_insertion_point(field_map:serial_v2.MapString2StringVec.value)
  return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >*
MapString2StringVec::_internal_mutable_value() {
  return _impl_.value_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::serial_v2::StringVec >*
MapString2StringVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_map:serial_v2.MapString2StringVec.value)
  return _internal_mutable_value();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace serial_v2

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::serial_v2::AttrDef_OccurType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::serial_v2::AttrDef_OccurType>() {
  return ::serial_v2::AttrDef_OccurType_descriptor();
}
template <> struct is_proto_enum< ::serial_v2::OpArgDef_OccurType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::serial_v2::OpArgDef_OccurType>() {
  return ::serial_v2::OpArgDef_OccurType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv2_2eproto
