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

#ifndef GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv1_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv1_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/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_5fv1_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_5fv1_2eproto {
  static const uint32_t offsets[];
};
XIR_DLLESPEC extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_graph_5fproto_5fv1_2eproto;
namespace serial_v1 {
class AttrDef;
struct AttrDefDefaultTypeInternal;
XIR_DLLESPEC extern AttrDefDefaultTypeInternal _AttrDef_default_instance_;
class AttrValue;
struct AttrValueDefaultTypeInternal;
XIR_DLLESPEC extern AttrValueDefaultTypeInternal _AttrValue_default_instance_;
class AttrValue_ListValue;
struct AttrValue_ListValueDefaultTypeInternal;
XIR_DLLESPEC extern AttrValue_ListValueDefaultTypeInternal _AttrValue_ListValue_default_instance_;
class AttrValue_kv_map;
struct AttrValue_kv_mapDefaultTypeInternal;
XIR_DLLESPEC extern AttrValue_kv_mapDefaultTypeInternal _AttrValue_kv_map_default_instance_;
class AttrValue_kv_pair;
struct AttrValue_kv_pairDefaultTypeInternal;
XIR_DLLESPEC extern AttrValue_kv_pairDefaultTypeInternal _AttrValue_kv_pair_default_instance_;
class ExpandAttrValue;
struct ExpandAttrValueDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValueDefaultTypeInternal _ExpandAttrValue_default_instance_;
class ExpandAttrValue_BoolMap;
struct ExpandAttrValue_BoolMapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_BoolMapDefaultTypeInternal _ExpandAttrValue_BoolMap_default_instance_;
class ExpandAttrValue_BoolVec;
struct ExpandAttrValue_BoolVecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_BoolVecDefaultTypeInternal _ExpandAttrValue_BoolVec_default_instance_;
class ExpandAttrValue_BytesMap;
struct ExpandAttrValue_BytesMapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_BytesMapDefaultTypeInternal _ExpandAttrValue_BytesMap_default_instance_;
class ExpandAttrValue_BytesVec;
struct ExpandAttrValue_BytesVecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_BytesVecDefaultTypeInternal _ExpandAttrValue_BytesVec_default_instance_;
class ExpandAttrValue_FloatMap;
struct ExpandAttrValue_FloatMapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_FloatMapDefaultTypeInternal _ExpandAttrValue_FloatMap_default_instance_;
class ExpandAttrValue_FloatVec;
struct ExpandAttrValue_FloatVecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_FloatVecDefaultTypeInternal _ExpandAttrValue_FloatVec_default_instance_;
class ExpandAttrValue_Int32Map;
struct ExpandAttrValue_Int32MapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_Int32MapDefaultTypeInternal _ExpandAttrValue_Int32Map_default_instance_;
class ExpandAttrValue_Int32Vec;
struct ExpandAttrValue_Int32VecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_Int32VecDefaultTypeInternal _ExpandAttrValue_Int32Vec_default_instance_;
class ExpandAttrValue_Int64Map;
struct ExpandAttrValue_Int64MapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_Int64MapDefaultTypeInternal _ExpandAttrValue_Int64Map_default_instance_;
class ExpandAttrValue_Int64Vec;
struct ExpandAttrValue_Int64VecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_Int64VecDefaultTypeInternal _ExpandAttrValue_Int64Vec_default_instance_;
class ExpandAttrValue_KeyBoolPair;
struct ExpandAttrValue_KeyBoolPairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyBoolPairDefaultTypeInternal _ExpandAttrValue_KeyBoolPair_default_instance_;
class ExpandAttrValue_KeyBytesPair;
struct ExpandAttrValue_KeyBytesPairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyBytesPairDefaultTypeInternal _ExpandAttrValue_KeyBytesPair_default_instance_;
class ExpandAttrValue_KeyFloatPair;
struct ExpandAttrValue_KeyFloatPairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyFloatPairDefaultTypeInternal _ExpandAttrValue_KeyFloatPair_default_instance_;
class ExpandAttrValue_KeyInt32Pair;
struct ExpandAttrValue_KeyInt32PairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyInt32PairDefaultTypeInternal _ExpandAttrValue_KeyInt32Pair_default_instance_;
class ExpandAttrValue_KeyInt64Pair;
struct ExpandAttrValue_KeyInt64PairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyInt64PairDefaultTypeInternal _ExpandAttrValue_KeyInt64Pair_default_instance_;
class ExpandAttrValue_KeyStringPair;
struct ExpandAttrValue_KeyStringPairDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_KeyStringPairDefaultTypeInternal _ExpandAttrValue_KeyStringPair_default_instance_;
class ExpandAttrValue_StringMap;
struct ExpandAttrValue_StringMapDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_StringMapDefaultTypeInternal _ExpandAttrValue_StringMap_default_instance_;
class ExpandAttrValue_StringVec;
struct ExpandAttrValue_StringVecDefaultTypeInternal;
XIR_DLLESPEC extern ExpandAttrValue_StringVecDefaultTypeInternal _ExpandAttrValue_StringVec_default_instance_;
class Graph;
struct GraphDefaultTypeInternal;
XIR_DLLESPEC extern GraphDefaultTypeInternal _Graph_default_instance_;
class OPNode;
struct OPNodeDefaultTypeInternal;
XIR_DLLESPEC extern OPNodeDefaultTypeInternal _OPNode_default_instance_;
class OneKindOP;
struct OneKindOPDefaultTypeInternal;
XIR_DLLESPEC extern OneKindOPDefaultTypeInternal _OneKindOP_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 SubGraph;
struct SubGraphDefaultTypeInternal;
XIR_DLLESPEC extern SubGraphDefaultTypeInternal _SubGraph_default_instance_;
class Tensor;
struct TensorDefaultTypeInternal;
XIR_DLLESPEC extern TensorDefaultTypeInternal _Tensor_default_instance_;
}  // namespace serial_v1
PROTOBUF_NAMESPACE_OPEN
template<> XIR_DLLESPEC ::serial_v1::AttrDef* Arena::CreateMaybeMessage<::serial_v1::AttrDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::AttrValue* Arena::CreateMaybeMessage<::serial_v1::AttrValue>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::AttrValue_ListValue* Arena::CreateMaybeMessage<::serial_v1::AttrValue_ListValue>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::AttrValue_kv_map* Arena::CreateMaybeMessage<::serial_v1::AttrValue_kv_map>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::AttrValue_kv_pair* Arena::CreateMaybeMessage<::serial_v1::AttrValue_kv_pair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_BoolMap* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_BoolMap>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_BoolVec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_BoolVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_BytesMap* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_BytesMap>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_BytesVec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_BytesVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_FloatMap* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_FloatMap>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_FloatVec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_FloatVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_Int32Map* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_Int32Map>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_Int32Vec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_Int32Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_Int64Map* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_Int64Map>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_Int64Vec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_Int64Vec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyBoolPair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyBoolPair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyBytesPair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyBytesPair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyFloatPair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyFloatPair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyInt32Pair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyInt32Pair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyInt64Pair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyInt64Pair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_KeyStringPair* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_KeyStringPair>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_StringMap* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_StringMap>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::ExpandAttrValue_StringVec* Arena::CreateMaybeMessage<::serial_v1::ExpandAttrValue_StringVec>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::Graph* Arena::CreateMaybeMessage<::serial_v1::Graph>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::OPNode* Arena::CreateMaybeMessage<::serial_v1::OPNode>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::OneKindOP* Arena::CreateMaybeMessage<::serial_v1::OneKindOP>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::OpArgDef* Arena::CreateMaybeMessage<::serial_v1::OpArgDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::OpDef* Arena::CreateMaybeMessage<::serial_v1::OpDef>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::SubGraph* Arena::CreateMaybeMessage<::serial_v1::SubGraph>(Arena*);
template<> XIR_DLLESPEC ::serial_v1::Tensor* Arena::CreateMaybeMessage<::serial_v1::Tensor>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace serial_v1 {

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);
}
enum OpArgDef_DataType : int {
  OpArgDef_DataType_ALL = 0,
  OpArgDef_DataType_FLOAT = 1,
  OpArgDef_DataType_INT = 2,
  OpArgDef_DataType_XINT = 3,
  OpArgDef_DataType_OpArgDef_DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  OpArgDef_DataType_OpArgDef_DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
XIR_DLLESPEC bool OpArgDef_DataType_IsValid(int value);
constexpr OpArgDef_DataType OpArgDef_DataType_DataType_MIN = OpArgDef_DataType_ALL;
constexpr OpArgDef_DataType OpArgDef_DataType_DataType_MAX = OpArgDef_DataType_XINT;
constexpr int OpArgDef_DataType_DataType_ARRAYSIZE = OpArgDef_DataType_DataType_MAX + 1;

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

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

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

  inline AttrValue_ListValue& operator=(const AttrValue_ListValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttrValue_ListValue& operator=(AttrValue_ListValue&& 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_ListValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const AttrValue_ListValue* internal_default_instance() {
    return reinterpret_cast<const AttrValue_ListValue*>(
               &_AttrValue_ListValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(AttrValue_ListValue& a, AttrValue_ListValue& b) {
    a.Swap(&b);
  }
  inline void Swap(AttrValue_ListValue* 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_ListValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AttrValue_ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttrValue_ListValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AttrValue_ListValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AttrValue_ListValue& from) {
    AttrValue_ListValue::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_ListValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.AttrValue.ListValue";
  }
  protected:
  explicit AttrValue_ListValue(::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 = 1,
    kInt64ValueFieldNumber = 3,
    kFloatValueFieldNumber = 4,
    kStringValueFieldNumber = 5,
    kBytesValueFieldNumber = 6,
  };
  // repeated bool bool_value = 1;
  int bool_value_size() const;
  private:
  int _internal_bool_value_size() const;
  public:
  void clear_bool_value();
  private:
  bool _internal_bool_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_bool_value() const;
  void _internal_add_bool_value(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_bool_value();
  public:
  bool bool_value(int index) const;
  void set_bool_value(int index, bool value);
  void add_bool_value(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      bool_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_bool_value();

  // repeated sint64 int64_value = 3;
  int int64_value_size() const;
  private:
  int _internal_int64_value_size() const;
  public:
  void clear_int64_value();
  private:
  int64_t _internal_int64_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_int64_value() const;
  void _internal_add_int64_value(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_int64_value();
  public:
  int64_t int64_value(int index) const;
  void set_int64_value(int index, int64_t value);
  void add_int64_value(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      int64_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_int64_value();

  // repeated float float_value = 4;
  int float_value_size() const;
  private:
  int _internal_float_value_size() const;
  public:
  void clear_float_value();
  private:
  float _internal_float_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_float_value() const;
  void _internal_add_float_value(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_float_value();
  public:
  float float_value(int index) const;
  void set_float_value(int index, float value);
  void add_float_value(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      float_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_float_value();

  // repeated string string_value = 5;
  int string_value_size() const;
  private:
  int _internal_string_value_size() const;
  public:
  void clear_string_value();
  const std::string& string_value(int index) const;
  std::string* mutable_string_value(int index);
  void set_string_value(int index, const std::string& value);
  void set_string_value(int index, std::string&& value);
  void set_string_value(int index, const char* value);
  void set_string_value(int index, const char* value, size_t size);
  std::string* add_string_value();
  void add_string_value(const std::string& value);
  void add_string_value(std::string&& value);
  void add_string_value(const char* value);
  void add_string_value(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_value();
  private:
  const std::string& _internal_string_value(int index) const;
  std::string* _internal_add_string_value();
  public:

  // repeated bytes bytes_value = 6;
  int bytes_value_size() const;
  private:
  int _internal_bytes_value_size() const;
  public:
  void clear_bytes_value();
  const std::string& bytes_value(int index) const;
  std::string* mutable_bytes_value(int index);
  void set_bytes_value(int index, const std::string& value);
  void set_bytes_value(int index, std::string&& value);
  void set_bytes_value(int index, const char* value);
  void set_bytes_value(int index, const void* value, size_t size);
  std::string* add_bytes_value();
  void add_bytes_value(const std::string& value);
  void add_bytes_value(std::string&& value);
  void add_bytes_value(const char* value);
  void add_bytes_value(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bytes_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bytes_value();
  private:
  const std::string& _internal_bytes_value(int index) const;
  std::string* _internal_add_bytes_value();
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.AttrValue.ListValue)
 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 > bool_value_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > int64_value_;
    mutable std::atomic<int> _int64_value_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_value_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_value_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bytes_value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline AttrValue_kv_pair& operator=(const AttrValue_kv_pair& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttrValue_kv_pair& operator=(AttrValue_kv_pair&& 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_kv_pair& default_instance() {
    return *internal_default_instance();
  }
  static inline const AttrValue_kv_pair* internal_default_instance() {
    return reinterpret_cast<const AttrValue_kv_pair*>(
               &_AttrValue_kv_pair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(AttrValue_kv_pair& a, AttrValue_kv_pair& b) {
    a.Swap(&b);
  }
  inline void Swap(AttrValue_kv_pair* 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_kv_pair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AttrValue_kv_pair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttrValue_kv_pair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AttrValue_kv_pair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AttrValue_kv_pair& from) {
    AttrValue_kv_pair::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_kv_pair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.AttrValue.kv_pair";
  }
  protected:
  explicit AttrValue_kv_pair(::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 {
    kKeyFieldNumber = 1,
    kStringValueFieldNumber = 6,
    kBytesValueFieldNumber = 7,
    kBoolValueFieldNumber = 2,
    kFloatValueFieldNumber = 5,
    kInt64ValueFieldNumber = 4,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // string string_value = 6;
  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:

  // bytes bytes_value = 7;
  void clear_bytes_value();
  const std::string& bytes_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bytes_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bytes_value();
  PROTOBUF_NODISCARD std::string* release_bytes_value();
  void set_allocated_bytes_value(std::string* bytes_value);
  private:
  const std::string& _internal_bytes_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytes_value(const std::string& value);
  std::string* _internal_mutable_bytes_value();
  public:

  // bool bool_value = 2;
  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:

  // float float_value = 5;
  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:

  // sint64 int64_value = 4;
  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:

  // @@protoc_insertion_point(class_scope:serial_v1.AttrValue.kv_pair)
 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 key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
    bool bool_value_;
    float float_value_;
    int64_t int64_value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline AttrValue_kv_map& operator=(const AttrValue_kv_map& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttrValue_kv_map& operator=(AttrValue_kv_map&& 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_kv_map& default_instance() {
    return *internal_default_instance();
  }
  static inline const AttrValue_kv_map* internal_default_instance() {
    return reinterpret_cast<const AttrValue_kv_map*>(
               &_AttrValue_kv_map_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(AttrValue_kv_map& a, AttrValue_kv_map& b) {
    a.Swap(&b);
  }
  inline void Swap(AttrValue_kv_map* 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_kv_map* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AttrValue_kv_map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttrValue_kv_map>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AttrValue_kv_map& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AttrValue_kv_map& from) {
    AttrValue_kv_map::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_kv_map* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.AttrValue.kv_map";
  }
  protected:
  explicit AttrValue_kv_map(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.AttrValue.kv_pair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::AttrValue_kv_pair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue_kv_pair >*
      mutable_pairs();
  private:
  const ::serial_v1::AttrValue_kv_pair& _internal_pairs(int index) const;
  ::serial_v1::AttrValue_kv_pair* _internal_add_pairs();
  public:
  const ::serial_v1::AttrValue_kv_pair& pairs(int index) const;
  ::serial_v1::AttrValue_kv_pair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue_kv_pair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.AttrValue.kv_map)
 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_v1::AttrValue_kv_pair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC AttrValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 AttrValueCase {
    kBoolValue = 2,
    kInt64Value = 4,
    kFloatValue = 5,
    kStringValue = 6,
    kBytesValue = 7,
    kListValue = 8,
    kKv = 10,
    ATTR_VALUE_NOT_SET = 0,
  };

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

  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_v1.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 ----------------------------------------------------

  typedef AttrValue_ListValue ListValue;
  typedef AttrValue_kv_pair kv_pair;
  typedef AttrValue_kv_map kv_map;

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

  enum : int {
    kAttrNameFieldNumber = 1,
    kBoolValueFieldNumber = 2,
    kInt64ValueFieldNumber = 4,
    kFloatValueFieldNumber = 5,
    kStringValueFieldNumber = 6,
    kBytesValueFieldNumber = 7,
    kListValueFieldNumber = 8,
    kKvFieldNumber = 10,
  };
  // string attr_name = 1;
  void clear_attr_name();
  const std::string& attr_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attr_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attr_name();
  PROTOBUF_NODISCARD std::string* release_attr_name();
  void set_allocated_attr_name(std::string* attr_name);
  private:
  const std::string& _internal_attr_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attr_name(const std::string& value);
  std::string* _internal_mutable_attr_name();
  public:

  // bool bool_value = 2;
  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:

  // sint64 int64_value = 4;
  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:

  // float float_value = 5;
  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:

  // string string_value = 6;
  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:

  // bytes bytes_value = 7;
  bool has_bytes_value() const;
  private:
  bool _internal_has_bytes_value() const;
  public:
  void clear_bytes_value();
  const std::string& bytes_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bytes_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bytes_value();
  PROTOBUF_NODISCARD std::string* release_bytes_value();
  void set_allocated_bytes_value(std::string* bytes_value);
  private:
  const std::string& _internal_bytes_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytes_value(const std::string& value);
  std::string* _internal_mutable_bytes_value();
  public:

  // .serial_v1.AttrValue.ListValue list_value = 8;
  bool has_list_value() const;
  private:
  bool _internal_has_list_value() const;
  public:
  void clear_list_value();
  const ::serial_v1::AttrValue_ListValue& list_value() const;
  PROTOBUF_NODISCARD ::serial_v1::AttrValue_ListValue* release_list_value();
  ::serial_v1::AttrValue_ListValue* mutable_list_value();
  void set_allocated_list_value(::serial_v1::AttrValue_ListValue* list_value);
  private:
  const ::serial_v1::AttrValue_ListValue& _internal_list_value() const;
  ::serial_v1::AttrValue_ListValue* _internal_mutable_list_value();
  public:
  void unsafe_arena_set_allocated_list_value(
      ::serial_v1::AttrValue_ListValue* list_value);
  ::serial_v1::AttrValue_ListValue* unsafe_arena_release_list_value();

  // .serial_v1.AttrValue.kv_map kv = 10;
  bool has_kv() const;
  private:
  bool _internal_has_kv() const;
  public:
  void clear_kv();
  const ::serial_v1::AttrValue_kv_map& kv() const;
  PROTOBUF_NODISCARD ::serial_v1::AttrValue_kv_map* release_kv();
  ::serial_v1::AttrValue_kv_map* mutable_kv();
  void set_allocated_kv(::serial_v1::AttrValue_kv_map* kv);
  private:
  const ::serial_v1::AttrValue_kv_map& _internal_kv() const;
  ::serial_v1::AttrValue_kv_map* _internal_mutable_kv();
  public:
  void unsafe_arena_set_allocated_kv(
      ::serial_v1::AttrValue_kv_map* kv);
  ::serial_v1::AttrValue_kv_map* unsafe_arena_release_kv();

  void clear_attr_value();
  AttrValueCase attr_value_case() const;
  // @@protoc_insertion_point(class_scope:serial_v1.AttrValue)
 private:
  class _Internal;
  void set_has_bool_value();
  void set_has_int64_value();
  void set_has_float_value();
  void set_has_string_value();
  void set_has_bytes_value();
  void set_has_list_value();
  void set_has_kv();

  inline bool has_attr_value() const;
  inline void clear_has_attr_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attr_name_;
    union AttrValueUnion {
      constexpr AttrValueUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      bool bool_value_;
      int64_t int64_value_;
      float float_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
      ::serial_v1::AttrValue_ListValue* list_value_;
      ::serial_v1::AttrValue_kv_map* kv_;
    } attr_value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

  inline ExpandAttrValue_BoolVec& operator=(const ExpandAttrValue_BoolVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_BoolVec& operator=(ExpandAttrValue_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 ExpandAttrValue_BoolVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_BoolVec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_BoolVec*>(
               &_ExpandAttrValue_BoolVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ExpandAttrValue_BoolVec& a, ExpandAttrValue_BoolVec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_BoolVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_BoolVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_BoolVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_BoolVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_BoolVec& from) {
    ExpandAttrValue_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(ExpandAttrValue_BoolVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.BoolVec";
  }
  protected:
  explicit ExpandAttrValue_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_v1.ExpandAttrValue.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_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_Int32Vec& operator=(const ExpandAttrValue_Int32Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_Int32Vec& operator=(ExpandAttrValue_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 ExpandAttrValue_Int32Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_Int32Vec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_Int32Vec*>(
               &_ExpandAttrValue_Int32Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(ExpandAttrValue_Int32Vec& a, ExpandAttrValue_Int32Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_Int32Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_Int32Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_Int32Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_Int32Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_Int32Vec& from) {
    ExpandAttrValue_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(ExpandAttrValue_Int32Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.Int32Vec";
  }
  protected:
  explicit ExpandAttrValue_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 sint32 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_v1.ExpandAttrValue.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_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_Int64Vec& operator=(const ExpandAttrValue_Int64Vec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_Int64Vec& operator=(ExpandAttrValue_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 ExpandAttrValue_Int64Vec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_Int64Vec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_Int64Vec*>(
               &_ExpandAttrValue_Int64Vec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(ExpandAttrValue_Int64Vec& a, ExpandAttrValue_Int64Vec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_Int64Vec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_Int64Vec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_Int64Vec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_Int64Vec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_Int64Vec& from) {
    ExpandAttrValue_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(ExpandAttrValue_Int64Vec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.Int64Vec";
  }
  protected:
  explicit ExpandAttrValue_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 sint64 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_v1.ExpandAttrValue.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_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_FloatVec& operator=(const ExpandAttrValue_FloatVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_FloatVec& operator=(ExpandAttrValue_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 ExpandAttrValue_FloatVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_FloatVec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_FloatVec*>(
               &_ExpandAttrValue_FloatVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ExpandAttrValue_FloatVec& a, ExpandAttrValue_FloatVec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_FloatVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_FloatVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_FloatVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_FloatVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_FloatVec& from) {
    ExpandAttrValue_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(ExpandAttrValue_FloatVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.FloatVec";
  }
  protected:
  explicit ExpandAttrValue_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_v1.ExpandAttrValue.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_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_StringVec& operator=(const ExpandAttrValue_StringVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_StringVec& operator=(ExpandAttrValue_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 ExpandAttrValue_StringVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_StringVec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_StringVec*>(
               &_ExpandAttrValue_StringVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(ExpandAttrValue_StringVec& a, ExpandAttrValue_StringVec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_StringVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_StringVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_StringVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_StringVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_StringVec& from) {
    ExpandAttrValue_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(ExpandAttrValue_StringVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.StringVec";
  }
  protected:
  explicit ExpandAttrValue_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_v1.ExpandAttrValue.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_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_BytesVec& operator=(const ExpandAttrValue_BytesVec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_BytesVec& operator=(ExpandAttrValue_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 ExpandAttrValue_BytesVec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_BytesVec* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_BytesVec*>(
               &_ExpandAttrValue_BytesVec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(ExpandAttrValue_BytesVec& a, ExpandAttrValue_BytesVec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_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(ExpandAttrValue_BytesVec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_BytesVec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_BytesVec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_BytesVec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_BytesVec& from) {
    ExpandAttrValue_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(ExpandAttrValue_BytesVec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.BytesVec";
  }
  protected:
  explicit ExpandAttrValue_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 bytes 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 void* 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 void* 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_v1.ExpandAttrValue.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<std::string> value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyBoolPair& operator=(const ExpandAttrValue_KeyBoolPair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyBoolPair& operator=(ExpandAttrValue_KeyBoolPair&& 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 ExpandAttrValue_KeyBoolPair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyBoolPair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyBoolPair*>(
               &_ExpandAttrValue_KeyBoolPair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(ExpandAttrValue_KeyBoolPair& a, ExpandAttrValue_KeyBoolPair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyBoolPair* 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(ExpandAttrValue_KeyBoolPair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyBoolPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyBoolPair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyBoolPair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyBoolPair& from) {
    ExpandAttrValue_KeyBoolPair::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(ExpandAttrValue_KeyBoolPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyBoolPair";
  }
  protected:
  explicit ExpandAttrValue_KeyBoolPair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // bool value = 2;
  void clear_value();
  bool value() const;
  void set_value(bool value);
  private:
  bool _internal_value() const;
  void _internal_set_value(bool value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.KeyBoolPair)
 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 key_;
    bool value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_BoolMap& operator=(const ExpandAttrValue_BoolMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_BoolMap& operator=(ExpandAttrValue_BoolMap&& 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 ExpandAttrValue_BoolMap& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_BoolMap* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_BoolMap*>(
               &_ExpandAttrValue_BoolMap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(ExpandAttrValue_BoolMap& a, ExpandAttrValue_BoolMap& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_BoolMap* 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(ExpandAttrValue_BoolMap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_BoolMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_BoolMap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_BoolMap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_BoolMap& from) {
    ExpandAttrValue_BoolMap::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(ExpandAttrValue_BoolMap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.BoolMap";
  }
  protected:
  explicit ExpandAttrValue_BoolMap(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyBoolPair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyBoolPair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBoolPair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyBoolPair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyBoolPair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyBoolPair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyBoolPair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBoolPair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.BoolMap)
 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_v1::ExpandAttrValue_KeyBoolPair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyInt32Pair& operator=(const ExpandAttrValue_KeyInt32Pair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyInt32Pair& operator=(ExpandAttrValue_KeyInt32Pair&& 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 ExpandAttrValue_KeyInt32Pair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyInt32Pair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyInt32Pair*>(
               &_ExpandAttrValue_KeyInt32Pair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(ExpandAttrValue_KeyInt32Pair& a, ExpandAttrValue_KeyInt32Pair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyInt32Pair* 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(ExpandAttrValue_KeyInt32Pair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyInt32Pair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyInt32Pair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyInt32Pair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyInt32Pair& from) {
    ExpandAttrValue_KeyInt32Pair::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(ExpandAttrValue_KeyInt32Pair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyInt32Pair";
  }
  protected:
  explicit ExpandAttrValue_KeyInt32Pair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // sint32 value = 2;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.KeyInt32Pair)
 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 key_;
    int32_t value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_Int32Map& operator=(const ExpandAttrValue_Int32Map& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_Int32Map& operator=(ExpandAttrValue_Int32Map&& 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 ExpandAttrValue_Int32Map& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_Int32Map* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_Int32Map*>(
               &_ExpandAttrValue_Int32Map_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(ExpandAttrValue_Int32Map& a, ExpandAttrValue_Int32Map& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_Int32Map* 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(ExpandAttrValue_Int32Map* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_Int32Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_Int32Map>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_Int32Map& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_Int32Map& from) {
    ExpandAttrValue_Int32Map::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(ExpandAttrValue_Int32Map* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.Int32Map";
  }
  protected:
  explicit ExpandAttrValue_Int32Map(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyInt32Pair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyInt32Pair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt32Pair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyInt32Pair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyInt32Pair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyInt32Pair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyInt32Pair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt32Pair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.Int32Map)
 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_v1::ExpandAttrValue_KeyInt32Pair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyInt64Pair& operator=(const ExpandAttrValue_KeyInt64Pair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyInt64Pair& operator=(ExpandAttrValue_KeyInt64Pair&& 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 ExpandAttrValue_KeyInt64Pair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyInt64Pair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyInt64Pair*>(
               &_ExpandAttrValue_KeyInt64Pair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(ExpandAttrValue_KeyInt64Pair& a, ExpandAttrValue_KeyInt64Pair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyInt64Pair* 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(ExpandAttrValue_KeyInt64Pair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyInt64Pair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyInt64Pair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyInt64Pair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyInt64Pair& from) {
    ExpandAttrValue_KeyInt64Pair::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(ExpandAttrValue_KeyInt64Pair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyInt64Pair";
  }
  protected:
  explicit ExpandAttrValue_KeyInt64Pair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // sint64 value = 2;
  void clear_value();
  int64_t value() const;
  void set_value(int64_t value);
  private:
  int64_t _internal_value() const;
  void _internal_set_value(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.KeyInt64Pair)
 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 key_;
    int64_t value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_Int64Map& operator=(const ExpandAttrValue_Int64Map& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_Int64Map& operator=(ExpandAttrValue_Int64Map&& 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 ExpandAttrValue_Int64Map& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_Int64Map* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_Int64Map*>(
               &_ExpandAttrValue_Int64Map_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(ExpandAttrValue_Int64Map& a, ExpandAttrValue_Int64Map& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_Int64Map* 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(ExpandAttrValue_Int64Map* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_Int64Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_Int64Map>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_Int64Map& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_Int64Map& from) {
    ExpandAttrValue_Int64Map::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(ExpandAttrValue_Int64Map* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.Int64Map";
  }
  protected:
  explicit ExpandAttrValue_Int64Map(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyInt64Pair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyInt64Pair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt64Pair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyInt64Pair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyInt64Pair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyInt64Pair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyInt64Pair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt64Pair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.Int64Map)
 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_v1::ExpandAttrValue_KeyInt64Pair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyFloatPair& operator=(const ExpandAttrValue_KeyFloatPair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyFloatPair& operator=(ExpandAttrValue_KeyFloatPair&& 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 ExpandAttrValue_KeyFloatPair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyFloatPair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyFloatPair*>(
               &_ExpandAttrValue_KeyFloatPair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(ExpandAttrValue_KeyFloatPair& a, ExpandAttrValue_KeyFloatPair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyFloatPair* 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(ExpandAttrValue_KeyFloatPair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyFloatPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyFloatPair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyFloatPair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyFloatPair& from) {
    ExpandAttrValue_KeyFloatPair::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(ExpandAttrValue_KeyFloatPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyFloatPair";
  }
  protected:
  explicit ExpandAttrValue_KeyFloatPair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // float value = 2;
  void clear_value();
  float value() const;
  void set_value(float value);
  private:
  float _internal_value() const;
  void _internal_set_value(float value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.KeyFloatPair)
 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 key_;
    float value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_FloatMap& operator=(const ExpandAttrValue_FloatMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_FloatMap& operator=(ExpandAttrValue_FloatMap&& 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 ExpandAttrValue_FloatMap& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_FloatMap* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_FloatMap*>(
               &_ExpandAttrValue_FloatMap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(ExpandAttrValue_FloatMap& a, ExpandAttrValue_FloatMap& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_FloatMap* 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(ExpandAttrValue_FloatMap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_FloatMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_FloatMap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_FloatMap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_FloatMap& from) {
    ExpandAttrValue_FloatMap::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(ExpandAttrValue_FloatMap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.FloatMap";
  }
  protected:
  explicit ExpandAttrValue_FloatMap(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyFloatPair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyFloatPair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyFloatPair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyFloatPair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyFloatPair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyFloatPair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyFloatPair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyFloatPair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.FloatMap)
 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_v1::ExpandAttrValue_KeyFloatPair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyStringPair& operator=(const ExpandAttrValue_KeyStringPair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyStringPair& operator=(ExpandAttrValue_KeyStringPair&& 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 ExpandAttrValue_KeyStringPair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyStringPair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyStringPair*>(
               &_ExpandAttrValue_KeyStringPair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(ExpandAttrValue_KeyStringPair& a, ExpandAttrValue_KeyStringPair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyStringPair* 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(ExpandAttrValue_KeyStringPair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyStringPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyStringPair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyStringPair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyStringPair& from) {
    ExpandAttrValue_KeyStringPair::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(ExpandAttrValue_KeyStringPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyStringPair";
  }
  protected:
  explicit ExpandAttrValue_KeyStringPair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // string value = 2;
  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_v1.ExpandAttrValue.KeyStringPair)
 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 key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_StringMap& operator=(const ExpandAttrValue_StringMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_StringMap& operator=(ExpandAttrValue_StringMap&& 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 ExpandAttrValue_StringMap& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_StringMap* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_StringMap*>(
               &_ExpandAttrValue_StringMap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(ExpandAttrValue_StringMap& a, ExpandAttrValue_StringMap& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_StringMap* 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(ExpandAttrValue_StringMap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_StringMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_StringMap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_StringMap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_StringMap& from) {
    ExpandAttrValue_StringMap::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(ExpandAttrValue_StringMap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.StringMap";
  }
  protected:
  explicit ExpandAttrValue_StringMap(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyStringPair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyStringPair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyStringPair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyStringPair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyStringPair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyStringPair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyStringPair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyStringPair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.StringMap)
 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_v1::ExpandAttrValue_KeyStringPair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_KeyBytesPair& operator=(const ExpandAttrValue_KeyBytesPair& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_KeyBytesPair& operator=(ExpandAttrValue_KeyBytesPair&& 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 ExpandAttrValue_KeyBytesPair& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_KeyBytesPair* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_KeyBytesPair*>(
               &_ExpandAttrValue_KeyBytesPair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(ExpandAttrValue_KeyBytesPair& a, ExpandAttrValue_KeyBytesPair& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_KeyBytesPair* 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(ExpandAttrValue_KeyBytesPair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_KeyBytesPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_KeyBytesPair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_KeyBytesPair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_KeyBytesPair& from) {
    ExpandAttrValue_KeyBytesPair::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(ExpandAttrValue_KeyBytesPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.KeyBytesPair";
  }
  protected:
  explicit ExpandAttrValue_KeyBytesPair(::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 {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // bytes value = 2;
  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_v1.ExpandAttrValue.KeyBytesPair)
 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 key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue_BytesMap& operator=(const ExpandAttrValue_BytesMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue_BytesMap& operator=(ExpandAttrValue_BytesMap&& 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 ExpandAttrValue_BytesMap& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpandAttrValue_BytesMap* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue_BytesMap*>(
               &_ExpandAttrValue_BytesMap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(ExpandAttrValue_BytesMap& a, ExpandAttrValue_BytesMap& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue_BytesMap* 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(ExpandAttrValue_BytesMap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue_BytesMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue_BytesMap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue_BytesMap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue_BytesMap& from) {
    ExpandAttrValue_BytesMap::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(ExpandAttrValue_BytesMap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue.BytesMap";
  }
  protected:
  explicit ExpandAttrValue_BytesMap(::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 {
    kPairsFieldNumber = 1,
  };
  // repeated .serial_v1.ExpandAttrValue.KeyBytesPair pairs = 1;
  int pairs_size() const;
  private:
  int _internal_pairs_size() const;
  public:
  void clear_pairs();
  ::serial_v1::ExpandAttrValue_KeyBytesPair* mutable_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBytesPair >*
      mutable_pairs();
  private:
  const ::serial_v1::ExpandAttrValue_KeyBytesPair& _internal_pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyBytesPair* _internal_add_pairs();
  public:
  const ::serial_v1::ExpandAttrValue_KeyBytesPair& pairs(int index) const;
  ::serial_v1::ExpandAttrValue_KeyBytesPair* add_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBytesPair >&
      pairs() const;

  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue.BytesMap)
 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_v1::ExpandAttrValue_KeyBytesPair > pairs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExpandAttrValue& operator=(const ExpandAttrValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpandAttrValue& operator=(ExpandAttrValue&& 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 ExpandAttrValue& default_instance() {
    return *internal_default_instance();
  }
  enum AttrValueCase {
    kBoolValue = 1,
    kInt32Value = 2,
    kInt64Value = 3,
    kFloatValue = 4,
    kStringValue = 5,
    kBytesValue = 6,
    kBoolVec = 11,
    kInt32Vec = 12,
    kInt64Vec = 13,
    kFloatVec = 14,
    kStringVec = 15,
    kBoolMap = 21,
    kInt32Map = 22,
    kInt64Map = 23,
    kFloatMap = 24,
    kStringMap = 25,
    kBytesMap = 26,
    ATTR_VALUE_NOT_SET = 0,
  };

  static inline const ExpandAttrValue* internal_default_instance() {
    return reinterpret_cast<const ExpandAttrValue*>(
               &_ExpandAttrValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(ExpandAttrValue& a, ExpandAttrValue& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpandAttrValue* 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(ExpandAttrValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpandAttrValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpandAttrValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpandAttrValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpandAttrValue& from) {
    ExpandAttrValue::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(ExpandAttrValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.ExpandAttrValue";
  }
  protected:
  explicit ExpandAttrValue(::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 ExpandAttrValue_BoolVec BoolVec;
  typedef ExpandAttrValue_Int32Vec Int32Vec;
  typedef ExpandAttrValue_Int64Vec Int64Vec;
  typedef ExpandAttrValue_FloatVec FloatVec;
  typedef ExpandAttrValue_StringVec StringVec;
  typedef ExpandAttrValue_BytesVec BytesVec;
  typedef ExpandAttrValue_KeyBoolPair KeyBoolPair;
  typedef ExpandAttrValue_BoolMap BoolMap;
  typedef ExpandAttrValue_KeyInt32Pair KeyInt32Pair;
  typedef ExpandAttrValue_Int32Map Int32Map;
  typedef ExpandAttrValue_KeyInt64Pair KeyInt64Pair;
  typedef ExpandAttrValue_Int64Map Int64Map;
  typedef ExpandAttrValue_KeyFloatPair KeyFloatPair;
  typedef ExpandAttrValue_FloatMap FloatMap;
  typedef ExpandAttrValue_KeyStringPair KeyStringPair;
  typedef ExpandAttrValue_StringMap StringMap;
  typedef ExpandAttrValue_KeyBytesPair KeyBytesPair;
  typedef ExpandAttrValue_BytesMap BytesMap;

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

  enum : int {
    kAttrNameFieldNumber = 100,
    kBoolValueFieldNumber = 1,
    kInt32ValueFieldNumber = 2,
    kInt64ValueFieldNumber = 3,
    kFloatValueFieldNumber = 4,
    kStringValueFieldNumber = 5,
    kBytesValueFieldNumber = 6,
    kBoolVecFieldNumber = 11,
    kInt32VecFieldNumber = 12,
    kInt64VecFieldNumber = 13,
    kFloatVecFieldNumber = 14,
    kStringVecFieldNumber = 15,
    kBoolMapFieldNumber = 21,
    kInt32MapFieldNumber = 22,
    kInt64MapFieldNumber = 23,
    kFloatMapFieldNumber = 24,
    kStringMapFieldNumber = 25,
    kBytesMapFieldNumber = 26,
  };
  // string attr_name = 100;
  void clear_attr_name();
  const std::string& attr_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attr_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attr_name();
  PROTOBUF_NODISCARD std::string* release_attr_name();
  void set_allocated_attr_name(std::string* attr_name);
  private:
  const std::string& _internal_attr_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attr_name(const std::string& value);
  std::string* _internal_mutable_attr_name();
  public:

  // bool bool_value = 1;
  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:

  // sint32 int32_value = 2;
  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:

  // sint64 int64_value = 3;
  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:

  // float float_value = 4;
  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:

  // string string_value = 5;
  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:

  // bytes bytes_value = 6;
  bool has_bytes_value() const;
  private:
  bool _internal_has_bytes_value() const;
  public:
  void clear_bytes_value();
  const std::string& bytes_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bytes_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bytes_value();
  PROTOBUF_NODISCARD std::string* release_bytes_value();
  void set_allocated_bytes_value(std::string* bytes_value);
  private:
  const std::string& _internal_bytes_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytes_value(const std::string& value);
  std::string* _internal_mutable_bytes_value();
  public:

  // .serial_v1.ExpandAttrValue.BoolVec bool_vec = 11;
  bool has_bool_vec() const;
  private:
  bool _internal_has_bool_vec() const;
  public:
  void clear_bool_vec();
  const ::serial_v1::ExpandAttrValue_BoolVec& bool_vec() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_BoolVec* release_bool_vec();
  ::serial_v1::ExpandAttrValue_BoolVec* mutable_bool_vec();
  void set_allocated_bool_vec(::serial_v1::ExpandAttrValue_BoolVec* bool_vec);
  private:
  const ::serial_v1::ExpandAttrValue_BoolVec& _internal_bool_vec() const;
  ::serial_v1::ExpandAttrValue_BoolVec* _internal_mutable_bool_vec();
  public:
  void unsafe_arena_set_allocated_bool_vec(
      ::serial_v1::ExpandAttrValue_BoolVec* bool_vec);
  ::serial_v1::ExpandAttrValue_BoolVec* unsafe_arena_release_bool_vec();

  // .serial_v1.ExpandAttrValue.Int32Vec int32_vec = 12;
  bool has_int32_vec() const;
  private:
  bool _internal_has_int32_vec() const;
  public:
  void clear_int32_vec();
  const ::serial_v1::ExpandAttrValue_Int32Vec& int32_vec() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_Int32Vec* release_int32_vec();
  ::serial_v1::ExpandAttrValue_Int32Vec* mutable_int32_vec();
  void set_allocated_int32_vec(::serial_v1::ExpandAttrValue_Int32Vec* int32_vec);
  private:
  const ::serial_v1::ExpandAttrValue_Int32Vec& _internal_int32_vec() const;
  ::serial_v1::ExpandAttrValue_Int32Vec* _internal_mutable_int32_vec();
  public:
  void unsafe_arena_set_allocated_int32_vec(
      ::serial_v1::ExpandAttrValue_Int32Vec* int32_vec);
  ::serial_v1::ExpandAttrValue_Int32Vec* unsafe_arena_release_int32_vec();

  // .serial_v1.ExpandAttrValue.Int64Vec int64_vec = 13;
  bool has_int64_vec() const;
  private:
  bool _internal_has_int64_vec() const;
  public:
  void clear_int64_vec();
  const ::serial_v1::ExpandAttrValue_Int64Vec& int64_vec() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_Int64Vec* release_int64_vec();
  ::serial_v1::ExpandAttrValue_Int64Vec* mutable_int64_vec();
  void set_allocated_int64_vec(::serial_v1::ExpandAttrValue_Int64Vec* int64_vec);
  private:
  const ::serial_v1::ExpandAttrValue_Int64Vec& _internal_int64_vec() const;
  ::serial_v1::ExpandAttrValue_Int64Vec* _internal_mutable_int64_vec();
  public:
  void unsafe_arena_set_allocated_int64_vec(
      ::serial_v1::ExpandAttrValue_Int64Vec* int64_vec);
  ::serial_v1::ExpandAttrValue_Int64Vec* unsafe_arena_release_int64_vec();

  // .serial_v1.ExpandAttrValue.FloatVec float_vec = 14;
  bool has_float_vec() const;
  private:
  bool _internal_has_float_vec() const;
  public:
  void clear_float_vec();
  const ::serial_v1::ExpandAttrValue_FloatVec& float_vec() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_FloatVec* release_float_vec();
  ::serial_v1::ExpandAttrValue_FloatVec* mutable_float_vec();
  void set_allocated_float_vec(::serial_v1::ExpandAttrValue_FloatVec* float_vec);
  private:
  const ::serial_v1::ExpandAttrValue_FloatVec& _internal_float_vec() const;
  ::serial_v1::ExpandAttrValue_FloatVec* _internal_mutable_float_vec();
  public:
  void unsafe_arena_set_allocated_float_vec(
      ::serial_v1::ExpandAttrValue_FloatVec* float_vec);
  ::serial_v1::ExpandAttrValue_FloatVec* unsafe_arena_release_float_vec();

  // .serial_v1.ExpandAttrValue.StringVec string_vec = 15;
  bool has_string_vec() const;
  private:
  bool _internal_has_string_vec() const;
  public:
  void clear_string_vec();
  const ::serial_v1::ExpandAttrValue_StringVec& string_vec() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_StringVec* release_string_vec();
  ::serial_v1::ExpandAttrValue_StringVec* mutable_string_vec();
  void set_allocated_string_vec(::serial_v1::ExpandAttrValue_StringVec* string_vec);
  private:
  const ::serial_v1::ExpandAttrValue_StringVec& _internal_string_vec() const;
  ::serial_v1::ExpandAttrValue_StringVec* _internal_mutable_string_vec();
  public:
  void unsafe_arena_set_allocated_string_vec(
      ::serial_v1::ExpandAttrValue_StringVec* string_vec);
  ::serial_v1::ExpandAttrValue_StringVec* unsafe_arena_release_string_vec();

  // .serial_v1.ExpandAttrValue.BoolMap bool_map = 21;
  bool has_bool_map() const;
  private:
  bool _internal_has_bool_map() const;
  public:
  void clear_bool_map();
  const ::serial_v1::ExpandAttrValue_BoolMap& bool_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_BoolMap* release_bool_map();
  ::serial_v1::ExpandAttrValue_BoolMap* mutable_bool_map();
  void set_allocated_bool_map(::serial_v1::ExpandAttrValue_BoolMap* bool_map);
  private:
  const ::serial_v1::ExpandAttrValue_BoolMap& _internal_bool_map() const;
  ::serial_v1::ExpandAttrValue_BoolMap* _internal_mutable_bool_map();
  public:
  void unsafe_arena_set_allocated_bool_map(
      ::serial_v1::ExpandAttrValue_BoolMap* bool_map);
  ::serial_v1::ExpandAttrValue_BoolMap* unsafe_arena_release_bool_map();

  // .serial_v1.ExpandAttrValue.Int32Map int32_map = 22;
  bool has_int32_map() const;
  private:
  bool _internal_has_int32_map() const;
  public:
  void clear_int32_map();
  const ::serial_v1::ExpandAttrValue_Int32Map& int32_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_Int32Map* release_int32_map();
  ::serial_v1::ExpandAttrValue_Int32Map* mutable_int32_map();
  void set_allocated_int32_map(::serial_v1::ExpandAttrValue_Int32Map* int32_map);
  private:
  const ::serial_v1::ExpandAttrValue_Int32Map& _internal_int32_map() const;
  ::serial_v1::ExpandAttrValue_Int32Map* _internal_mutable_int32_map();
  public:
  void unsafe_arena_set_allocated_int32_map(
      ::serial_v1::ExpandAttrValue_Int32Map* int32_map);
  ::serial_v1::ExpandAttrValue_Int32Map* unsafe_arena_release_int32_map();

  // .serial_v1.ExpandAttrValue.Int64Map int64_map = 23;
  bool has_int64_map() const;
  private:
  bool _internal_has_int64_map() const;
  public:
  void clear_int64_map();
  const ::serial_v1::ExpandAttrValue_Int64Map& int64_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_Int64Map* release_int64_map();
  ::serial_v1::ExpandAttrValue_Int64Map* mutable_int64_map();
  void set_allocated_int64_map(::serial_v1::ExpandAttrValue_Int64Map* int64_map);
  private:
  const ::serial_v1::ExpandAttrValue_Int64Map& _internal_int64_map() const;
  ::serial_v1::ExpandAttrValue_Int64Map* _internal_mutable_int64_map();
  public:
  void unsafe_arena_set_allocated_int64_map(
      ::serial_v1::ExpandAttrValue_Int64Map* int64_map);
  ::serial_v1::ExpandAttrValue_Int64Map* unsafe_arena_release_int64_map();

  // .serial_v1.ExpandAttrValue.FloatMap float_map = 24;
  bool has_float_map() const;
  private:
  bool _internal_has_float_map() const;
  public:
  void clear_float_map();
  const ::serial_v1::ExpandAttrValue_FloatMap& float_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_FloatMap* release_float_map();
  ::serial_v1::ExpandAttrValue_FloatMap* mutable_float_map();
  void set_allocated_float_map(::serial_v1::ExpandAttrValue_FloatMap* float_map);
  private:
  const ::serial_v1::ExpandAttrValue_FloatMap& _internal_float_map() const;
  ::serial_v1::ExpandAttrValue_FloatMap* _internal_mutable_float_map();
  public:
  void unsafe_arena_set_allocated_float_map(
      ::serial_v1::ExpandAttrValue_FloatMap* float_map);
  ::serial_v1::ExpandAttrValue_FloatMap* unsafe_arena_release_float_map();

  // .serial_v1.ExpandAttrValue.StringMap string_map = 25;
  bool has_string_map() const;
  private:
  bool _internal_has_string_map() const;
  public:
  void clear_string_map();
  const ::serial_v1::ExpandAttrValue_StringMap& string_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_StringMap* release_string_map();
  ::serial_v1::ExpandAttrValue_StringMap* mutable_string_map();
  void set_allocated_string_map(::serial_v1::ExpandAttrValue_StringMap* string_map);
  private:
  const ::serial_v1::ExpandAttrValue_StringMap& _internal_string_map() const;
  ::serial_v1::ExpandAttrValue_StringMap* _internal_mutable_string_map();
  public:
  void unsafe_arena_set_allocated_string_map(
      ::serial_v1::ExpandAttrValue_StringMap* string_map);
  ::serial_v1::ExpandAttrValue_StringMap* unsafe_arena_release_string_map();

  // .serial_v1.ExpandAttrValue.BytesMap bytes_map = 26;
  bool has_bytes_map() const;
  private:
  bool _internal_has_bytes_map() const;
  public:
  void clear_bytes_map();
  const ::serial_v1::ExpandAttrValue_BytesMap& bytes_map() const;
  PROTOBUF_NODISCARD ::serial_v1::ExpandAttrValue_BytesMap* release_bytes_map();
  ::serial_v1::ExpandAttrValue_BytesMap* mutable_bytes_map();
  void set_allocated_bytes_map(::serial_v1::ExpandAttrValue_BytesMap* bytes_map);
  private:
  const ::serial_v1::ExpandAttrValue_BytesMap& _internal_bytes_map() const;
  ::serial_v1::ExpandAttrValue_BytesMap* _internal_mutable_bytes_map();
  public:
  void unsafe_arena_set_allocated_bytes_map(
      ::serial_v1::ExpandAttrValue_BytesMap* bytes_map);
  ::serial_v1::ExpandAttrValue_BytesMap* unsafe_arena_release_bytes_map();

  void clear_attr_value();
  AttrValueCase attr_value_case() const;
  // @@protoc_insertion_point(class_scope:serial_v1.ExpandAttrValue)
 private:
  class _Internal;
  void set_has_bool_value();
  void set_has_int32_value();
  void set_has_int64_value();
  void set_has_float_value();
  void set_has_string_value();
  void set_has_bytes_value();
  void set_has_bool_vec();
  void set_has_int32_vec();
  void set_has_int64_vec();
  void set_has_float_vec();
  void set_has_string_vec();
  void set_has_bool_map();
  void set_has_int32_map();
  void set_has_int64_map();
  void set_has_float_map();
  void set_has_string_map();
  void set_has_bytes_map();

  inline bool has_attr_value() const;
  inline void clear_has_attr_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attr_name_;
    union AttrValueUnion {
      constexpr AttrValueUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      bool bool_value_;
      int32_t int32_value_;
      int64_t int64_value_;
      float float_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
      ::serial_v1::ExpandAttrValue_BoolVec* bool_vec_;
      ::serial_v1::ExpandAttrValue_Int32Vec* int32_vec_;
      ::serial_v1::ExpandAttrValue_Int64Vec* int64_vec_;
      ::serial_v1::ExpandAttrValue_FloatVec* float_vec_;
      ::serial_v1::ExpandAttrValue_StringVec* string_vec_;
      ::serial_v1::ExpandAttrValue_BoolMap* bool_map_;
      ::serial_v1::ExpandAttrValue_Int32Map* int32_map_;
      ::serial_v1::ExpandAttrValue_Int64Map* int64_map_;
      ::serial_v1::ExpandAttrValue_FloatMap* float_map_;
      ::serial_v1::ExpandAttrValue_StringMap* string_map_;
      ::serial_v1::ExpandAttrValue_BytesMap* bytes_map_;
    } attr_value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

  inline OneKindOP& operator=(const OneKindOP& from) {
    CopyFrom(from);
    return *this;
  }
  inline OneKindOP& operator=(OneKindOP&& 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 OneKindOP& default_instance() {
    return *internal_default_instance();
  }
  static inline const OneKindOP* internal_default_instance() {
    return reinterpret_cast<const OneKindOP*>(
               &_OneKindOP_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(OneKindOP& a, OneKindOP& b) {
    a.Swap(&b);
  }
  inline void Swap(OneKindOP* 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(OneKindOP* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OneKindOP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OneKindOP>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OneKindOP& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OneKindOP& from) {
    OneKindOP::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(OneKindOP* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "serial_v1.OneKindOP";
  }
  protected:
  explicit OneKindOP(::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 {
    kOpNameFieldNumber = 2,
    kOpTypeFieldNumber = 1,
  };
  // repeated string op_name = 2;
  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:

  // string op_type = 1;
  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:

  // @@protoc_insertion_point(class_scope:serial_v1.OneKindOP)
 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::ArenaStringPtr op_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Tensor final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    24;

  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_v1.Tensor";
  }
  protected:
  explicit Tensor(::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 {
    kTensorDimFieldNumber = 2,
    kTensorAttrFieldNumber = 10,
    kTensorNameFieldNumber = 1,
    kDataTypeFieldNumber = 5,
  };
  // 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();

  // repeated .serial_v1.ExpandAttrValue tensor_attr = 10;
  int tensor_attr_size() const;
  private:
  int _internal_tensor_attr_size() const;
  public:
  void clear_tensor_attr();
  ::serial_v1::ExpandAttrValue* mutable_tensor_attr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
      mutable_tensor_attr();
  private:
  const ::serial_v1::ExpandAttrValue& _internal_tensor_attr(int index) const;
  ::serial_v1::ExpandAttrValue* _internal_add_tensor_attr();
  public:
  const ::serial_v1::ExpandAttrValue& tensor_attr(int index) const;
  ::serial_v1::ExpandAttrValue* add_tensor_attr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
      tensor_attr() const;

  // 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:

  // @@protoc_insertion_point(class_scope:serial_v1.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::RepeatedPtrField< ::serial_v1::ExpandAttrValue > tensor_attr_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
    int32_t data_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OPNode final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    25;

  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_v1.OPNode";
  }
  protected:
  explicit OPNode(::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 {
    kOpAttrFieldNumber = 3,
    kInputOpFieldNumber = 4,
    kExpandOpAttrFieldNumber = 8,
    kOpNameFieldNumber = 1,
    kOpTypeFieldNumber = 2,
    kOutputTensorFieldNumber = 5,
  };
  // repeated .serial_v1.AttrValue op_attr = 3;
  int op_attr_size() const;
  private:
  int _internal_op_attr_size() const;
  public:
  void clear_op_attr();
  ::serial_v1::AttrValue* mutable_op_attr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue >*
      mutable_op_attr();
  private:
  const ::serial_v1::AttrValue& _internal_op_attr(int index) const;
  ::serial_v1::AttrValue* _internal_add_op_attr();
  public:
  const ::serial_v1::AttrValue& op_attr(int index) const;
  ::serial_v1::AttrValue* add_op_attr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue >&
      op_attr() const;

  // repeated .serial_v1.OneKindOP input_op = 4;
  int input_op_size() const;
  private:
  int _internal_input_op_size() const;
  public:
  void clear_input_op();
  ::serial_v1::OneKindOP* mutable_input_op(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OneKindOP >*
      mutable_input_op();
  private:
  const ::serial_v1::OneKindOP& _internal_input_op(int index) const;
  ::serial_v1::OneKindOP* _internal_add_input_op();
  public:
  const ::serial_v1::OneKindOP& input_op(int index) const;
  ::serial_v1::OneKindOP* add_input_op();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OneKindOP >&
      input_op() const;

  // repeated .serial_v1.ExpandAttrValue expand_op_attr = 8;
  int expand_op_attr_size() const;
  private:
  int _internal_expand_op_attr_size() const;
  public:
  void clear_expand_op_attr();
  ::serial_v1::ExpandAttrValue* mutable_expand_op_attr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
      mutable_expand_op_attr();
  private:
  const ::serial_v1::ExpandAttrValue& _internal_expand_op_attr(int index) const;
  ::serial_v1::ExpandAttrValue* _internal_add_expand_op_attr();
  public:
  const ::serial_v1::ExpandAttrValue& expand_op_attr(int index) const;
  ::serial_v1::ExpandAttrValue* add_expand_op_attr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
      expand_op_attr() 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_v1.Tensor output_tensor = 5;
  bool has_output_tensor() const;
  private:
  bool _internal_has_output_tensor() const;
  public:
  void clear_output_tensor();
  const ::serial_v1::Tensor& output_tensor() const;
  PROTOBUF_NODISCARD ::serial_v1::Tensor* release_output_tensor();
  ::serial_v1::Tensor* mutable_output_tensor();
  void set_allocated_output_tensor(::serial_v1::Tensor* output_tensor);
  private:
  const ::serial_v1::Tensor& _internal_output_tensor() const;
  ::serial_v1::Tensor* _internal_mutable_output_tensor();
  public:
  void unsafe_arena_set_allocated_output_tensor(
      ::serial_v1::Tensor* output_tensor);
  ::serial_v1::Tensor* unsafe_arena_release_output_tensor();

  // @@protoc_insertion_point(class_scope:serial_v1.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::RepeatedPtrField< ::serial_v1::AttrValue > op_attr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OneKindOP > input_op_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue > expand_op_attr_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
    ::serial_v1::Tensor* output_tensor_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC SubGraph final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    26;

  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_v1.SubGraph";
  }
  protected:
  explicit SubGraph(::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 {
    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:

  // repeated .serial_v1.ExpandAttrValue subg_attr = 5;
  int subg_attr_size() const;
  private:
  int _internal_subg_attr_size() const;
  public:
  void clear_subg_attr();
  ::serial_v1::ExpandAttrValue* mutable_subg_attr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
      mutable_subg_attr();
  private:
  const ::serial_v1::ExpandAttrValue& _internal_subg_attr(int index) const;
  ::serial_v1::ExpandAttrValue* _internal_add_subg_attr();
  public:
  const ::serial_v1::ExpandAttrValue& subg_attr(int index) const;
  ::serial_v1::ExpandAttrValue* add_subg_attr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
      subg_attr() const;

  // repeated .serial_v1.SubGraph subg_child = 10;
  int subg_child_size() const;
  private:
  int _internal_subg_child_size() const;
  public:
  void clear_subg_child();
  ::serial_v1::SubGraph* mutable_subg_child(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::SubGraph >*
      mutable_subg_child();
  private:
  const ::serial_v1::SubGraph& _internal_subg_child(int index) const;
  ::serial_v1::SubGraph* _internal_add_subg_child();
  public:
  const ::serial_v1::SubGraph& subg_child(int index) const;
  ::serial_v1::SubGraph* add_subg_child();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::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_v1.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::RepeatedPtrField< ::serial_v1::ExpandAttrValue > subg_attr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::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_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC Graph final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    27;

  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_v1.Graph";
  }
  protected:
  explicit Graph(::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 {
    kOpNodeFieldNumber = 5,
    kOpDefsFieldNumber = 101,
    kGraphNameFieldNumber = 1,
    kSubgRootFieldNumber = 10,
  };
  // repeated .serial_v1.OPNode op_node = 5;
  int op_node_size() const;
  private:
  int _internal_op_node_size() const;
  public:
  void clear_op_node();
  ::serial_v1::OPNode* mutable_op_node(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OPNode >*
      mutable_op_node();
  private:
  const ::serial_v1::OPNode& _internal_op_node(int index) const;
  ::serial_v1::OPNode* _internal_add_op_node();
  public:
  const ::serial_v1::OPNode& op_node(int index) const;
  ::serial_v1::OPNode* add_op_node();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OPNode >&
      op_node() const;

  // repeated .serial_v1.OpDef op_defs = 101;
  int op_defs_size() const;
  private:
  int _internal_op_defs_size() const;
  public:
  void clear_op_defs();
  ::serial_v1::OpDef* mutable_op_defs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpDef >*
      mutable_op_defs();
  private:
  const ::serial_v1::OpDef& _internal_op_defs(int index) const;
  ::serial_v1::OpDef* _internal_add_op_defs();
  public:
  const ::serial_v1::OpDef& op_defs(int index) const;
  ::serial_v1::OpDef* add_op_defs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::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_v1.SubGraph subg_root = 10;
  bool has_subg_root() const;
  private:
  bool _internal_has_subg_root() const;
  public:
  void clear_subg_root();
  const ::serial_v1::SubGraph& subg_root() const;
  PROTOBUF_NODISCARD ::serial_v1::SubGraph* release_subg_root();
  ::serial_v1::SubGraph* mutable_subg_root();
  void set_allocated_subg_root(::serial_v1::SubGraph* subg_root);
  private:
  const ::serial_v1::SubGraph& _internal_subg_root() const;
  ::serial_v1::SubGraph* _internal_mutable_subg_root();
  public:
  void unsafe_arena_set_allocated_subg_root(
      ::serial_v1::SubGraph* subg_root);
  ::serial_v1::SubGraph* unsafe_arena_release_subg_root();

  // @@protoc_insertion_point(class_scope:serial_v1.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_v1::OPNode > op_node_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpDef > op_defs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_name_;
    ::serial_v1::SubGraph* subg_root_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC AttrDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    28;

  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_v1.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,
    kDataTypeFieldNumber = 2,
    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_v1.AttrValue default_value = 4;
  bool has_default_value() const;
  private:
  bool _internal_has_default_value() const;
  public:
  void clear_default_value();
  const ::serial_v1::AttrValue& default_value() const;
  PROTOBUF_NODISCARD ::serial_v1::AttrValue* release_default_value();
  ::serial_v1::AttrValue* mutable_default_value();
  void set_allocated_default_value(::serial_v1::AttrValue* default_value);
  private:
  const ::serial_v1::AttrValue& _internal_default_value() const;
  ::serial_v1::AttrValue* _internal_mutable_default_value();
  public:
  void unsafe_arena_set_allocated_default_value(
      ::serial_v1::AttrValue* default_value);
  ::serial_v1::AttrValue* unsafe_arena_release_default_value();

  // int32 data_type = 2;
  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:

  // .serial_v1.AttrDef.OccurType occur_type = 3;
  void clear_occur_type();
  ::serial_v1::AttrDef_OccurType occur_type() const;
  void set_occur_type(::serial_v1::AttrDef_OccurType value);
  private:
  ::serial_v1::AttrDef_OccurType _internal_occur_type() const;
  void _internal_set_occur_type(::serial_v1::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_v1.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_v1::AttrValue* default_value_;
    int32_t data_type_;
    int occur_type_;
    int32_t list_length_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OpDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    29;

  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_v1.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_v1.OpArgDef input_args = 2;
  int input_args_size() const;
  private:
  int _internal_input_args_size() const;
  public:
  void clear_input_args();
  ::serial_v1::OpArgDef* mutable_input_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpArgDef >*
      mutable_input_args();
  private:
  const ::serial_v1::OpArgDef& _internal_input_args(int index) const;
  ::serial_v1::OpArgDef* _internal_add_input_args();
  public:
  const ::serial_v1::OpArgDef& input_args(int index) const;
  ::serial_v1::OpArgDef* add_input_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpArgDef >&
      input_args() const;

  // repeated .serial_v1.AttrDef attrs = 3;
  int attrs_size() const;
  private:
  int _internal_attrs_size() const;
  public:
  void clear_attrs();
  ::serial_v1::AttrDef* mutable_attrs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrDef >*
      mutable_attrs();
  private:
  const ::serial_v1::AttrDef& _internal_attrs(int index) const;
  ::serial_v1::AttrDef* _internal_add_attrs();
  public:
  const ::serial_v1::AttrDef& attrs(int index) const;
  ::serial_v1::AttrDef* add_attrs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::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_v1.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_v1::OpArgDef > input_args_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::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_5fv1_2eproto;
};
// -------------------------------------------------------------------

class XIR_DLLESPEC OpArgDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:serial_v1.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 =
    30;

  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_v1.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);
  }

  typedef OpArgDef_DataType DataType;
  static constexpr DataType ALL =
    OpArgDef_DataType_ALL;
  static constexpr DataType FLOAT =
    OpArgDef_DataType_FLOAT;
  static constexpr DataType INT =
    OpArgDef_DataType_INT;
  static constexpr DataType XINT =
    OpArgDef_DataType_XINT;
  static inline bool DataType_IsValid(int value) {
    return OpArgDef_DataType_IsValid(value);
  }
  static constexpr DataType DataType_MIN =
    OpArgDef_DataType_DataType_MIN;
  static constexpr DataType DataType_MAX =
    OpArgDef_DataType_DataType_MAX;
  static constexpr int DataType_ARRAYSIZE =
    OpArgDef_DataType_DataType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DataType_descriptor() {
    return OpArgDef_DataType_descriptor();
  }
  template<typename T>
  static inline const std::string& DataType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DataType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DataType_Name.");
    return OpArgDef_DataType_Name(enum_t_value);
  }
  static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DataType* value) {
    return OpArgDef_DataType_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_v1.OpArgDef.OccurType occur_type = 2;
  void clear_occur_type();
  ::serial_v1::OpArgDef_OccurType occur_type() const;
  void set_occur_type(::serial_v1::OpArgDef_OccurType value);
  private:
  ::serial_v1::OpArgDef_OccurType _internal_occur_type() const;
  void _internal_set_occur_type(::serial_v1::OpArgDef_OccurType value);
  public:

  // .serial_v1.OpArgDef.DataType data_type = 3;
  void clear_data_type();
  ::serial_v1::OpArgDef_DataType data_type() const;
  void set_data_type(::serial_v1::OpArgDef_DataType value);
  private:
  ::serial_v1::OpArgDef_DataType _internal_data_type() const;
  void _internal_set_data_type(::serial_v1::OpArgDef_DataType value);
  public:

  // @@protoc_insertion_point(class_scope:serial_v1.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_;
    int data_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_graph_5fproto_5fv1_2eproto;
};
// ===================================================================


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

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

// repeated bool bool_value = 1;
inline int AttrValue_ListValue::_internal_bool_value_size() const {
  return _impl_.bool_value_.size();
}
inline int AttrValue_ListValue::bool_value_size() const {
  return _internal_bool_value_size();
}
inline void AttrValue_ListValue::clear_bool_value() {
  _impl_.bool_value_.Clear();
}
inline bool AttrValue_ListValue::_internal_bool_value(int index) const {
  return _impl_.bool_value_.Get(index);
}
inline bool AttrValue_ListValue::bool_value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.ListValue.bool_value)
  return _internal_bool_value(index);
}
inline void AttrValue_ListValue::set_bool_value(int index, bool value) {
  _impl_.bool_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.bool_value)
}
inline void AttrValue_ListValue::_internal_add_bool_value(bool value) {
  _impl_.bool_value_.Add(value);
}
inline void AttrValue_ListValue::add_bool_value(bool value) {
  _internal_add_bool_value(value);
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.bool_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
AttrValue_ListValue::_internal_bool_value() const {
  return _impl_.bool_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
AttrValue_ListValue::bool_value() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.ListValue.bool_value)
  return _internal_bool_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
AttrValue_ListValue::_internal_mutable_bool_value() {
  return &_impl_.bool_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
AttrValue_ListValue::mutable_bool_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.ListValue.bool_value)
  return _internal_mutable_bool_value();
}

// repeated sint64 int64_value = 3;
inline int AttrValue_ListValue::_internal_int64_value_size() const {
  return _impl_.int64_value_.size();
}
inline int AttrValue_ListValue::int64_value_size() const {
  return _internal_int64_value_size();
}
inline void AttrValue_ListValue::clear_int64_value() {
  _impl_.int64_value_.Clear();
}
inline int64_t AttrValue_ListValue::_internal_int64_value(int index) const {
  return _impl_.int64_value_.Get(index);
}
inline int64_t AttrValue_ListValue::int64_value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.ListValue.int64_value)
  return _internal_int64_value(index);
}
inline void AttrValue_ListValue::set_int64_value(int index, int64_t value) {
  _impl_.int64_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.int64_value)
}
inline void AttrValue_ListValue::_internal_add_int64_value(int64_t value) {
  _impl_.int64_value_.Add(value);
}
inline void AttrValue_ListValue::add_int64_value(int64_t value) {
  _internal_add_int64_value(value);
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.int64_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
AttrValue_ListValue::_internal_int64_value() const {
  return _impl_.int64_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
AttrValue_ListValue::int64_value() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.ListValue.int64_value)
  return _internal_int64_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
AttrValue_ListValue::_internal_mutable_int64_value() {
  return &_impl_.int64_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
AttrValue_ListValue::mutable_int64_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.ListValue.int64_value)
  return _internal_mutable_int64_value();
}

// repeated float float_value = 4;
inline int AttrValue_ListValue::_internal_float_value_size() const {
  return _impl_.float_value_.size();
}
inline int AttrValue_ListValue::float_value_size() const {
  return _internal_float_value_size();
}
inline void AttrValue_ListValue::clear_float_value() {
  _impl_.float_value_.Clear();
}
inline float AttrValue_ListValue::_internal_float_value(int index) const {
  return _impl_.float_value_.Get(index);
}
inline float AttrValue_ListValue::float_value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.ListValue.float_value)
  return _internal_float_value(index);
}
inline void AttrValue_ListValue::set_float_value(int index, float value) {
  _impl_.float_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.float_value)
}
inline void AttrValue_ListValue::_internal_add_float_value(float value) {
  _impl_.float_value_.Add(value);
}
inline void AttrValue_ListValue::add_float_value(float value) {
  _internal_add_float_value(value);
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.float_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
AttrValue_ListValue::_internal_float_value() const {
  return _impl_.float_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
AttrValue_ListValue::float_value() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.ListValue.float_value)
  return _internal_float_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
AttrValue_ListValue::_internal_mutable_float_value() {
  return &_impl_.float_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
AttrValue_ListValue::mutable_float_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.ListValue.float_value)
  return _internal_mutable_float_value();
}

// repeated string string_value = 5;
inline int AttrValue_ListValue::_internal_string_value_size() const {
  return _impl_.string_value_.size();
}
inline int AttrValue_ListValue::string_value_size() const {
  return _internal_string_value_size();
}
inline void AttrValue_ListValue::clear_string_value() {
  _impl_.string_value_.Clear();
}
inline std::string* AttrValue_ListValue::add_string_value() {
  std::string* _s = _internal_add_string_value();
  // @@protoc_insertion_point(field_add_mutable:serial_v1.AttrValue.ListValue.string_value)
  return _s;
}
inline const std::string& AttrValue_ListValue::_internal_string_value(int index) const {
  return _impl_.string_value_.Get(index);
}
inline const std::string& AttrValue_ListValue::string_value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.ListValue.string_value)
  return _internal_string_value(index);
}
inline std::string* AttrValue_ListValue::mutable_string_value(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.ListValue.string_value)
  return _impl_.string_value_.Mutable(index);
}
inline void AttrValue_ListValue::set_string_value(int index, const std::string& value) {
  _impl_.string_value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::set_string_value(int index, std::string&& value) {
  _impl_.string_value_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::set_string_value(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.string_value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::set_string_value(int index, const char* value, size_t size) {
  _impl_.string_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:serial_v1.AttrValue.ListValue.string_value)
}
inline std::string* AttrValue_ListValue::_internal_add_string_value() {
  return _impl_.string_value_.Add();
}
inline void AttrValue_ListValue::add_string_value(const std::string& value) {
  _impl_.string_value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::add_string_value(std::string&& value) {
  _impl_.string_value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::add_string_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.string_value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v1.AttrValue.ListValue.string_value)
}
inline void AttrValue_ListValue::add_string_value(const char* value, size_t size) {
  _impl_.string_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:serial_v1.AttrValue.ListValue.string_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AttrValue_ListValue::string_value() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.ListValue.string_value)
  return _impl_.string_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AttrValue_ListValue::mutable_string_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.ListValue.string_value)
  return &_impl_.string_value_;
}

// repeated bytes bytes_value = 6;
inline int AttrValue_ListValue::_internal_bytes_value_size() const {
  return _impl_.bytes_value_.size();
}
inline int AttrValue_ListValue::bytes_value_size() const {
  return _internal_bytes_value_size();
}
inline void AttrValue_ListValue::clear_bytes_value() {
  _impl_.bytes_value_.Clear();
}
inline std::string* AttrValue_ListValue::add_bytes_value() {
  std::string* _s = _internal_add_bytes_value();
  // @@protoc_insertion_point(field_add_mutable:serial_v1.AttrValue.ListValue.bytes_value)
  return _s;
}
inline const std::string& AttrValue_ListValue::_internal_bytes_value(int index) const {
  return _impl_.bytes_value_.Get(index);
}
inline const std::string& AttrValue_ListValue::bytes_value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.ListValue.bytes_value)
  return _internal_bytes_value(index);
}
inline std::string* AttrValue_ListValue::mutable_bytes_value(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.ListValue.bytes_value)
  return _impl_.bytes_value_.Mutable(index);
}
inline void AttrValue_ListValue::set_bytes_value(int index, const std::string& value) {
  _impl_.bytes_value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::set_bytes_value(int index, std::string&& value) {
  _impl_.bytes_value_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::set_bytes_value(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bytes_value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::set_bytes_value(int index, const void* value, size_t size) {
  _impl_.bytes_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:serial_v1.AttrValue.ListValue.bytes_value)
}
inline std::string* AttrValue_ListValue::_internal_add_bytes_value() {
  return _impl_.bytes_value_.Add();
}
inline void AttrValue_ListValue::add_bytes_value(const std::string& value) {
  _impl_.bytes_value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::add_bytes_value(std::string&& value) {
  _impl_.bytes_value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::add_bytes_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bytes_value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v1.AttrValue.ListValue.bytes_value)
}
inline void AttrValue_ListValue::add_bytes_value(const void* value, size_t size) {
  _impl_.bytes_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:serial_v1.AttrValue.ListValue.bytes_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AttrValue_ListValue::bytes_value() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.ListValue.bytes_value)
  return _impl_.bytes_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AttrValue_ListValue::mutable_bytes_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.ListValue.bytes_value)
  return &_impl_.bytes_value_;
}

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

// AttrValue_kv_pair

// string key = 1;
inline void AttrValue_kv_pair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& AttrValue_kv_pair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrValue_kv_pair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.key)
}
inline std::string* AttrValue_kv_pair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.kv_pair.key)
  return _s;
}
inline const std::string& AttrValue_kv_pair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void AttrValue_kv_pair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.kv_pair.key)
  return _impl_.key_.Release();
}
inline void AttrValue_kv_pair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.kv_pair.key)
}

// bool bool_value = 2;
inline void AttrValue_kv_pair::clear_bool_value() {
  _impl_.bool_value_ = false;
}
inline bool AttrValue_kv_pair::_internal_bool_value() const {
  return _impl_.bool_value_;
}
inline bool AttrValue_kv_pair::bool_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.bool_value)
  return _internal_bool_value();
}
inline void AttrValue_kv_pair::_internal_set_bool_value(bool value) {
  
  _impl_.bool_value_ = value;
}
inline void AttrValue_kv_pair::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.bool_value)
}

// sint64 int64_value = 4;
inline void AttrValue_kv_pair::clear_int64_value() {
  _impl_.int64_value_ = int64_t{0};
}
inline int64_t AttrValue_kv_pair::_internal_int64_value() const {
  return _impl_.int64_value_;
}
inline int64_t AttrValue_kv_pair::int64_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.int64_value)
  return _internal_int64_value();
}
inline void AttrValue_kv_pair::_internal_set_int64_value(int64_t value) {
  
  _impl_.int64_value_ = value;
}
inline void AttrValue_kv_pair::set_int64_value(int64_t value) {
  _internal_set_int64_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.int64_value)
}

// float float_value = 5;
inline void AttrValue_kv_pair::clear_float_value() {
  _impl_.float_value_ = 0;
}
inline float AttrValue_kv_pair::_internal_float_value() const {
  return _impl_.float_value_;
}
inline float AttrValue_kv_pair::float_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.float_value)
  return _internal_float_value();
}
inline void AttrValue_kv_pair::_internal_set_float_value(float value) {
  
  _impl_.float_value_ = value;
}
inline void AttrValue_kv_pair::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.float_value)
}

// string string_value = 6;
inline void AttrValue_kv_pair::clear_string_value() {
  _impl_.string_value_.ClearToEmpty();
}
inline const std::string& AttrValue_kv_pair::string_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrValue_kv_pair::set_string_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.string_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.string_value)
}
inline std::string* AttrValue_kv_pair::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.kv_pair.string_value)
  return _s;
}
inline const std::string& AttrValue_kv_pair::_internal_string_value() const {
  return _impl_.string_value_.Get();
}
inline void AttrValue_kv_pair::_internal_set_string_value(const std::string& value) {
  
  _impl_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::_internal_mutable_string_value() {
  
  return _impl_.string_value_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::release_string_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.kv_pair.string_value)
  return _impl_.string_value_.Release();
}
inline void AttrValue_kv_pair::set_allocated_string_value(std::string* string_value) {
  if (string_value != nullptr) {
    
  } else {
    
  }
  _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_value_.IsDefault()) {
    _impl_.string_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.kv_pair.string_value)
}

// bytes bytes_value = 7;
inline void AttrValue_kv_pair::clear_bytes_value() {
  _impl_.bytes_value_.ClearToEmpty();
}
inline const std::string& AttrValue_kv_pair::bytes_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_pair.bytes_value)
  return _internal_bytes_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrValue_kv_pair::set_bytes_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.bytes_value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.kv_pair.bytes_value)
}
inline std::string* AttrValue_kv_pair::mutable_bytes_value() {
  std::string* _s = _internal_mutable_bytes_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.kv_pair.bytes_value)
  return _s;
}
inline const std::string& AttrValue_kv_pair::_internal_bytes_value() const {
  return _impl_.bytes_value_.Get();
}
inline void AttrValue_kv_pair::_internal_set_bytes_value(const std::string& value) {
  
  _impl_.bytes_value_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::_internal_mutable_bytes_value() {
  
  return _impl_.bytes_value_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrValue_kv_pair::release_bytes_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.kv_pair.bytes_value)
  return _impl_.bytes_value_.Release();
}
inline void AttrValue_kv_pair::set_allocated_bytes_value(std::string* bytes_value) {
  if (bytes_value != nullptr) {
    
  } else {
    
  }
  _impl_.bytes_value_.SetAllocated(bytes_value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bytes_value_.IsDefault()) {
    _impl_.bytes_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.kv_pair.bytes_value)
}

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

// AttrValue_kv_map

// repeated .serial_v1.AttrValue.kv_pair pairs = 1;
inline int AttrValue_kv_map::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int AttrValue_kv_map::pairs_size() const {
  return _internal_pairs_size();
}
inline void AttrValue_kv_map::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::AttrValue_kv_pair* AttrValue_kv_map::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.kv_map.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue_kv_pair >*
AttrValue_kv_map::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.AttrValue.kv_map.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::AttrValue_kv_pair& AttrValue_kv_map::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::AttrValue_kv_pair& AttrValue_kv_map::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv_map.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::AttrValue_kv_pair* AttrValue_kv_map::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::AttrValue_kv_pair* AttrValue_kv_map::add_pairs() {
  ::serial_v1::AttrValue_kv_pair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.AttrValue.kv_map.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue_kv_pair >&
AttrValue_kv_map::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.AttrValue.kv_map.pairs)
  return _impl_.pairs_;
}

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

// AttrValue

// string attr_name = 1;
inline void AttrValue::clear_attr_name() {
  _impl_.attr_name_.ClearToEmpty();
}
inline const std::string& AttrValue::attr_name() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.attr_name)
  return _internal_attr_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttrValue::set_attr_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.attr_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.attr_name)
}
inline std::string* AttrValue::mutable_attr_name() {
  std::string* _s = _internal_mutable_attr_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.attr_name)
  return _s;
}
inline const std::string& AttrValue::_internal_attr_name() const {
  return _impl_.attr_name_.Get();
}
inline void AttrValue::_internal_set_attr_name(const std::string& value) {
  
  _impl_.attr_name_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue::_internal_mutable_attr_name() {
  
  return _impl_.attr_name_.Mutable(GetArenaForAllocation());
}
inline std::string* AttrValue::release_attr_name() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.attr_name)
  return _impl_.attr_name_.Release();
}
inline void AttrValue::set_allocated_attr_name(std::string* attr_name) {
  if (attr_name != nullptr) {
    
  } else {
    
  }
  _impl_.attr_name_.SetAllocated(attr_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attr_name_.IsDefault()) {
    _impl_.attr_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.attr_name)
}

// bool bool_value = 2;
inline bool AttrValue::_internal_has_bool_value() const {
  return attr_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_.attr_value_.bool_value_ = false;
    clear_has_attr_value();
  }
}
inline bool AttrValue::_internal_bool_value() const {
  if (_internal_has_bool_value()) {
    return _impl_.attr_value_.bool_value_;
  }
  return false;
}
inline void AttrValue::_internal_set_bool_value(bool value) {
  if (!_internal_has_bool_value()) {
    clear_attr_value();
    set_has_bool_value();
  }
  _impl_.attr_value_.bool_value_ = value;
}
inline bool AttrValue::bool_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.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_v1.AttrValue.bool_value)
}

// sint64 int64_value = 4;
inline bool AttrValue::_internal_has_int64_value() const {
  return attr_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_.attr_value_.int64_value_ = int64_t{0};
    clear_has_attr_value();
  }
}
inline int64_t AttrValue::_internal_int64_value() const {
  if (_internal_has_int64_value()) {
    return _impl_.attr_value_.int64_value_;
  }
  return int64_t{0};
}
inline void AttrValue::_internal_set_int64_value(int64_t value) {
  if (!_internal_has_int64_value()) {
    clear_attr_value();
    set_has_int64_value();
  }
  _impl_.attr_value_.int64_value_ = value;
}
inline int64_t AttrValue::int64_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.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_v1.AttrValue.int64_value)
}

// float float_value = 5;
inline bool AttrValue::_internal_has_float_value() const {
  return attr_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_.attr_value_.float_value_ = 0;
    clear_has_attr_value();
  }
}
inline float AttrValue::_internal_float_value() const {
  if (_internal_has_float_value()) {
    return _impl_.attr_value_.float_value_;
  }
  return 0;
}
inline void AttrValue::_internal_set_float_value(float value) {
  if (!_internal_has_float_value()) {
    clear_attr_value();
    set_has_float_value();
  }
  _impl_.attr_value_.float_value_ = value;
}
inline float AttrValue::float_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.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_v1.AttrValue.float_value)
}

// string string_value = 6;
inline bool AttrValue::_internal_has_string_value() const {
  return attr_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_.attr_value_.string_value_.Destroy();
    clear_has_attr_value();
  }
}
inline const std::string& AttrValue::string_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.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_attr_value();
    set_has_string_value();
    _impl_.attr_value_.string_value_.InitDefault();
  }
  _impl_.attr_value_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.string_value)
}
inline std::string* AttrValue::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.string_value)
  return _s;
}
inline const std::string& AttrValue::_internal_string_value() const {
  if (_internal_has_string_value()) {
    return _impl_.attr_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_attr_value();
    set_has_string_value();
    _impl_.attr_value_.string_value_.InitDefault();
  }
  _impl_.attr_value_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue::_internal_mutable_string_value() {
  if (!_internal_has_string_value()) {
    clear_attr_value();
    set_has_string_value();
    _impl_.attr_value_.string_value_.InitDefault();
  }
  return _impl_.attr_value_.string_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* AttrValue::release_string_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.string_value)
  if (_internal_has_string_value()) {
    clear_has_attr_value();
    return _impl_.attr_value_.string_value_.Release();
  } else {
    return nullptr;
  }
}
inline void AttrValue::set_allocated_string_value(std::string* string_value) {
  if (has_attr_value()) {
    clear_attr_value();
  }
  if (string_value != nullptr) {
    set_has_string_value();
    _impl_.attr_value_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.string_value)
}

// bytes bytes_value = 7;
inline bool AttrValue::_internal_has_bytes_value() const {
  return attr_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()) {
    _impl_.attr_value_.bytes_value_.Destroy();
    clear_has_attr_value();
  }
}
inline const std::string& AttrValue::bytes_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.bytes_value)
  return _internal_bytes_value();
}
template <typename ArgT0, typename... ArgT>
inline void AttrValue::set_bytes_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  _impl_.attr_value_.bytes_value_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.AttrValue.bytes_value)
}
inline std::string* AttrValue::mutable_bytes_value() {
  std::string* _s = _internal_mutable_bytes_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.bytes_value)
  return _s;
}
inline const std::string& AttrValue::_internal_bytes_value() const {
  if (_internal_has_bytes_value()) {
    return _impl_.attr_value_.bytes_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void AttrValue::_internal_set_bytes_value(const std::string& value) {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  _impl_.attr_value_.bytes_value_.Set(value, GetArenaForAllocation());
}
inline std::string* AttrValue::_internal_mutable_bytes_value() {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  return _impl_.attr_value_.bytes_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* AttrValue::release_bytes_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.bytes_value)
  if (_internal_has_bytes_value()) {
    clear_has_attr_value();
    return _impl_.attr_value_.bytes_value_.Release();
  } else {
    return nullptr;
  }
}
inline void AttrValue::set_allocated_bytes_value(std::string* bytes_value) {
  if (has_attr_value()) {
    clear_attr_value();
  }
  if (bytes_value != nullptr) {
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitAllocated(bytes_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:serial_v1.AttrValue.bytes_value)
}

// .serial_v1.AttrValue.ListValue list_value = 8;
inline bool AttrValue::_internal_has_list_value() const {
  return attr_value_case() == kListValue;
}
inline bool AttrValue::has_list_value() const {
  return _internal_has_list_value();
}
inline void AttrValue::set_has_list_value() {
  _impl_._oneof_case_[0] = kListValue;
}
inline void AttrValue::clear_list_value() {
  if (_internal_has_list_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.list_value_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::AttrValue_ListValue* AttrValue::release_list_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.list_value)
  if (_internal_has_list_value()) {
    clear_has_attr_value();
    ::serial_v1::AttrValue_ListValue* temp = _impl_.attr_value_.list_value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.list_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::AttrValue_ListValue& AttrValue::_internal_list_value() const {
  return _internal_has_list_value()
      ? *_impl_.attr_value_.list_value_
      : reinterpret_cast< ::serial_v1::AttrValue_ListValue&>(::serial_v1::_AttrValue_ListValue_default_instance_);
}
inline const ::serial_v1::AttrValue_ListValue& AttrValue::list_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.list_value)
  return _internal_list_value();
}
inline ::serial_v1::AttrValue_ListValue* AttrValue::unsafe_arena_release_list_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.AttrValue.list_value)
  if (_internal_has_list_value()) {
    clear_has_attr_value();
    ::serial_v1::AttrValue_ListValue* temp = _impl_.attr_value_.list_value_;
    _impl_.attr_value_.list_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_list_value(::serial_v1::AttrValue_ListValue* list_value) {
  clear_attr_value();
  if (list_value) {
    set_has_list_value();
    _impl_.attr_value_.list_value_ = list_value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.AttrValue.list_value)
}
inline ::serial_v1::AttrValue_ListValue* AttrValue::_internal_mutable_list_value() {
  if (!_internal_has_list_value()) {
    clear_attr_value();
    set_has_list_value();
    _impl_.attr_value_.list_value_ = CreateMaybeMessage< ::serial_v1::AttrValue_ListValue >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.list_value_;
}
inline ::serial_v1::AttrValue_ListValue* AttrValue::mutable_list_value() {
  ::serial_v1::AttrValue_ListValue* _msg = _internal_mutable_list_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.list_value)
  return _msg;
}

// .serial_v1.AttrValue.kv_map kv = 10;
inline bool AttrValue::_internal_has_kv() const {
  return attr_value_case() == kKv;
}
inline bool AttrValue::has_kv() const {
  return _internal_has_kv();
}
inline void AttrValue::set_has_kv() {
  _impl_._oneof_case_[0] = kKv;
}
inline void AttrValue::clear_kv() {
  if (_internal_has_kv()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.kv_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::AttrValue_kv_map* AttrValue::release_kv() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrValue.kv)
  if (_internal_has_kv()) {
    clear_has_attr_value();
    ::serial_v1::AttrValue_kv_map* temp = _impl_.attr_value_.kv_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.kv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::AttrValue_kv_map& AttrValue::_internal_kv() const {
  return _internal_has_kv()
      ? *_impl_.attr_value_.kv_
      : reinterpret_cast< ::serial_v1::AttrValue_kv_map&>(::serial_v1::_AttrValue_kv_map_default_instance_);
}
inline const ::serial_v1::AttrValue_kv_map& AttrValue::kv() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrValue.kv)
  return _internal_kv();
}
inline ::serial_v1::AttrValue_kv_map* AttrValue::unsafe_arena_release_kv() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.AttrValue.kv)
  if (_internal_has_kv()) {
    clear_has_attr_value();
    ::serial_v1::AttrValue_kv_map* temp = _impl_.attr_value_.kv_;
    _impl_.attr_value_.kv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AttrValue::unsafe_arena_set_allocated_kv(::serial_v1::AttrValue_kv_map* kv) {
  clear_attr_value();
  if (kv) {
    set_has_kv();
    _impl_.attr_value_.kv_ = kv;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.AttrValue.kv)
}
inline ::serial_v1::AttrValue_kv_map* AttrValue::_internal_mutable_kv() {
  if (!_internal_has_kv()) {
    clear_attr_value();
    set_has_kv();
    _impl_.attr_value_.kv_ = CreateMaybeMessage< ::serial_v1::AttrValue_kv_map >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.kv_;
}
inline ::serial_v1::AttrValue_kv_map* AttrValue::mutable_kv() {
  ::serial_v1::AttrValue_kv_map* _msg = _internal_mutable_kv();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrValue.kv)
  return _msg;
}

inline bool AttrValue::has_attr_value() const {
  return attr_value_case() != ATTR_VALUE_NOT_SET;
}
inline void AttrValue::clear_has_attr_value() {
  _impl_._oneof_case_[0] = ATTR_VALUE_NOT_SET;
}
inline AttrValue::AttrValueCase AttrValue::attr_value_case() const {
  return AttrValue::AttrValueCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// ExpandAttrValue_BoolVec

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

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

// ExpandAttrValue_Int32Vec

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

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

// ExpandAttrValue_Int64Vec

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

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

// ExpandAttrValue_FloatVec

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

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

// ExpandAttrValue_StringVec

// repeated string value = 1;
inline int ExpandAttrValue_StringVec::_internal_value_size() const {
  return _impl_.value_.size();
}
inline int ExpandAttrValue_StringVec::value_size() const {
  return _internal_value_size();
}
inline void ExpandAttrValue_StringVec::clear_value() {
  _impl_.value_.Clear();
}
inline std::string* ExpandAttrValue_StringVec::add_value() {
  std::string* _s = _internal_add_value();
  // @@protoc_insertion_point(field_add_mutable:serial_v1.ExpandAttrValue.StringVec.value)
  return _s;
}
inline const std::string& ExpandAttrValue_StringVec::_internal_value(int index) const {
  return _impl_.value_.Get(index);
}
inline const std::string& ExpandAttrValue_StringVec::value(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.StringVec.value)
  return _internal_value(index);
}
inline std::string* ExpandAttrValue_StringVec::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.StringVec.value)
  return _impl_.value_.Mutable(index);
}
inline void ExpandAttrValue_StringVec::set_value(int index, const std::string& value) {
  _impl_.value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_StringVec::set_value(int index, std::string&& value) {
  _impl_.value_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_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_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_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_v1.ExpandAttrValue.StringVec.value)
}
inline std::string* ExpandAttrValue_StringVec::_internal_add_value() {
  return _impl_.value_.Add();
}
inline void ExpandAttrValue_StringVec::add_value(const std::string& value) {
  _impl_.value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_StringVec::add_value(std::string&& value) {
  _impl_.value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_StringVec::add_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v1.ExpandAttrValue.StringVec.value)
}
inline void ExpandAttrValue_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_v1.ExpandAttrValue.StringVec.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ExpandAttrValue_StringVec::value() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.StringVec.value)
  return _impl_.value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ExpandAttrValue_StringVec::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.StringVec.value)
  return &_impl_.value_;
}

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

// ExpandAttrValue_BytesVec

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

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

// ExpandAttrValue_KeyBoolPair

// string key = 1;
inline void ExpandAttrValue_KeyBoolPair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyBoolPair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyBoolPair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyBoolPair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyBoolPair.key)
}
inline std::string* ExpandAttrValue_KeyBoolPair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyBoolPair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyBoolPair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyBoolPair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBoolPair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBoolPair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyBoolPair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyBoolPair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyBoolPair.key)
}

// bool value = 2;
inline void ExpandAttrValue_KeyBoolPair::clear_value() {
  _impl_.value_ = false;
}
inline bool ExpandAttrValue_KeyBoolPair::_internal_value() const {
  return _impl_.value_;
}
inline bool ExpandAttrValue_KeyBoolPair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyBoolPair.value)
  return _internal_value();
}
inline void ExpandAttrValue_KeyBoolPair::_internal_set_value(bool value) {
  
  _impl_.value_ = value;
}
inline void ExpandAttrValue_KeyBoolPair::set_value(bool value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyBoolPair.value)
}

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

// ExpandAttrValue_BoolMap

// repeated .serial_v1.ExpandAttrValue.KeyBoolPair pairs = 1;
inline int ExpandAttrValue_BoolMap::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_BoolMap::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_BoolMap::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyBoolPair* ExpandAttrValue_BoolMap::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.BoolMap.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBoolPair >*
ExpandAttrValue_BoolMap::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.BoolMap.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyBoolPair& ExpandAttrValue_BoolMap::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyBoolPair& ExpandAttrValue_BoolMap::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.BoolMap.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyBoolPair* ExpandAttrValue_BoolMap::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyBoolPair* ExpandAttrValue_BoolMap::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyBoolPair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.BoolMap.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBoolPair >&
ExpandAttrValue_BoolMap::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.BoolMap.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue_KeyInt32Pair

// string key = 1;
inline void ExpandAttrValue_KeyInt32Pair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyInt32Pair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyInt32Pair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyInt32Pair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyInt32Pair.key)
}
inline std::string* ExpandAttrValue_KeyInt32Pair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyInt32Pair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyInt32Pair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyInt32Pair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyInt32Pair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyInt32Pair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyInt32Pair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyInt32Pair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyInt32Pair.key)
}

// sint32 value = 2;
inline void ExpandAttrValue_KeyInt32Pair::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t ExpandAttrValue_KeyInt32Pair::_internal_value() const {
  return _impl_.value_;
}
inline int32_t ExpandAttrValue_KeyInt32Pair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyInt32Pair.value)
  return _internal_value();
}
inline void ExpandAttrValue_KeyInt32Pair::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void ExpandAttrValue_KeyInt32Pair::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyInt32Pair.value)
}

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

// ExpandAttrValue_Int32Map

// repeated .serial_v1.ExpandAttrValue.KeyInt32Pair pairs = 1;
inline int ExpandAttrValue_Int32Map::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_Int32Map::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_Int32Map::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyInt32Pair* ExpandAttrValue_Int32Map::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.Int32Map.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt32Pair >*
ExpandAttrValue_Int32Map::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.Int32Map.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyInt32Pair& ExpandAttrValue_Int32Map::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyInt32Pair& ExpandAttrValue_Int32Map::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.Int32Map.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyInt32Pair* ExpandAttrValue_Int32Map::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyInt32Pair* ExpandAttrValue_Int32Map::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyInt32Pair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.Int32Map.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt32Pair >&
ExpandAttrValue_Int32Map::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.Int32Map.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue_KeyInt64Pair

// string key = 1;
inline void ExpandAttrValue_KeyInt64Pair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyInt64Pair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyInt64Pair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyInt64Pair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyInt64Pair.key)
}
inline std::string* ExpandAttrValue_KeyInt64Pair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyInt64Pair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyInt64Pair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyInt64Pair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyInt64Pair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyInt64Pair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyInt64Pair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyInt64Pair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyInt64Pair.key)
}

// sint64 value = 2;
inline void ExpandAttrValue_KeyInt64Pair::clear_value() {
  _impl_.value_ = int64_t{0};
}
inline int64_t ExpandAttrValue_KeyInt64Pair::_internal_value() const {
  return _impl_.value_;
}
inline int64_t ExpandAttrValue_KeyInt64Pair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyInt64Pair.value)
  return _internal_value();
}
inline void ExpandAttrValue_KeyInt64Pair::_internal_set_value(int64_t value) {
  
  _impl_.value_ = value;
}
inline void ExpandAttrValue_KeyInt64Pair::set_value(int64_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyInt64Pair.value)
}

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

// ExpandAttrValue_Int64Map

// repeated .serial_v1.ExpandAttrValue.KeyInt64Pair pairs = 1;
inline int ExpandAttrValue_Int64Map::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_Int64Map::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_Int64Map::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyInt64Pair* ExpandAttrValue_Int64Map::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.Int64Map.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt64Pair >*
ExpandAttrValue_Int64Map::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.Int64Map.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyInt64Pair& ExpandAttrValue_Int64Map::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyInt64Pair& ExpandAttrValue_Int64Map::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.Int64Map.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyInt64Pair* ExpandAttrValue_Int64Map::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyInt64Pair* ExpandAttrValue_Int64Map::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyInt64Pair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.Int64Map.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyInt64Pair >&
ExpandAttrValue_Int64Map::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.Int64Map.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue_KeyFloatPair

// string key = 1;
inline void ExpandAttrValue_KeyFloatPair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyFloatPair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyFloatPair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyFloatPair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyFloatPair.key)
}
inline std::string* ExpandAttrValue_KeyFloatPair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyFloatPair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyFloatPair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyFloatPair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyFloatPair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyFloatPair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyFloatPair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyFloatPair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyFloatPair.key)
}

// float value = 2;
inline void ExpandAttrValue_KeyFloatPair::clear_value() {
  _impl_.value_ = 0;
}
inline float ExpandAttrValue_KeyFloatPair::_internal_value() const {
  return _impl_.value_;
}
inline float ExpandAttrValue_KeyFloatPair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyFloatPair.value)
  return _internal_value();
}
inline void ExpandAttrValue_KeyFloatPair::_internal_set_value(float value) {
  
  _impl_.value_ = value;
}
inline void ExpandAttrValue_KeyFloatPair::set_value(float value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyFloatPair.value)
}

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

// ExpandAttrValue_FloatMap

// repeated .serial_v1.ExpandAttrValue.KeyFloatPair pairs = 1;
inline int ExpandAttrValue_FloatMap::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_FloatMap::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_FloatMap::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyFloatPair* ExpandAttrValue_FloatMap::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.FloatMap.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyFloatPair >*
ExpandAttrValue_FloatMap::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.FloatMap.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyFloatPair& ExpandAttrValue_FloatMap::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyFloatPair& ExpandAttrValue_FloatMap::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.FloatMap.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyFloatPair* ExpandAttrValue_FloatMap::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyFloatPair* ExpandAttrValue_FloatMap::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyFloatPair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.FloatMap.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyFloatPair >&
ExpandAttrValue_FloatMap::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.FloatMap.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue_KeyStringPair

// string key = 1;
inline void ExpandAttrValue_KeyStringPair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyStringPair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyStringPair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyStringPair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyStringPair.key)
}
inline std::string* ExpandAttrValue_KeyStringPair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyStringPair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyStringPair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyStringPair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyStringPair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyStringPair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyStringPair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyStringPair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyStringPair.key)
}

// string value = 2;
inline void ExpandAttrValue_KeyStringPair::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyStringPair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyStringPair.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyStringPair::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyStringPair.value)
}
inline std::string* ExpandAttrValue_KeyStringPair::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyStringPair.value)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyStringPair::_internal_value() const {
  return _impl_.value_.Get();
}
inline void ExpandAttrValue_KeyStringPair::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyStringPair::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyStringPair::release_value() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyStringPair.value)
  return _impl_.value_.Release();
}
inline void ExpandAttrValue_KeyStringPair::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_v1.ExpandAttrValue.KeyStringPair.value)
}

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

// ExpandAttrValue_StringMap

// repeated .serial_v1.ExpandAttrValue.KeyStringPair pairs = 1;
inline int ExpandAttrValue_StringMap::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_StringMap::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_StringMap::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyStringPair* ExpandAttrValue_StringMap::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.StringMap.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyStringPair >*
ExpandAttrValue_StringMap::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.StringMap.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyStringPair& ExpandAttrValue_StringMap::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyStringPair& ExpandAttrValue_StringMap::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.StringMap.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyStringPair* ExpandAttrValue_StringMap::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyStringPair* ExpandAttrValue_StringMap::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyStringPair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.StringMap.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyStringPair >&
ExpandAttrValue_StringMap::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.StringMap.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue_KeyBytesPair

// string key = 1;
inline void ExpandAttrValue_KeyBytesPair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyBytesPair::key() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyBytesPair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyBytesPair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyBytesPair.key)
}
inline std::string* ExpandAttrValue_KeyBytesPair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyBytesPair.key)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyBytesPair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ExpandAttrValue_KeyBytesPair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBytesPair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBytesPair::release_key() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyBytesPair.key)
  return _impl_.key_.Release();
}
inline void ExpandAttrValue_KeyBytesPair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.KeyBytesPair.key)
}

// bytes value = 2;
inline void ExpandAttrValue_KeyBytesPair::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue_KeyBytesPair::value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.KeyBytesPair.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue_KeyBytesPair::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.KeyBytesPair.value)
}
inline std::string* ExpandAttrValue_KeyBytesPair::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.KeyBytesPair.value)
  return _s;
}
inline const std::string& ExpandAttrValue_KeyBytesPair::_internal_value() const {
  return _impl_.value_.Get();
}
inline void ExpandAttrValue_KeyBytesPair::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBytesPair::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue_KeyBytesPair::release_value() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.KeyBytesPair.value)
  return _impl_.value_.Release();
}
inline void ExpandAttrValue_KeyBytesPair::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_v1.ExpandAttrValue.KeyBytesPair.value)
}

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

// ExpandAttrValue_BytesMap

// repeated .serial_v1.ExpandAttrValue.KeyBytesPair pairs = 1;
inline int ExpandAttrValue_BytesMap::_internal_pairs_size() const {
  return _impl_.pairs_.size();
}
inline int ExpandAttrValue_BytesMap::pairs_size() const {
  return _internal_pairs_size();
}
inline void ExpandAttrValue_BytesMap::clear_pairs() {
  _impl_.pairs_.Clear();
}
inline ::serial_v1::ExpandAttrValue_KeyBytesPair* ExpandAttrValue_BytesMap::mutable_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.BytesMap.pairs)
  return _impl_.pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBytesPair >*
ExpandAttrValue_BytesMap::mutable_pairs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.ExpandAttrValue.BytesMap.pairs)
  return &_impl_.pairs_;
}
inline const ::serial_v1::ExpandAttrValue_KeyBytesPair& ExpandAttrValue_BytesMap::_internal_pairs(int index) const {
  return _impl_.pairs_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue_KeyBytesPair& ExpandAttrValue_BytesMap::pairs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.BytesMap.pairs)
  return _internal_pairs(index);
}
inline ::serial_v1::ExpandAttrValue_KeyBytesPair* ExpandAttrValue_BytesMap::_internal_add_pairs() {
  return _impl_.pairs_.Add();
}
inline ::serial_v1::ExpandAttrValue_KeyBytesPair* ExpandAttrValue_BytesMap::add_pairs() {
  ::serial_v1::ExpandAttrValue_KeyBytesPair* _add = _internal_add_pairs();
  // @@protoc_insertion_point(field_add:serial_v1.ExpandAttrValue.BytesMap.pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue_KeyBytesPair >&
ExpandAttrValue_BytesMap::pairs() const {
  // @@protoc_insertion_point(field_list:serial_v1.ExpandAttrValue.BytesMap.pairs)
  return _impl_.pairs_;
}

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

// ExpandAttrValue

// string attr_name = 100;
inline void ExpandAttrValue::clear_attr_name() {
  _impl_.attr_name_.ClearToEmpty();
}
inline const std::string& ExpandAttrValue::attr_name() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.attr_name)
  return _internal_attr_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExpandAttrValue::set_attr_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.attr_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.attr_name)
}
inline std::string* ExpandAttrValue::mutable_attr_name() {
  std::string* _s = _internal_mutable_attr_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.attr_name)
  return _s;
}
inline const std::string& ExpandAttrValue::_internal_attr_name() const {
  return _impl_.attr_name_.Get();
}
inline void ExpandAttrValue::_internal_set_attr_name(const std::string& value) {
  
  _impl_.attr_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue::_internal_mutable_attr_name() {
  
  return _impl_.attr_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ExpandAttrValue::release_attr_name() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.attr_name)
  return _impl_.attr_name_.Release();
}
inline void ExpandAttrValue::set_allocated_attr_name(std::string* attr_name) {
  if (attr_name != nullptr) {
    
  } else {
    
  }
  _impl_.attr_name_.SetAllocated(attr_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attr_name_.IsDefault()) {
    _impl_.attr_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.attr_name)
}

// bool bool_value = 1;
inline bool ExpandAttrValue::_internal_has_bool_value() const {
  return attr_value_case() == kBoolValue;
}
inline bool ExpandAttrValue::has_bool_value() const {
  return _internal_has_bool_value();
}
inline void ExpandAttrValue::set_has_bool_value() {
  _impl_._oneof_case_[0] = kBoolValue;
}
inline void ExpandAttrValue::clear_bool_value() {
  if (_internal_has_bool_value()) {
    _impl_.attr_value_.bool_value_ = false;
    clear_has_attr_value();
  }
}
inline bool ExpandAttrValue::_internal_bool_value() const {
  if (_internal_has_bool_value()) {
    return _impl_.attr_value_.bool_value_;
  }
  return false;
}
inline void ExpandAttrValue::_internal_set_bool_value(bool value) {
  if (!_internal_has_bool_value()) {
    clear_attr_value();
    set_has_bool_value();
  }
  _impl_.attr_value_.bool_value_ = value;
}
inline bool ExpandAttrValue::bool_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.bool_value)
  return _internal_bool_value();
}
inline void ExpandAttrValue::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.bool_value)
}

// sint32 int32_value = 2;
inline bool ExpandAttrValue::_internal_has_int32_value() const {
  return attr_value_case() == kInt32Value;
}
inline bool ExpandAttrValue::has_int32_value() const {
  return _internal_has_int32_value();
}
inline void ExpandAttrValue::set_has_int32_value() {
  _impl_._oneof_case_[0] = kInt32Value;
}
inline void ExpandAttrValue::clear_int32_value() {
  if (_internal_has_int32_value()) {
    _impl_.attr_value_.int32_value_ = 0;
    clear_has_attr_value();
  }
}
inline int32_t ExpandAttrValue::_internal_int32_value() const {
  if (_internal_has_int32_value()) {
    return _impl_.attr_value_.int32_value_;
  }
  return 0;
}
inline void ExpandAttrValue::_internal_set_int32_value(int32_t value) {
  if (!_internal_has_int32_value()) {
    clear_attr_value();
    set_has_int32_value();
  }
  _impl_.attr_value_.int32_value_ = value;
}
inline int32_t ExpandAttrValue::int32_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int32_value)
  return _internal_int32_value();
}
inline void ExpandAttrValue::set_int32_value(int32_t value) {
  _internal_set_int32_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.int32_value)
}

// sint64 int64_value = 3;
inline bool ExpandAttrValue::_internal_has_int64_value() const {
  return attr_value_case() == kInt64Value;
}
inline bool ExpandAttrValue::has_int64_value() const {
  return _internal_has_int64_value();
}
inline void ExpandAttrValue::set_has_int64_value() {
  _impl_._oneof_case_[0] = kInt64Value;
}
inline void ExpandAttrValue::clear_int64_value() {
  if (_internal_has_int64_value()) {
    _impl_.attr_value_.int64_value_ = int64_t{0};
    clear_has_attr_value();
  }
}
inline int64_t ExpandAttrValue::_internal_int64_value() const {
  if (_internal_has_int64_value()) {
    return _impl_.attr_value_.int64_value_;
  }
  return int64_t{0};
}
inline void ExpandAttrValue::_internal_set_int64_value(int64_t value) {
  if (!_internal_has_int64_value()) {
    clear_attr_value();
    set_has_int64_value();
  }
  _impl_.attr_value_.int64_value_ = value;
}
inline int64_t ExpandAttrValue::int64_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int64_value)
  return _internal_int64_value();
}
inline void ExpandAttrValue::set_int64_value(int64_t value) {
  _internal_set_int64_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.int64_value)
}

// float float_value = 4;
inline bool ExpandAttrValue::_internal_has_float_value() const {
  return attr_value_case() == kFloatValue;
}
inline bool ExpandAttrValue::has_float_value() const {
  return _internal_has_float_value();
}
inline void ExpandAttrValue::set_has_float_value() {
  _impl_._oneof_case_[0] = kFloatValue;
}
inline void ExpandAttrValue::clear_float_value() {
  if (_internal_has_float_value()) {
    _impl_.attr_value_.float_value_ = 0;
    clear_has_attr_value();
  }
}
inline float ExpandAttrValue::_internal_float_value() const {
  if (_internal_has_float_value()) {
    return _impl_.attr_value_.float_value_;
  }
  return 0;
}
inline void ExpandAttrValue::_internal_set_float_value(float value) {
  if (!_internal_has_float_value()) {
    clear_attr_value();
    set_has_float_value();
  }
  _impl_.attr_value_.float_value_ = value;
}
inline float ExpandAttrValue::float_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.float_value)
  return _internal_float_value();
}
inline void ExpandAttrValue::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.float_value)
}

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

// bytes bytes_value = 6;
inline bool ExpandAttrValue::_internal_has_bytes_value() const {
  return attr_value_case() == kBytesValue;
}
inline bool ExpandAttrValue::has_bytes_value() const {
  return _internal_has_bytes_value();
}
inline void ExpandAttrValue::set_has_bytes_value() {
  _impl_._oneof_case_[0] = kBytesValue;
}
inline void ExpandAttrValue::clear_bytes_value() {
  if (_internal_has_bytes_value()) {
    _impl_.attr_value_.bytes_value_.Destroy();
    clear_has_attr_value();
  }
}
inline const std::string& ExpandAttrValue::bytes_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.bytes_value)
  return _internal_bytes_value();
}
template <typename ArgT0, typename... ArgT>
inline void ExpandAttrValue::set_bytes_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  _impl_.attr_value_.bytes_value_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.ExpandAttrValue.bytes_value)
}
inline std::string* ExpandAttrValue::mutable_bytes_value() {
  std::string* _s = _internal_mutable_bytes_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.bytes_value)
  return _s;
}
inline const std::string& ExpandAttrValue::_internal_bytes_value() const {
  if (_internal_has_bytes_value()) {
    return _impl_.attr_value_.bytes_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void ExpandAttrValue::_internal_set_bytes_value(const std::string& value) {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  _impl_.attr_value_.bytes_value_.Set(value, GetArenaForAllocation());
}
inline std::string* ExpandAttrValue::_internal_mutable_bytes_value() {
  if (!_internal_has_bytes_value()) {
    clear_attr_value();
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitDefault();
  }
  return _impl_.attr_value_.bytes_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* ExpandAttrValue::release_bytes_value() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.bytes_value)
  if (_internal_has_bytes_value()) {
    clear_has_attr_value();
    return _impl_.attr_value_.bytes_value_.Release();
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::set_allocated_bytes_value(std::string* bytes_value) {
  if (has_attr_value()) {
    clear_attr_value();
  }
  if (bytes_value != nullptr) {
    set_has_bytes_value();
    _impl_.attr_value_.bytes_value_.InitAllocated(bytes_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:serial_v1.ExpandAttrValue.bytes_value)
}

// .serial_v1.ExpandAttrValue.BoolVec bool_vec = 11;
inline bool ExpandAttrValue::_internal_has_bool_vec() const {
  return attr_value_case() == kBoolVec;
}
inline bool ExpandAttrValue::has_bool_vec() const {
  return _internal_has_bool_vec();
}
inline void ExpandAttrValue::set_has_bool_vec() {
  _impl_._oneof_case_[0] = kBoolVec;
}
inline void ExpandAttrValue::clear_bool_vec() {
  if (_internal_has_bool_vec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.bool_vec_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_BoolVec* ExpandAttrValue::release_bool_vec() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.bool_vec)
  if (_internal_has_bool_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BoolVec* temp = _impl_.attr_value_.bool_vec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.bool_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_BoolVec& ExpandAttrValue::_internal_bool_vec() const {
  return _internal_has_bool_vec()
      ? *_impl_.attr_value_.bool_vec_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_BoolVec&>(::serial_v1::_ExpandAttrValue_BoolVec_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_BoolVec& ExpandAttrValue::bool_vec() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.bool_vec)
  return _internal_bool_vec();
}
inline ::serial_v1::ExpandAttrValue_BoolVec* ExpandAttrValue::unsafe_arena_release_bool_vec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.bool_vec)
  if (_internal_has_bool_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BoolVec* temp = _impl_.attr_value_.bool_vec_;
    _impl_.attr_value_.bool_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_bool_vec(::serial_v1::ExpandAttrValue_BoolVec* bool_vec) {
  clear_attr_value();
  if (bool_vec) {
    set_has_bool_vec();
    _impl_.attr_value_.bool_vec_ = bool_vec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.bool_vec)
}
inline ::serial_v1::ExpandAttrValue_BoolVec* ExpandAttrValue::_internal_mutable_bool_vec() {
  if (!_internal_has_bool_vec()) {
    clear_attr_value();
    set_has_bool_vec();
    _impl_.attr_value_.bool_vec_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_BoolVec >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.bool_vec_;
}
inline ::serial_v1::ExpandAttrValue_BoolVec* ExpandAttrValue::mutable_bool_vec() {
  ::serial_v1::ExpandAttrValue_BoolVec* _msg = _internal_mutable_bool_vec();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.bool_vec)
  return _msg;
}

// .serial_v1.ExpandAttrValue.Int32Vec int32_vec = 12;
inline bool ExpandAttrValue::_internal_has_int32_vec() const {
  return attr_value_case() == kInt32Vec;
}
inline bool ExpandAttrValue::has_int32_vec() const {
  return _internal_has_int32_vec();
}
inline void ExpandAttrValue::set_has_int32_vec() {
  _impl_._oneof_case_[0] = kInt32Vec;
}
inline void ExpandAttrValue::clear_int32_vec() {
  if (_internal_has_int32_vec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.int32_vec_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_Int32Vec* ExpandAttrValue::release_int32_vec() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.int32_vec)
  if (_internal_has_int32_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int32Vec* temp = _impl_.attr_value_.int32_vec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.int32_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_Int32Vec& ExpandAttrValue::_internal_int32_vec() const {
  return _internal_has_int32_vec()
      ? *_impl_.attr_value_.int32_vec_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_Int32Vec&>(::serial_v1::_ExpandAttrValue_Int32Vec_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_Int32Vec& ExpandAttrValue::int32_vec() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int32_vec)
  return _internal_int32_vec();
}
inline ::serial_v1::ExpandAttrValue_Int32Vec* ExpandAttrValue::unsafe_arena_release_int32_vec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.int32_vec)
  if (_internal_has_int32_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int32Vec* temp = _impl_.attr_value_.int32_vec_;
    _impl_.attr_value_.int32_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_int32_vec(::serial_v1::ExpandAttrValue_Int32Vec* int32_vec) {
  clear_attr_value();
  if (int32_vec) {
    set_has_int32_vec();
    _impl_.attr_value_.int32_vec_ = int32_vec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.int32_vec)
}
inline ::serial_v1::ExpandAttrValue_Int32Vec* ExpandAttrValue::_internal_mutable_int32_vec() {
  if (!_internal_has_int32_vec()) {
    clear_attr_value();
    set_has_int32_vec();
    _impl_.attr_value_.int32_vec_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_Int32Vec >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.int32_vec_;
}
inline ::serial_v1::ExpandAttrValue_Int32Vec* ExpandAttrValue::mutable_int32_vec() {
  ::serial_v1::ExpandAttrValue_Int32Vec* _msg = _internal_mutable_int32_vec();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.int32_vec)
  return _msg;
}

// .serial_v1.ExpandAttrValue.Int64Vec int64_vec = 13;
inline bool ExpandAttrValue::_internal_has_int64_vec() const {
  return attr_value_case() == kInt64Vec;
}
inline bool ExpandAttrValue::has_int64_vec() const {
  return _internal_has_int64_vec();
}
inline void ExpandAttrValue::set_has_int64_vec() {
  _impl_._oneof_case_[0] = kInt64Vec;
}
inline void ExpandAttrValue::clear_int64_vec() {
  if (_internal_has_int64_vec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.int64_vec_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_Int64Vec* ExpandAttrValue::release_int64_vec() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.int64_vec)
  if (_internal_has_int64_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int64Vec* temp = _impl_.attr_value_.int64_vec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.int64_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_Int64Vec& ExpandAttrValue::_internal_int64_vec() const {
  return _internal_has_int64_vec()
      ? *_impl_.attr_value_.int64_vec_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_Int64Vec&>(::serial_v1::_ExpandAttrValue_Int64Vec_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_Int64Vec& ExpandAttrValue::int64_vec() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int64_vec)
  return _internal_int64_vec();
}
inline ::serial_v1::ExpandAttrValue_Int64Vec* ExpandAttrValue::unsafe_arena_release_int64_vec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.int64_vec)
  if (_internal_has_int64_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int64Vec* temp = _impl_.attr_value_.int64_vec_;
    _impl_.attr_value_.int64_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_int64_vec(::serial_v1::ExpandAttrValue_Int64Vec* int64_vec) {
  clear_attr_value();
  if (int64_vec) {
    set_has_int64_vec();
    _impl_.attr_value_.int64_vec_ = int64_vec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.int64_vec)
}
inline ::serial_v1::ExpandAttrValue_Int64Vec* ExpandAttrValue::_internal_mutable_int64_vec() {
  if (!_internal_has_int64_vec()) {
    clear_attr_value();
    set_has_int64_vec();
    _impl_.attr_value_.int64_vec_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_Int64Vec >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.int64_vec_;
}
inline ::serial_v1::ExpandAttrValue_Int64Vec* ExpandAttrValue::mutable_int64_vec() {
  ::serial_v1::ExpandAttrValue_Int64Vec* _msg = _internal_mutable_int64_vec();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.int64_vec)
  return _msg;
}

// .serial_v1.ExpandAttrValue.FloatVec float_vec = 14;
inline bool ExpandAttrValue::_internal_has_float_vec() const {
  return attr_value_case() == kFloatVec;
}
inline bool ExpandAttrValue::has_float_vec() const {
  return _internal_has_float_vec();
}
inline void ExpandAttrValue::set_has_float_vec() {
  _impl_._oneof_case_[0] = kFloatVec;
}
inline void ExpandAttrValue::clear_float_vec() {
  if (_internal_has_float_vec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.float_vec_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_FloatVec* ExpandAttrValue::release_float_vec() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.float_vec)
  if (_internal_has_float_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_FloatVec* temp = _impl_.attr_value_.float_vec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.float_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_FloatVec& ExpandAttrValue::_internal_float_vec() const {
  return _internal_has_float_vec()
      ? *_impl_.attr_value_.float_vec_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_FloatVec&>(::serial_v1::_ExpandAttrValue_FloatVec_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_FloatVec& ExpandAttrValue::float_vec() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.float_vec)
  return _internal_float_vec();
}
inline ::serial_v1::ExpandAttrValue_FloatVec* ExpandAttrValue::unsafe_arena_release_float_vec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.float_vec)
  if (_internal_has_float_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_FloatVec* temp = _impl_.attr_value_.float_vec_;
    _impl_.attr_value_.float_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_float_vec(::serial_v1::ExpandAttrValue_FloatVec* float_vec) {
  clear_attr_value();
  if (float_vec) {
    set_has_float_vec();
    _impl_.attr_value_.float_vec_ = float_vec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.float_vec)
}
inline ::serial_v1::ExpandAttrValue_FloatVec* ExpandAttrValue::_internal_mutable_float_vec() {
  if (!_internal_has_float_vec()) {
    clear_attr_value();
    set_has_float_vec();
    _impl_.attr_value_.float_vec_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_FloatVec >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.float_vec_;
}
inline ::serial_v1::ExpandAttrValue_FloatVec* ExpandAttrValue::mutable_float_vec() {
  ::serial_v1::ExpandAttrValue_FloatVec* _msg = _internal_mutable_float_vec();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.float_vec)
  return _msg;
}

// .serial_v1.ExpandAttrValue.StringVec string_vec = 15;
inline bool ExpandAttrValue::_internal_has_string_vec() const {
  return attr_value_case() == kStringVec;
}
inline bool ExpandAttrValue::has_string_vec() const {
  return _internal_has_string_vec();
}
inline void ExpandAttrValue::set_has_string_vec() {
  _impl_._oneof_case_[0] = kStringVec;
}
inline void ExpandAttrValue::clear_string_vec() {
  if (_internal_has_string_vec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.string_vec_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_StringVec* ExpandAttrValue::release_string_vec() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.string_vec)
  if (_internal_has_string_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_StringVec* temp = _impl_.attr_value_.string_vec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.string_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_StringVec& ExpandAttrValue::_internal_string_vec() const {
  return _internal_has_string_vec()
      ? *_impl_.attr_value_.string_vec_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_StringVec&>(::serial_v1::_ExpandAttrValue_StringVec_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_StringVec& ExpandAttrValue::string_vec() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.string_vec)
  return _internal_string_vec();
}
inline ::serial_v1::ExpandAttrValue_StringVec* ExpandAttrValue::unsafe_arena_release_string_vec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.string_vec)
  if (_internal_has_string_vec()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_StringVec* temp = _impl_.attr_value_.string_vec_;
    _impl_.attr_value_.string_vec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_string_vec(::serial_v1::ExpandAttrValue_StringVec* string_vec) {
  clear_attr_value();
  if (string_vec) {
    set_has_string_vec();
    _impl_.attr_value_.string_vec_ = string_vec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.string_vec)
}
inline ::serial_v1::ExpandAttrValue_StringVec* ExpandAttrValue::_internal_mutable_string_vec() {
  if (!_internal_has_string_vec()) {
    clear_attr_value();
    set_has_string_vec();
    _impl_.attr_value_.string_vec_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_StringVec >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.string_vec_;
}
inline ::serial_v1::ExpandAttrValue_StringVec* ExpandAttrValue::mutable_string_vec() {
  ::serial_v1::ExpandAttrValue_StringVec* _msg = _internal_mutable_string_vec();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.string_vec)
  return _msg;
}

// .serial_v1.ExpandAttrValue.BoolMap bool_map = 21;
inline bool ExpandAttrValue::_internal_has_bool_map() const {
  return attr_value_case() == kBoolMap;
}
inline bool ExpandAttrValue::has_bool_map() const {
  return _internal_has_bool_map();
}
inline void ExpandAttrValue::set_has_bool_map() {
  _impl_._oneof_case_[0] = kBoolMap;
}
inline void ExpandAttrValue::clear_bool_map() {
  if (_internal_has_bool_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.bool_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_BoolMap* ExpandAttrValue::release_bool_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.bool_map)
  if (_internal_has_bool_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BoolMap* temp = _impl_.attr_value_.bool_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.bool_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_BoolMap& ExpandAttrValue::_internal_bool_map() const {
  return _internal_has_bool_map()
      ? *_impl_.attr_value_.bool_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_BoolMap&>(::serial_v1::_ExpandAttrValue_BoolMap_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_BoolMap& ExpandAttrValue::bool_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.bool_map)
  return _internal_bool_map();
}
inline ::serial_v1::ExpandAttrValue_BoolMap* ExpandAttrValue::unsafe_arena_release_bool_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.bool_map)
  if (_internal_has_bool_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BoolMap* temp = _impl_.attr_value_.bool_map_;
    _impl_.attr_value_.bool_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_bool_map(::serial_v1::ExpandAttrValue_BoolMap* bool_map) {
  clear_attr_value();
  if (bool_map) {
    set_has_bool_map();
    _impl_.attr_value_.bool_map_ = bool_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.bool_map)
}
inline ::serial_v1::ExpandAttrValue_BoolMap* ExpandAttrValue::_internal_mutable_bool_map() {
  if (!_internal_has_bool_map()) {
    clear_attr_value();
    set_has_bool_map();
    _impl_.attr_value_.bool_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_BoolMap >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.bool_map_;
}
inline ::serial_v1::ExpandAttrValue_BoolMap* ExpandAttrValue::mutable_bool_map() {
  ::serial_v1::ExpandAttrValue_BoolMap* _msg = _internal_mutable_bool_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.bool_map)
  return _msg;
}

// .serial_v1.ExpandAttrValue.Int32Map int32_map = 22;
inline bool ExpandAttrValue::_internal_has_int32_map() const {
  return attr_value_case() == kInt32Map;
}
inline bool ExpandAttrValue::has_int32_map() const {
  return _internal_has_int32_map();
}
inline void ExpandAttrValue::set_has_int32_map() {
  _impl_._oneof_case_[0] = kInt32Map;
}
inline void ExpandAttrValue::clear_int32_map() {
  if (_internal_has_int32_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.int32_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_Int32Map* ExpandAttrValue::release_int32_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.int32_map)
  if (_internal_has_int32_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int32Map* temp = _impl_.attr_value_.int32_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.int32_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_Int32Map& ExpandAttrValue::_internal_int32_map() const {
  return _internal_has_int32_map()
      ? *_impl_.attr_value_.int32_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_Int32Map&>(::serial_v1::_ExpandAttrValue_Int32Map_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_Int32Map& ExpandAttrValue::int32_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int32_map)
  return _internal_int32_map();
}
inline ::serial_v1::ExpandAttrValue_Int32Map* ExpandAttrValue::unsafe_arena_release_int32_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.int32_map)
  if (_internal_has_int32_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int32Map* temp = _impl_.attr_value_.int32_map_;
    _impl_.attr_value_.int32_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_int32_map(::serial_v1::ExpandAttrValue_Int32Map* int32_map) {
  clear_attr_value();
  if (int32_map) {
    set_has_int32_map();
    _impl_.attr_value_.int32_map_ = int32_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.int32_map)
}
inline ::serial_v1::ExpandAttrValue_Int32Map* ExpandAttrValue::_internal_mutable_int32_map() {
  if (!_internal_has_int32_map()) {
    clear_attr_value();
    set_has_int32_map();
    _impl_.attr_value_.int32_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_Int32Map >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.int32_map_;
}
inline ::serial_v1::ExpandAttrValue_Int32Map* ExpandAttrValue::mutable_int32_map() {
  ::serial_v1::ExpandAttrValue_Int32Map* _msg = _internal_mutable_int32_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.int32_map)
  return _msg;
}

// .serial_v1.ExpandAttrValue.Int64Map int64_map = 23;
inline bool ExpandAttrValue::_internal_has_int64_map() const {
  return attr_value_case() == kInt64Map;
}
inline bool ExpandAttrValue::has_int64_map() const {
  return _internal_has_int64_map();
}
inline void ExpandAttrValue::set_has_int64_map() {
  _impl_._oneof_case_[0] = kInt64Map;
}
inline void ExpandAttrValue::clear_int64_map() {
  if (_internal_has_int64_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.int64_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_Int64Map* ExpandAttrValue::release_int64_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.int64_map)
  if (_internal_has_int64_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int64Map* temp = _impl_.attr_value_.int64_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.int64_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_Int64Map& ExpandAttrValue::_internal_int64_map() const {
  return _internal_has_int64_map()
      ? *_impl_.attr_value_.int64_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_Int64Map&>(::serial_v1::_ExpandAttrValue_Int64Map_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_Int64Map& ExpandAttrValue::int64_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.int64_map)
  return _internal_int64_map();
}
inline ::serial_v1::ExpandAttrValue_Int64Map* ExpandAttrValue::unsafe_arena_release_int64_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.int64_map)
  if (_internal_has_int64_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_Int64Map* temp = _impl_.attr_value_.int64_map_;
    _impl_.attr_value_.int64_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_int64_map(::serial_v1::ExpandAttrValue_Int64Map* int64_map) {
  clear_attr_value();
  if (int64_map) {
    set_has_int64_map();
    _impl_.attr_value_.int64_map_ = int64_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.int64_map)
}
inline ::serial_v1::ExpandAttrValue_Int64Map* ExpandAttrValue::_internal_mutable_int64_map() {
  if (!_internal_has_int64_map()) {
    clear_attr_value();
    set_has_int64_map();
    _impl_.attr_value_.int64_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_Int64Map >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.int64_map_;
}
inline ::serial_v1::ExpandAttrValue_Int64Map* ExpandAttrValue::mutable_int64_map() {
  ::serial_v1::ExpandAttrValue_Int64Map* _msg = _internal_mutable_int64_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.int64_map)
  return _msg;
}

// .serial_v1.ExpandAttrValue.FloatMap float_map = 24;
inline bool ExpandAttrValue::_internal_has_float_map() const {
  return attr_value_case() == kFloatMap;
}
inline bool ExpandAttrValue::has_float_map() const {
  return _internal_has_float_map();
}
inline void ExpandAttrValue::set_has_float_map() {
  _impl_._oneof_case_[0] = kFloatMap;
}
inline void ExpandAttrValue::clear_float_map() {
  if (_internal_has_float_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.float_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_FloatMap* ExpandAttrValue::release_float_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.float_map)
  if (_internal_has_float_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_FloatMap* temp = _impl_.attr_value_.float_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.float_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_FloatMap& ExpandAttrValue::_internal_float_map() const {
  return _internal_has_float_map()
      ? *_impl_.attr_value_.float_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_FloatMap&>(::serial_v1::_ExpandAttrValue_FloatMap_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_FloatMap& ExpandAttrValue::float_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.float_map)
  return _internal_float_map();
}
inline ::serial_v1::ExpandAttrValue_FloatMap* ExpandAttrValue::unsafe_arena_release_float_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.float_map)
  if (_internal_has_float_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_FloatMap* temp = _impl_.attr_value_.float_map_;
    _impl_.attr_value_.float_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_float_map(::serial_v1::ExpandAttrValue_FloatMap* float_map) {
  clear_attr_value();
  if (float_map) {
    set_has_float_map();
    _impl_.attr_value_.float_map_ = float_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.float_map)
}
inline ::serial_v1::ExpandAttrValue_FloatMap* ExpandAttrValue::_internal_mutable_float_map() {
  if (!_internal_has_float_map()) {
    clear_attr_value();
    set_has_float_map();
    _impl_.attr_value_.float_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_FloatMap >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.float_map_;
}
inline ::serial_v1::ExpandAttrValue_FloatMap* ExpandAttrValue::mutable_float_map() {
  ::serial_v1::ExpandAttrValue_FloatMap* _msg = _internal_mutable_float_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.float_map)
  return _msg;
}

// .serial_v1.ExpandAttrValue.StringMap string_map = 25;
inline bool ExpandAttrValue::_internal_has_string_map() const {
  return attr_value_case() == kStringMap;
}
inline bool ExpandAttrValue::has_string_map() const {
  return _internal_has_string_map();
}
inline void ExpandAttrValue::set_has_string_map() {
  _impl_._oneof_case_[0] = kStringMap;
}
inline void ExpandAttrValue::clear_string_map() {
  if (_internal_has_string_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.string_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_StringMap* ExpandAttrValue::release_string_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.string_map)
  if (_internal_has_string_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_StringMap* temp = _impl_.attr_value_.string_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.string_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_StringMap& ExpandAttrValue::_internal_string_map() const {
  return _internal_has_string_map()
      ? *_impl_.attr_value_.string_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_StringMap&>(::serial_v1::_ExpandAttrValue_StringMap_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_StringMap& ExpandAttrValue::string_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.string_map)
  return _internal_string_map();
}
inline ::serial_v1::ExpandAttrValue_StringMap* ExpandAttrValue::unsafe_arena_release_string_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.string_map)
  if (_internal_has_string_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_StringMap* temp = _impl_.attr_value_.string_map_;
    _impl_.attr_value_.string_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_string_map(::serial_v1::ExpandAttrValue_StringMap* string_map) {
  clear_attr_value();
  if (string_map) {
    set_has_string_map();
    _impl_.attr_value_.string_map_ = string_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.string_map)
}
inline ::serial_v1::ExpandAttrValue_StringMap* ExpandAttrValue::_internal_mutable_string_map() {
  if (!_internal_has_string_map()) {
    clear_attr_value();
    set_has_string_map();
    _impl_.attr_value_.string_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_StringMap >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.string_map_;
}
inline ::serial_v1::ExpandAttrValue_StringMap* ExpandAttrValue::mutable_string_map() {
  ::serial_v1::ExpandAttrValue_StringMap* _msg = _internal_mutable_string_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.string_map)
  return _msg;
}

// .serial_v1.ExpandAttrValue.BytesMap bytes_map = 26;
inline bool ExpandAttrValue::_internal_has_bytes_map() const {
  return attr_value_case() == kBytesMap;
}
inline bool ExpandAttrValue::has_bytes_map() const {
  return _internal_has_bytes_map();
}
inline void ExpandAttrValue::set_has_bytes_map() {
  _impl_._oneof_case_[0] = kBytesMap;
}
inline void ExpandAttrValue::clear_bytes_map() {
  if (_internal_has_bytes_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.attr_value_.bytes_map_;
    }
    clear_has_attr_value();
  }
}
inline ::serial_v1::ExpandAttrValue_BytesMap* ExpandAttrValue::release_bytes_map() {
  // @@protoc_insertion_point(field_release:serial_v1.ExpandAttrValue.bytes_map)
  if (_internal_has_bytes_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BytesMap* temp = _impl_.attr_value_.bytes_map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.attr_value_.bytes_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::serial_v1::ExpandAttrValue_BytesMap& ExpandAttrValue::_internal_bytes_map() const {
  return _internal_has_bytes_map()
      ? *_impl_.attr_value_.bytes_map_
      : reinterpret_cast< ::serial_v1::ExpandAttrValue_BytesMap&>(::serial_v1::_ExpandAttrValue_BytesMap_default_instance_);
}
inline const ::serial_v1::ExpandAttrValue_BytesMap& ExpandAttrValue::bytes_map() const {
  // @@protoc_insertion_point(field_get:serial_v1.ExpandAttrValue.bytes_map)
  return _internal_bytes_map();
}
inline ::serial_v1::ExpandAttrValue_BytesMap* ExpandAttrValue::unsafe_arena_release_bytes_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:serial_v1.ExpandAttrValue.bytes_map)
  if (_internal_has_bytes_map()) {
    clear_has_attr_value();
    ::serial_v1::ExpandAttrValue_BytesMap* temp = _impl_.attr_value_.bytes_map_;
    _impl_.attr_value_.bytes_map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExpandAttrValue::unsafe_arena_set_allocated_bytes_map(::serial_v1::ExpandAttrValue_BytesMap* bytes_map) {
  clear_attr_value();
  if (bytes_map) {
    set_has_bytes_map();
    _impl_.attr_value_.bytes_map_ = bytes_map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:serial_v1.ExpandAttrValue.bytes_map)
}
inline ::serial_v1::ExpandAttrValue_BytesMap* ExpandAttrValue::_internal_mutable_bytes_map() {
  if (!_internal_has_bytes_map()) {
    clear_attr_value();
    set_has_bytes_map();
    _impl_.attr_value_.bytes_map_ = CreateMaybeMessage< ::serial_v1::ExpandAttrValue_BytesMap >(GetArenaForAllocation());
  }
  return _impl_.attr_value_.bytes_map_;
}
inline ::serial_v1::ExpandAttrValue_BytesMap* ExpandAttrValue::mutable_bytes_map() {
  ::serial_v1::ExpandAttrValue_BytesMap* _msg = _internal_mutable_bytes_map();
  // @@protoc_insertion_point(field_mutable:serial_v1.ExpandAttrValue.bytes_map)
  return _msg;
}

inline bool ExpandAttrValue::has_attr_value() const {
  return attr_value_case() != ATTR_VALUE_NOT_SET;
}
inline void ExpandAttrValue::clear_has_attr_value() {
  _impl_._oneof_case_[0] = ATTR_VALUE_NOT_SET;
}
inline ExpandAttrValue::AttrValueCase ExpandAttrValue::attr_value_case() const {
  return ExpandAttrValue::AttrValueCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// OneKindOP

// string op_type = 1;
inline void OneKindOP::clear_op_type() {
  _impl_.op_type_.ClearToEmpty();
}
inline const std::string& OneKindOP::op_type() const {
  // @@protoc_insertion_point(field_get:serial_v1.OneKindOP.op_type)
  return _internal_op_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OneKindOP::set_op_type(ArgT0&& arg0, ArgT... args) {
 
 _impl_.op_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:serial_v1.OneKindOP.op_type)
}
inline std::string* OneKindOP::mutable_op_type() {
  std::string* _s = _internal_mutable_op_type();
  // @@protoc_insertion_point(field_mutable:serial_v1.OneKindOP.op_type)
  return _s;
}
inline const std::string& OneKindOP::_internal_op_type() const {
  return _impl_.op_type_.Get();
}
inline void OneKindOP::_internal_set_op_type(const std::string& value) {
  
  _impl_.op_type_.Set(value, GetArenaForAllocation());
}
inline std::string* OneKindOP::_internal_mutable_op_type() {
  
  return _impl_.op_type_.Mutable(GetArenaForAllocation());
}
inline std::string* OneKindOP::release_op_type() {
  // @@protoc_insertion_point(field_release:serial_v1.OneKindOP.op_type)
  return _impl_.op_type_.Release();
}
inline void OneKindOP::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_v1.OneKindOP.op_type)
}

// repeated string op_name = 2;
inline int OneKindOP::_internal_op_name_size() const {
  return _impl_.op_name_.size();
}
inline int OneKindOP::op_name_size() const {
  return _internal_op_name_size();
}
inline void OneKindOP::clear_op_name() {
  _impl_.op_name_.Clear();
}
inline std::string* OneKindOP::add_op_name() {
  std::string* _s = _internal_add_op_name();
  // @@protoc_insertion_point(field_add_mutable:serial_v1.OneKindOP.op_name)
  return _s;
}
inline const std::string& OneKindOP::_internal_op_name(int index) const {
  return _impl_.op_name_.Get(index);
}
inline const std::string& OneKindOP::op_name(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OneKindOP.op_name)
  return _internal_op_name(index);
}
inline std::string* OneKindOP::mutable_op_name(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OneKindOP.op_name)
  return _impl_.op_name_.Mutable(index);
}
inline void OneKindOP::set_op_name(int index, const std::string& value) {
  _impl_.op_name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:serial_v1.OneKindOP.op_name)
}
inline void OneKindOP::set_op_name(int index, std::string&& value) {
  _impl_.op_name_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:serial_v1.OneKindOP.op_name)
}
inline void OneKindOP::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_v1.OneKindOP.op_name)
}
inline void OneKindOP::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_v1.OneKindOP.op_name)
}
inline std::string* OneKindOP::_internal_add_op_name() {
  return _impl_.op_name_.Add();
}
inline void OneKindOP::add_op_name(const std::string& value) {
  _impl_.op_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:serial_v1.OneKindOP.op_name)
}
inline void OneKindOP::add_op_name(std::string&& value) {
  _impl_.op_name_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:serial_v1.OneKindOP.op_name)
}
inline void OneKindOP::add_op_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.op_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:serial_v1.OneKindOP.op_name)
}
inline void OneKindOP::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_v1.OneKindOP.op_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
OneKindOP::op_name() const {
  // @@protoc_insertion_point(field_list:serial_v1.OneKindOP.op_name)
  return _impl_.op_name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
OneKindOP::mutable_op_name() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OneKindOP.op_name)
  return &_impl_.op_name_;
}

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

// 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_v1.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_v1.Tensor.tensor_name)
}
inline std::string* Tensor::mutable_tensor_name() {
  std::string* _s = _internal_mutable_tensor_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.Tensor.data_type)
}

// repeated .serial_v1.ExpandAttrValue 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 ::serial_v1::ExpandAttrValue* Tensor::mutable_tensor_attr(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.Tensor.tensor_attr)
  return _impl_.tensor_attr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
Tensor::mutable_tensor_attr() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.Tensor.tensor_attr)
  return &_impl_.tensor_attr_;
}
inline const ::serial_v1::ExpandAttrValue& Tensor::_internal_tensor_attr(int index) const {
  return _impl_.tensor_attr_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue& Tensor::tensor_attr(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.Tensor.tensor_attr)
  return _internal_tensor_attr(index);
}
inline ::serial_v1::ExpandAttrValue* Tensor::_internal_add_tensor_attr() {
  return _impl_.tensor_attr_.Add();
}
inline ::serial_v1::ExpandAttrValue* Tensor::add_tensor_attr() {
  ::serial_v1::ExpandAttrValue* _add = _internal_add_tensor_attr();
  // @@protoc_insertion_point(field_add:serial_v1.Tensor.tensor_attr)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
Tensor::tensor_attr() const {
  // @@protoc_insertion_point(field_list:serial_v1.Tensor.tensor_attr)
  return _impl_.tensor_attr_;
}

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

// 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_v1.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_v1.OPNode.op_name)
}
inline std::string* OPNode::mutable_op_name() {
  std::string* _s = _internal_mutable_op_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.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_v1.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_v1.OPNode.op_type)
}
inline std::string* OPNode::mutable_op_type() {
  std::string* _s = _internal_mutable_op_type();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.OPNode.op_type)
}

// repeated .serial_v1.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 ::serial_v1::AttrValue* OPNode::mutable_op_attr(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OPNode.op_attr)
  return _impl_.op_attr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue >*
OPNode::mutable_op_attr() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OPNode.op_attr)
  return &_impl_.op_attr_;
}
inline const ::serial_v1::AttrValue& OPNode::_internal_op_attr(int index) const {
  return _impl_.op_attr_.Get(index);
}
inline const ::serial_v1::AttrValue& OPNode::op_attr(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OPNode.op_attr)
  return _internal_op_attr(index);
}
inline ::serial_v1::AttrValue* OPNode::_internal_add_op_attr() {
  return _impl_.op_attr_.Add();
}
inline ::serial_v1::AttrValue* OPNode::add_op_attr() {
  ::serial_v1::AttrValue* _add = _internal_add_op_attr();
  // @@protoc_insertion_point(field_add:serial_v1.OPNode.op_attr)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrValue >&
OPNode::op_attr() const {
  // @@protoc_insertion_point(field_list:serial_v1.OPNode.op_attr)
  return _impl_.op_attr_;
}

// repeated .serial_v1.ExpandAttrValue expand_op_attr = 8;
inline int OPNode::_internal_expand_op_attr_size() const {
  return _impl_.expand_op_attr_.size();
}
inline int OPNode::expand_op_attr_size() const {
  return _internal_expand_op_attr_size();
}
inline void OPNode::clear_expand_op_attr() {
  _impl_.expand_op_attr_.Clear();
}
inline ::serial_v1::ExpandAttrValue* OPNode::mutable_expand_op_attr(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OPNode.expand_op_attr)
  return _impl_.expand_op_attr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
OPNode::mutable_expand_op_attr() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OPNode.expand_op_attr)
  return &_impl_.expand_op_attr_;
}
inline const ::serial_v1::ExpandAttrValue& OPNode::_internal_expand_op_attr(int index) const {
  return _impl_.expand_op_attr_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue& OPNode::expand_op_attr(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OPNode.expand_op_attr)
  return _internal_expand_op_attr(index);
}
inline ::serial_v1::ExpandAttrValue* OPNode::_internal_add_expand_op_attr() {
  return _impl_.expand_op_attr_.Add();
}
inline ::serial_v1::ExpandAttrValue* OPNode::add_expand_op_attr() {
  ::serial_v1::ExpandAttrValue* _add = _internal_add_expand_op_attr();
  // @@protoc_insertion_point(field_add:serial_v1.OPNode.expand_op_attr)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
OPNode::expand_op_attr() const {
  // @@protoc_insertion_point(field_list:serial_v1.OPNode.expand_op_attr)
  return _impl_.expand_op_attr_;
}

// repeated .serial_v1.OneKindOP input_op = 4;
inline int OPNode::_internal_input_op_size() const {
  return _impl_.input_op_.size();
}
inline int OPNode::input_op_size() const {
  return _internal_input_op_size();
}
inline void OPNode::clear_input_op() {
  _impl_.input_op_.Clear();
}
inline ::serial_v1::OneKindOP* OPNode::mutable_input_op(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OPNode.input_op)
  return _impl_.input_op_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OneKindOP >*
OPNode::mutable_input_op() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OPNode.input_op)
  return &_impl_.input_op_;
}
inline const ::serial_v1::OneKindOP& OPNode::_internal_input_op(int index) const {
  return _impl_.input_op_.Get(index);
}
inline const ::serial_v1::OneKindOP& OPNode::input_op(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OPNode.input_op)
  return _internal_input_op(index);
}
inline ::serial_v1::OneKindOP* OPNode::_internal_add_input_op() {
  return _impl_.input_op_.Add();
}
inline ::serial_v1::OneKindOP* OPNode::add_input_op() {
  ::serial_v1::OneKindOP* _add = _internal_add_input_op();
  // @@protoc_insertion_point(field_add:serial_v1.OPNode.input_op)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OneKindOP >&
OPNode::input_op() const {
  // @@protoc_insertion_point(field_list:serial_v1.OPNode.input_op)
  return _impl_.input_op_;
}

// .serial_v1.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_v1::Tensor& OPNode::_internal_output_tensor() const {
  const ::serial_v1::Tensor* p = _impl_.output_tensor_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v1::Tensor&>(
      ::serial_v1::_Tensor_default_instance_);
}
inline const ::serial_v1::Tensor& OPNode::output_tensor() const {
  // @@protoc_insertion_point(field_get:serial_v1.OPNode.output_tensor)
  return _internal_output_tensor();
}
inline void OPNode::unsafe_arena_set_allocated_output_tensor(
    ::serial_v1::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_v1.OPNode.output_tensor)
}
inline ::serial_v1::Tensor* OPNode::release_output_tensor() {
  
  ::serial_v1::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_v1::Tensor* OPNode::unsafe_arena_release_output_tensor() {
  // @@protoc_insertion_point(field_release:serial_v1.OPNode.output_tensor)
  
  ::serial_v1::Tensor* temp = _impl_.output_tensor_;
  _impl_.output_tensor_ = nullptr;
  return temp;
}
inline ::serial_v1::Tensor* OPNode::_internal_mutable_output_tensor() {
  
  if (_impl_.output_tensor_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v1::Tensor>(GetArenaForAllocation());
    _impl_.output_tensor_ = p;
  }
  return _impl_.output_tensor_;
}
inline ::serial_v1::Tensor* OPNode::mutable_output_tensor() {
  ::serial_v1::Tensor* _msg = _internal_mutable_output_tensor();
  // @@protoc_insertion_point(field_mutable:serial_v1.OPNode.output_tensor)
  return _msg;
}
inline void OPNode::set_allocated_output_tensor(::serial_v1::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_v1.OPNode.output_tensor)
}

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

// 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_v1.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_v1.SubGraph.subgraph_name)
}
inline std::string* SubGraph::mutable_subgraph_name() {
  std::string* _s = _internal_mutable_subgraph_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.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_v1.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_v1.SubGraph.op_name)
  return _internal_op_name(index);
}
inline std::string* SubGraph::mutable_op_name(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.SubGraph.op_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SubGraph::op_name() const {
  // @@protoc_insertion_point(field_list:serial_v1.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_v1.SubGraph.op_name)
  return &_impl_.op_name_;
}

// repeated .serial_v1.ExpandAttrValue 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 ::serial_v1::ExpandAttrValue* SubGraph::mutable_subg_attr(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.SubGraph.subg_attr)
  return _impl_.subg_attr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >*
SubGraph::mutable_subg_attr() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.SubGraph.subg_attr)
  return &_impl_.subg_attr_;
}
inline const ::serial_v1::ExpandAttrValue& SubGraph::_internal_subg_attr(int index) const {
  return _impl_.subg_attr_.Get(index);
}
inline const ::serial_v1::ExpandAttrValue& SubGraph::subg_attr(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.SubGraph.subg_attr)
  return _internal_subg_attr(index);
}
inline ::serial_v1::ExpandAttrValue* SubGraph::_internal_add_subg_attr() {
  return _impl_.subg_attr_.Add();
}
inline ::serial_v1::ExpandAttrValue* SubGraph::add_subg_attr() {
  ::serial_v1::ExpandAttrValue* _add = _internal_add_subg_attr();
  // @@protoc_insertion_point(field_add:serial_v1.SubGraph.subg_attr)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::ExpandAttrValue >&
SubGraph::subg_attr() const {
  // @@protoc_insertion_point(field_list:serial_v1.SubGraph.subg_attr)
  return _impl_.subg_attr_;
}

// repeated .serial_v1.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_v1::SubGraph* SubGraph::mutable_subg_child(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.SubGraph.subg_child)
  return _impl_.subg_child_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::SubGraph >*
SubGraph::mutable_subg_child() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.SubGraph.subg_child)
  return &_impl_.subg_child_;
}
inline const ::serial_v1::SubGraph& SubGraph::_internal_subg_child(int index) const {
  return _impl_.subg_child_.Get(index);
}
inline const ::serial_v1::SubGraph& SubGraph::subg_child(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.SubGraph.subg_child)
  return _internal_subg_child(index);
}
inline ::serial_v1::SubGraph* SubGraph::_internal_add_subg_child() {
  return _impl_.subg_child_.Add();
}
inline ::serial_v1::SubGraph* SubGraph::add_subg_child() {
  ::serial_v1::SubGraph* _add = _internal_add_subg_child();
  // @@protoc_insertion_point(field_add:serial_v1.SubGraph.subg_child)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::SubGraph >&
SubGraph::subg_child() const {
  // @@protoc_insertion_point(field_list:serial_v1.SubGraph.subg_child)
  return _impl_.subg_child_;
}

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

// 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_v1.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_v1.Graph.graph_name)
}
inline std::string* Graph::mutable_graph_name() {
  std::string* _s = _internal_mutable_graph_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.Graph.graph_name)
}

// repeated .serial_v1.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_v1::OPNode* Graph::mutable_op_node(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.Graph.op_node)
  return _impl_.op_node_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OPNode >*
Graph::mutable_op_node() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.Graph.op_node)
  return &_impl_.op_node_;
}
inline const ::serial_v1::OPNode& Graph::_internal_op_node(int index) const {
  return _impl_.op_node_.Get(index);
}
inline const ::serial_v1::OPNode& Graph::op_node(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.Graph.op_node)
  return _internal_op_node(index);
}
inline ::serial_v1::OPNode* Graph::_internal_add_op_node() {
  return _impl_.op_node_.Add();
}
inline ::serial_v1::OPNode* Graph::add_op_node() {
  ::serial_v1::OPNode* _add = _internal_add_op_node();
  // @@protoc_insertion_point(field_add:serial_v1.Graph.op_node)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OPNode >&
Graph::op_node() const {
  // @@protoc_insertion_point(field_list:serial_v1.Graph.op_node)
  return _impl_.op_node_;
}

// .serial_v1.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_v1::SubGraph& Graph::_internal_subg_root() const {
  const ::serial_v1::SubGraph* p = _impl_.subg_root_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v1::SubGraph&>(
      ::serial_v1::_SubGraph_default_instance_);
}
inline const ::serial_v1::SubGraph& Graph::subg_root() const {
  // @@protoc_insertion_point(field_get:serial_v1.Graph.subg_root)
  return _internal_subg_root();
}
inline void Graph::unsafe_arena_set_allocated_subg_root(
    ::serial_v1::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_v1.Graph.subg_root)
}
inline ::serial_v1::SubGraph* Graph::release_subg_root() {
  
  ::serial_v1::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_v1::SubGraph* Graph::unsafe_arena_release_subg_root() {
  // @@protoc_insertion_point(field_release:serial_v1.Graph.subg_root)
  
  ::serial_v1::SubGraph* temp = _impl_.subg_root_;
  _impl_.subg_root_ = nullptr;
  return temp;
}
inline ::serial_v1::SubGraph* Graph::_internal_mutable_subg_root() {
  
  if (_impl_.subg_root_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v1::SubGraph>(GetArenaForAllocation());
    _impl_.subg_root_ = p;
  }
  return _impl_.subg_root_;
}
inline ::serial_v1::SubGraph* Graph::mutable_subg_root() {
  ::serial_v1::SubGraph* _msg = _internal_mutable_subg_root();
  // @@protoc_insertion_point(field_mutable:serial_v1.Graph.subg_root)
  return _msg;
}
inline void Graph::set_allocated_subg_root(::serial_v1::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_v1.Graph.subg_root)
}

// repeated .serial_v1.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_v1::OpDef* Graph::mutable_op_defs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.Graph.op_defs)
  return _impl_.op_defs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpDef >*
Graph::mutable_op_defs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.Graph.op_defs)
  return &_impl_.op_defs_;
}
inline const ::serial_v1::OpDef& Graph::_internal_op_defs(int index) const {
  return _impl_.op_defs_.Get(index);
}
inline const ::serial_v1::OpDef& Graph::op_defs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.Graph.op_defs)
  return _internal_op_defs(index);
}
inline ::serial_v1::OpDef* Graph::_internal_add_op_defs() {
  return _impl_.op_defs_.Add();
}
inline ::serial_v1::OpDef* Graph::add_op_defs() {
  ::serial_v1::OpDef* _add = _internal_add_op_defs();
  // @@protoc_insertion_point(field_add:serial_v1.Graph.op_defs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpDef >&
Graph::op_defs() const {
  // @@protoc_insertion_point(field_list:serial_v1.Graph.op_defs)
  return _impl_.op_defs_;
}

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

// 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_v1.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_v1.AttrDef.name)
}
inline std::string* AttrDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.AttrDef.name)
}

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

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

// .serial_v1.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_v1::AttrValue& AttrDef::_internal_default_value() const {
  const ::serial_v1::AttrValue* p = _impl_.default_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::serial_v1::AttrValue&>(
      ::serial_v1::_AttrValue_default_instance_);
}
inline const ::serial_v1::AttrValue& AttrDef::default_value() const {
  // @@protoc_insertion_point(field_get:serial_v1.AttrDef.default_value)
  return _internal_default_value();
}
inline void AttrDef::unsafe_arena_set_allocated_default_value(
    ::serial_v1::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_v1.AttrDef.default_value)
}
inline ::serial_v1::AttrValue* AttrDef::release_default_value() {
  
  ::serial_v1::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_v1::AttrValue* AttrDef::unsafe_arena_release_default_value() {
  // @@protoc_insertion_point(field_release:serial_v1.AttrDef.default_value)
  
  ::serial_v1::AttrValue* temp = _impl_.default_value_;
  _impl_.default_value_ = nullptr;
  return temp;
}
inline ::serial_v1::AttrValue* AttrDef::_internal_mutable_default_value() {
  
  if (_impl_.default_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::serial_v1::AttrValue>(GetArenaForAllocation());
    _impl_.default_value_ = p;
  }
  return _impl_.default_value_;
}
inline ::serial_v1::AttrValue* AttrDef::mutable_default_value() {
  ::serial_v1::AttrValue* _msg = _internal_mutable_default_value();
  // @@protoc_insertion_point(field_mutable:serial_v1.AttrDef.default_value)
  return _msg;
}
inline void AttrDef::set_allocated_default_value(::serial_v1::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_v1.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_v1.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_v1.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_v1.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_v1.AttrDef.annotation)
}
inline std::string* AttrDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.AttrDef.annotation)
}

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

// 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_v1.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_v1.OpDef.name)
}
inline std::string* OpDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.OpDef.name)
}

// repeated .serial_v1.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_v1::OpArgDef* OpDef::mutable_input_args(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OpDef.input_args)
  return _impl_.input_args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpArgDef >*
OpDef::mutable_input_args() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OpDef.input_args)
  return &_impl_.input_args_;
}
inline const ::serial_v1::OpArgDef& OpDef::_internal_input_args(int index) const {
  return _impl_.input_args_.Get(index);
}
inline const ::serial_v1::OpArgDef& OpDef::input_args(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OpDef.input_args)
  return _internal_input_args(index);
}
inline ::serial_v1::OpArgDef* OpDef::_internal_add_input_args() {
  return _impl_.input_args_.Add();
}
inline ::serial_v1::OpArgDef* OpDef::add_input_args() {
  ::serial_v1::OpArgDef* _add = _internal_add_input_args();
  // @@protoc_insertion_point(field_add:serial_v1.OpDef.input_args)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::OpArgDef >&
OpDef::input_args() const {
  // @@protoc_insertion_point(field_list:serial_v1.OpDef.input_args)
  return _impl_.input_args_;
}

// repeated .serial_v1.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_v1::AttrDef* OpDef::mutable_attrs(int index) {
  // @@protoc_insertion_point(field_mutable:serial_v1.OpDef.attrs)
  return _impl_.attrs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrDef >*
OpDef::mutable_attrs() {
  // @@protoc_insertion_point(field_mutable_list:serial_v1.OpDef.attrs)
  return &_impl_.attrs_;
}
inline const ::serial_v1::AttrDef& OpDef::_internal_attrs(int index) const {
  return _impl_.attrs_.Get(index);
}
inline const ::serial_v1::AttrDef& OpDef::attrs(int index) const {
  // @@protoc_insertion_point(field_get:serial_v1.OpDef.attrs)
  return _internal_attrs(index);
}
inline ::serial_v1::AttrDef* OpDef::_internal_add_attrs() {
  return _impl_.attrs_.Add();
}
inline ::serial_v1::AttrDef* OpDef::add_attrs() {
  ::serial_v1::AttrDef* _add = _internal_add_attrs();
  // @@protoc_insertion_point(field_add:serial_v1.OpDef.attrs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::serial_v1::AttrDef >&
OpDef::attrs() const {
  // @@protoc_insertion_point(field_list:serial_v1.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_v1.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_v1.OpDef.annotation)
}
inline std::string* OpDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.OpDef.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_v1.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_v1.OpArgDef.name)
}
inline std::string* OpArgDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.OpArgDef.name)
}

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

// .serial_v1.OpArgDef.DataType data_type = 3;
inline void OpArgDef::clear_data_type() {
  _impl_.data_type_ = 0;
}
inline ::serial_v1::OpArgDef_DataType OpArgDef::_internal_data_type() const {
  return static_cast< ::serial_v1::OpArgDef_DataType >(_impl_.data_type_);
}
inline ::serial_v1::OpArgDef_DataType OpArgDef::data_type() const {
  // @@protoc_insertion_point(field_get:serial_v1.OpArgDef.data_type)
  return _internal_data_type();
}
inline void OpArgDef::_internal_set_data_type(::serial_v1::OpArgDef_DataType value) {
  
  _impl_.data_type_ = value;
}
inline void OpArgDef::set_data_type(::serial_v1::OpArgDef_DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:serial_v1.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_v1.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_v1.OpArgDef.annotation)
}
inline std::string* OpArgDef::mutable_annotation() {
  std::string* _s = _internal_mutable_annotation();
  // @@protoc_insertion_point(field_mutable:serial_v1.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_v1.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_v1.OpArgDef.annotation)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace serial_v1

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::serial_v1::AttrDef_OccurType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::serial_v1::AttrDef_OccurType>() {
  return ::serial_v1::AttrDef_OccurType_descriptor();
}
template <> struct is_proto_enum< ::serial_v1::OpArgDef_OccurType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::serial_v1::OpArgDef_OccurType>() {
  return ::serial_v1::OpArgDef_OccurType_descriptor();
}
template <> struct is_proto_enum< ::serial_v1::OpArgDef_DataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::serial_v1::OpArgDef_DataType>() {
  return ::serial_v1::OpArgDef_DataType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_graph_5fproto_5fv1_2eproto
