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

#ifndef GOOGLE_PROTOBUF_INCLUDED_SymbolicExpression_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_SymbolicExpression_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#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 3015005 < 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_table_driven.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_SymbolicExpression_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_SymbolicExpression_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_SymbolicExpression_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_SymbolicExpression_2eproto_metadata_getter(int index);
namespace gtirb {
namespace proto {
class SymAddrAddr;
struct SymAddrAddrDefaultTypeInternal;
extern SymAddrAddrDefaultTypeInternal _SymAddrAddr_default_instance_;
class SymAddrConst;
struct SymAddrConstDefaultTypeInternal;
extern SymAddrConstDefaultTypeInternal _SymAddrConst_default_instance_;
class SymStackConst;
struct SymStackConstDefaultTypeInternal;
extern SymStackConstDefaultTypeInternal _SymStackConst_default_instance_;
class SymbolicExpression;
struct SymbolicExpressionDefaultTypeInternal;
extern SymbolicExpressionDefaultTypeInternal _SymbolicExpression_default_instance_;
}  // namespace proto
}  // namespace gtirb
PROTOBUF_NAMESPACE_OPEN
template<> ::gtirb::proto::SymAddrAddr* Arena::CreateMaybeMessage<::gtirb::proto::SymAddrAddr>(Arena*);
template<> ::gtirb::proto::SymAddrConst* Arena::CreateMaybeMessage<::gtirb::proto::SymAddrConst>(Arena*);
template<> ::gtirb::proto::SymStackConst* Arena::CreateMaybeMessage<::gtirb::proto::SymStackConst>(Arena*);
template<> ::gtirb::proto::SymbolicExpression* Arena::CreateMaybeMessage<::gtirb::proto::SymbolicExpression>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace gtirb {
namespace proto {

enum SymAttribute : int {
  GOT = 0,
  GOTPC = 1,
  GOTOFF = 2,
  GOTREL = 3,
  PLT = 4,
  PLTOFF = 5,
  PCREL = 6,
  SECREL = 7,
  TLS = 8,
  TLSGD = 9,
  TLSLD = 10,
  TLSLDM = 11,
  TLSCALL = 12,
  TLSDESC = 13,
  TPREL = 14,
  TPOFF = 15,
  DTPREL = 16,
  DTPOFF = 17,
  NTPOFF = 18,
  DTPMOD = 19,
  PAGE = 20,
  PAGEOFF = 21,
  CALL = 22,
  LO = 23,
  HI = 24,
  HIGHER = 25,
  HIGHEST = 26,
  GOTNTPOFF = 1000,
  INDNTPOFF = 1001,
  G0 = 2001,
  G1 = 2002,
  G2 = 2003,
  G3 = 2004,
  UPPER16 = 2005,
  LOWER16 = 2006,
  LO12 = 2007,
  LO15 = 2008,
  LO14 = 2009,
  HI12 = 2010,
  HI21 = 2011,
  S = 2012,
  PG = 2013,
  NC = 2014,
  ABS = 2015,
  PREL = 2016,
  PREL31 = 2017,
  TARGET1 = 2018,
  TARGET2 = 2019,
  SBREL = 2020,
  TLSLDO = 2021,
  HI16 = 3000,
  LO16 = 3001,
  GPREL = 3002,
  DISP = 3003,
  OFST = 3004,
  H = 4000,
  L = 4001,
  HA = 4002,
  HIGH = 4003,
  HIGHA = 4004,
  HIGHERA = 4005,
  HIGHESTA = 4006,
  TOCBASE = 4007,
  TOC = 4008,
  NOTOC = 4009,
  SymAttribute_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  SymAttribute_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SymAttribute_IsValid(int value);
constexpr SymAttribute SymAttribute_MIN = GOT;
constexpr SymAttribute SymAttribute_MAX = NOTOC;
constexpr int SymAttribute_ARRAYSIZE = SymAttribute_MAX + 1;

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

class SymStackConst PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.SymStackConst) */ {
 public:
  inline SymStackConst() : SymStackConst(nullptr) {}
  virtual ~SymStackConst();
  explicit constexpr SymStackConst(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SymStackConst& operator=(const SymStackConst& from) {
    CopyFrom(from);
    return *this;
  }
  inline SymStackConst& operator=(SymStackConst&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SymStackConst& default_instance() {
    return *internal_default_instance();
  }
  static inline const SymStackConst* internal_default_instance() {
    return reinterpret_cast<const SymStackConst*>(
               &_SymStackConst_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(SymStackConst& a, SymStackConst& b) {
    a.Swap(&b);
  }
  inline void Swap(SymStackConst* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SymStackConst* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SymStackConst* New() const final {
    return CreateMaybeMessage<SymStackConst>(nullptr);
  }

  SymStackConst* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SymStackConst>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SymStackConst& from);
  void MergeFrom(const SymStackConst& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SymStackConst* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.SymStackConst";
  }
  protected:
  explicit SymStackConst(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_SymbolicExpression_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kSymbolUuidFieldNumber = 2,
    kOffsetFieldNumber = 1,
  };
  // bytes symbol_uuid = 2;
  void clear_symbol_uuid();
  const std::string& symbol_uuid() const;
  void set_symbol_uuid(const std::string& value);
  void set_symbol_uuid(std::string&& value);
  void set_symbol_uuid(const char* value);
  void set_symbol_uuid(const void* value, size_t size);
  std::string* mutable_symbol_uuid();
  std::string* release_symbol_uuid();
  void set_allocated_symbol_uuid(std::string* symbol_uuid);
  private:
  const std::string& _internal_symbol_uuid() const;
  void _internal_set_symbol_uuid(const std::string& value);
  std::string* _internal_mutable_symbol_uuid();
  public:

  // int32 offset = 1;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::int32 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const;
  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:gtirb.proto.SymStackConst)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_uuid_;
  ::PROTOBUF_NAMESPACE_ID::int32 offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SymbolicExpression_2eproto;
};
// -------------------------------------------------------------------

class SymAddrConst PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.SymAddrConst) */ {
 public:
  inline SymAddrConst() : SymAddrConst(nullptr) {}
  virtual ~SymAddrConst();
  explicit constexpr SymAddrConst(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SymAddrConst& operator=(const SymAddrConst& from) {
    CopyFrom(from);
    return *this;
  }
  inline SymAddrConst& operator=(SymAddrConst&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(SymAddrConst& a, SymAddrConst& b) {
    a.Swap(&b);
  }
  inline void Swap(SymAddrConst* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SymAddrConst* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SymAddrConst* New() const final {
    return CreateMaybeMessage<SymAddrConst>(nullptr);
  }

  SymAddrConst* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SymAddrConst>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SymAddrConst& from);
  void MergeFrom(const SymAddrConst& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SymAddrConst* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.SymAddrConst";
  }
  protected:
  explicit SymAddrConst(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_SymbolicExpression_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kSymbolUuidFieldNumber = 2,
    kOffsetFieldNumber = 1,
  };
  // bytes symbol_uuid = 2;
  void clear_symbol_uuid();
  const std::string& symbol_uuid() const;
  void set_symbol_uuid(const std::string& value);
  void set_symbol_uuid(std::string&& value);
  void set_symbol_uuid(const char* value);
  void set_symbol_uuid(const void* value, size_t size);
  std::string* mutable_symbol_uuid();
  std::string* release_symbol_uuid();
  void set_allocated_symbol_uuid(std::string* symbol_uuid);
  private:
  const std::string& _internal_symbol_uuid() const;
  void _internal_set_symbol_uuid(const std::string& value);
  std::string* _internal_mutable_symbol_uuid();
  public:

  // int64 offset = 1;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::int64 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const;
  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:gtirb.proto.SymAddrConst)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_uuid_;
  ::PROTOBUF_NAMESPACE_ID::int64 offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SymbolicExpression_2eproto;
};
// -------------------------------------------------------------------

class SymAddrAddr PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.SymAddrAddr) */ {
 public:
  inline SymAddrAddr() : SymAddrAddr(nullptr) {}
  virtual ~SymAddrAddr();
  explicit constexpr SymAddrAddr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SymAddrAddr& operator=(const SymAddrAddr& from) {
    CopyFrom(from);
    return *this;
  }
  inline SymAddrAddr& operator=(SymAddrAddr&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SymAddrAddr& default_instance() {
    return *internal_default_instance();
  }
  static inline const SymAddrAddr* internal_default_instance() {
    return reinterpret_cast<const SymAddrAddr*>(
               &_SymAddrAddr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SymAddrAddr& a, SymAddrAddr& b) {
    a.Swap(&b);
  }
  inline void Swap(SymAddrAddr* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SymAddrAddr* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SymAddrAddr* New() const final {
    return CreateMaybeMessage<SymAddrAddr>(nullptr);
  }

  SymAddrAddr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SymAddrAddr>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SymAddrAddr& from);
  void MergeFrom(const SymAddrAddr& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SymAddrAddr* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.SymAddrAddr";
  }
  protected:
  explicit SymAddrAddr(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_SymbolicExpression_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kSymbol1UuidFieldNumber = 3,
    kSymbol2UuidFieldNumber = 4,
    kScaleFieldNumber = 1,
    kOffsetFieldNumber = 2,
  };
  // bytes symbol1_uuid = 3;
  void clear_symbol1_uuid();
  const std::string& symbol1_uuid() const;
  void set_symbol1_uuid(const std::string& value);
  void set_symbol1_uuid(std::string&& value);
  void set_symbol1_uuid(const char* value);
  void set_symbol1_uuid(const void* value, size_t size);
  std::string* mutable_symbol1_uuid();
  std::string* release_symbol1_uuid();
  void set_allocated_symbol1_uuid(std::string* symbol1_uuid);
  private:
  const std::string& _internal_symbol1_uuid() const;
  void _internal_set_symbol1_uuid(const std::string& value);
  std::string* _internal_mutable_symbol1_uuid();
  public:

  // bytes symbol2_uuid = 4;
  void clear_symbol2_uuid();
  const std::string& symbol2_uuid() const;
  void set_symbol2_uuid(const std::string& value);
  void set_symbol2_uuid(std::string&& value);
  void set_symbol2_uuid(const char* value);
  void set_symbol2_uuid(const void* value, size_t size);
  std::string* mutable_symbol2_uuid();
  std::string* release_symbol2_uuid();
  void set_allocated_symbol2_uuid(std::string* symbol2_uuid);
  private:
  const std::string& _internal_symbol2_uuid() const;
  void _internal_set_symbol2_uuid(const std::string& value);
  std::string* _internal_mutable_symbol2_uuid();
  public:

  // int64 scale = 1;
  void clear_scale();
  ::PROTOBUF_NAMESPACE_ID::int64 scale() const;
  void set_scale(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_scale() const;
  void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 offset = 2;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::int64 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const;
  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:gtirb.proto.SymAddrAddr)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol1_uuid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol2_uuid_;
  ::PROTOBUF_NAMESPACE_ID::int64 scale_;
  ::PROTOBUF_NAMESPACE_ID::int64 offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SymbolicExpression_2eproto;
};
// -------------------------------------------------------------------

class SymbolicExpression PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.SymbolicExpression) */ {
 public:
  inline SymbolicExpression() : SymbolicExpression(nullptr) {}
  virtual ~SymbolicExpression();
  explicit constexpr SymbolicExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SymbolicExpression& operator=(const SymbolicExpression& from) {
    CopyFrom(from);
    return *this;
  }
  inline SymbolicExpression& operator=(SymbolicExpression&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SymbolicExpression& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kAddrConst = 2,
    kAddrAddr = 3,
    VALUE_NOT_SET = 0,
  };

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

  friend void swap(SymbolicExpression& a, SymbolicExpression& b) {
    a.Swap(&b);
  }
  inline void Swap(SymbolicExpression* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SymbolicExpression* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SymbolicExpression* New() const final {
    return CreateMaybeMessage<SymbolicExpression>(nullptr);
  }

  SymbolicExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SymbolicExpression>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SymbolicExpression& from);
  void MergeFrom(const SymbolicExpression& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SymbolicExpression* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.SymbolicExpression";
  }
  protected:
  explicit SymbolicExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_SymbolicExpression_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kAttributeFlagsFieldNumber = 4,
    kAddrConstFieldNumber = 2,
    kAddrAddrFieldNumber = 3,
  };
  // repeated .gtirb.proto.SymAttribute attribute_flags = 4;
  int attribute_flags_size() const;
  private:
  int _internal_attribute_flags_size() const;
  public:
  void clear_attribute_flags();
  private:
  ::gtirb::proto::SymAttribute _internal_attribute_flags(int index) const;
  void _internal_add_attribute_flags(::gtirb::proto::SymAttribute value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_attribute_flags();
  public:
  ::gtirb::proto::SymAttribute attribute_flags(int index) const;
  void set_attribute_flags(int index, ::gtirb::proto::SymAttribute value);
  void add_attribute_flags(::gtirb::proto::SymAttribute value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& attribute_flags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_attribute_flags();

  // .gtirb.proto.SymAddrConst addr_const = 2;
  bool has_addr_const() const;
  private:
  bool _internal_has_addr_const() const;
  public:
  void clear_addr_const();
  const ::gtirb::proto::SymAddrConst& addr_const() const;
  ::gtirb::proto::SymAddrConst* release_addr_const();
  ::gtirb::proto::SymAddrConst* mutable_addr_const();
  void set_allocated_addr_const(::gtirb::proto::SymAddrConst* addr_const);
  private:
  const ::gtirb::proto::SymAddrConst& _internal_addr_const() const;
  ::gtirb::proto::SymAddrConst* _internal_mutable_addr_const();
  public:
  void unsafe_arena_set_allocated_addr_const(
      ::gtirb::proto::SymAddrConst* addr_const);
  ::gtirb::proto::SymAddrConst* unsafe_arena_release_addr_const();

  // .gtirb.proto.SymAddrAddr addr_addr = 3;
  bool has_addr_addr() const;
  private:
  bool _internal_has_addr_addr() const;
  public:
  void clear_addr_addr();
  const ::gtirb::proto::SymAddrAddr& addr_addr() const;
  ::gtirb::proto::SymAddrAddr* release_addr_addr();
  ::gtirb::proto::SymAddrAddr* mutable_addr_addr();
  void set_allocated_addr_addr(::gtirb::proto::SymAddrAddr* addr_addr);
  private:
  const ::gtirb::proto::SymAddrAddr& _internal_addr_addr() const;
  ::gtirb::proto::SymAddrAddr* _internal_mutable_addr_addr();
  public:
  void unsafe_arena_set_allocated_addr_addr(
      ::gtirb::proto::SymAddrAddr* addr_addr);
  ::gtirb::proto::SymAddrAddr* unsafe_arena_release_addr_addr();

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:gtirb.proto.SymbolicExpression)
 private:
  class _Internal;
  void set_has_addr_const();
  void set_has_addr_addr();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> attribute_flags_;
  mutable std::atomic<int> _attribute_flags_cached_byte_size_;
  union ValueUnion {
    constexpr ValueUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::gtirb::proto::SymAddrConst* addr_const_;
    ::gtirb::proto::SymAddrAddr* addr_addr_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_SymbolicExpression_2eproto;
};
// ===================================================================


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

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

// int32 offset = 1;
inline void SymStackConst::clear_offset() {
  offset_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SymStackConst::_internal_offset() const {
  return offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SymStackConst::offset() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymStackConst.offset)
  return _internal_offset();
}
inline void SymStackConst::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  offset_ = value;
}
inline void SymStackConst::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymStackConst.offset)
}

// bytes symbol_uuid = 2;
inline void SymStackConst::clear_symbol_uuid() {
  symbol_uuid_.ClearToEmpty();
}
inline const std::string& SymStackConst::symbol_uuid() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymStackConst.symbol_uuid)
  return _internal_symbol_uuid();
}
inline void SymStackConst::set_symbol_uuid(const std::string& value) {
  _internal_set_symbol_uuid(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymStackConst.symbol_uuid)
}
inline std::string* SymStackConst::mutable_symbol_uuid() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymStackConst.symbol_uuid)
  return _internal_mutable_symbol_uuid();
}
inline const std::string& SymStackConst::_internal_symbol_uuid() const {
  return symbol_uuid_.Get();
}
inline void SymStackConst::_internal_set_symbol_uuid(const std::string& value) {
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SymStackConst::set_symbol_uuid(std::string&& value) {
  
  symbol_uuid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.SymStackConst.symbol_uuid)
}
inline void SymStackConst::set_symbol_uuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.SymStackConst.symbol_uuid)
}
inline void SymStackConst::set_symbol_uuid(const void* value,
    size_t size) {
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.SymStackConst.symbol_uuid)
}
inline std::string* SymStackConst::_internal_mutable_symbol_uuid() {
  
  return symbol_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SymStackConst::release_symbol_uuid() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymStackConst.symbol_uuid)
  return symbol_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SymStackConst::set_allocated_symbol_uuid(std::string* symbol_uuid) {
  if (symbol_uuid != nullptr) {
    
  } else {
    
  }
  symbol_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol_uuid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.SymStackConst.symbol_uuid)
}

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

// SymAddrConst

// int64 offset = 1;
inline void SymAddrConst::clear_offset() {
  offset_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrConst::_internal_offset() const {
  return offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrConst::offset() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrConst.offset)
  return _internal_offset();
}
inline void SymAddrConst::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  offset_ = value;
}
inline void SymAddrConst::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrConst.offset)
}

// bytes symbol_uuid = 2;
inline void SymAddrConst::clear_symbol_uuid() {
  symbol_uuid_.ClearToEmpty();
}
inline const std::string& SymAddrConst::symbol_uuid() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrConst.symbol_uuid)
  return _internal_symbol_uuid();
}
inline void SymAddrConst::set_symbol_uuid(const std::string& value) {
  _internal_set_symbol_uuid(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrConst.symbol_uuid)
}
inline std::string* SymAddrConst::mutable_symbol_uuid() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymAddrConst.symbol_uuid)
  return _internal_mutable_symbol_uuid();
}
inline const std::string& SymAddrConst::_internal_symbol_uuid() const {
  return symbol_uuid_.Get();
}
inline void SymAddrConst::_internal_set_symbol_uuid(const std::string& value) {
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SymAddrConst::set_symbol_uuid(std::string&& value) {
  
  symbol_uuid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.SymAddrConst.symbol_uuid)
}
inline void SymAddrConst::set_symbol_uuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.SymAddrConst.symbol_uuid)
}
inline void SymAddrConst::set_symbol_uuid(const void* value,
    size_t size) {
  
  symbol_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.SymAddrConst.symbol_uuid)
}
inline std::string* SymAddrConst::_internal_mutable_symbol_uuid() {
  
  return symbol_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SymAddrConst::release_symbol_uuid() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymAddrConst.symbol_uuid)
  return symbol_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SymAddrConst::set_allocated_symbol_uuid(std::string* symbol_uuid) {
  if (symbol_uuid != nullptr) {
    
  } else {
    
  }
  symbol_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol_uuid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.SymAddrConst.symbol_uuid)
}

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

// SymAddrAddr

// int64 scale = 1;
inline void SymAddrAddr::clear_scale() {
  scale_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrAddr::_internal_scale() const {
  return scale_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrAddr::scale() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrAddr.scale)
  return _internal_scale();
}
inline void SymAddrAddr::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  scale_ = value;
}
inline void SymAddrAddr::set_scale(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrAddr.scale)
}

// int64 offset = 2;
inline void SymAddrAddr::clear_offset() {
  offset_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrAddr::_internal_offset() const {
  return offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SymAddrAddr::offset() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrAddr.offset)
  return _internal_offset();
}
inline void SymAddrAddr::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  offset_ = value;
}
inline void SymAddrAddr::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrAddr.offset)
}

// bytes symbol1_uuid = 3;
inline void SymAddrAddr::clear_symbol1_uuid() {
  symbol1_uuid_.ClearToEmpty();
}
inline const std::string& SymAddrAddr::symbol1_uuid() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrAddr.symbol1_uuid)
  return _internal_symbol1_uuid();
}
inline void SymAddrAddr::set_symbol1_uuid(const std::string& value) {
  _internal_set_symbol1_uuid(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrAddr.symbol1_uuid)
}
inline std::string* SymAddrAddr::mutable_symbol1_uuid() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymAddrAddr.symbol1_uuid)
  return _internal_mutable_symbol1_uuid();
}
inline const std::string& SymAddrAddr::_internal_symbol1_uuid() const {
  return symbol1_uuid_.Get();
}
inline void SymAddrAddr::_internal_set_symbol1_uuid(const std::string& value) {
  
  symbol1_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SymAddrAddr::set_symbol1_uuid(std::string&& value) {
  
  symbol1_uuid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.SymAddrAddr.symbol1_uuid)
}
inline void SymAddrAddr::set_symbol1_uuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  symbol1_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.SymAddrAddr.symbol1_uuid)
}
inline void SymAddrAddr::set_symbol1_uuid(const void* value,
    size_t size) {
  
  symbol1_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.SymAddrAddr.symbol1_uuid)
}
inline std::string* SymAddrAddr::_internal_mutable_symbol1_uuid() {
  
  return symbol1_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SymAddrAddr::release_symbol1_uuid() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymAddrAddr.symbol1_uuid)
  return symbol1_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SymAddrAddr::set_allocated_symbol1_uuid(std::string* symbol1_uuid) {
  if (symbol1_uuid != nullptr) {
    
  } else {
    
  }
  symbol1_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol1_uuid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.SymAddrAddr.symbol1_uuid)
}

// bytes symbol2_uuid = 4;
inline void SymAddrAddr::clear_symbol2_uuid() {
  symbol2_uuid_.ClearToEmpty();
}
inline const std::string& SymAddrAddr::symbol2_uuid() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymAddrAddr.symbol2_uuid)
  return _internal_symbol2_uuid();
}
inline void SymAddrAddr::set_symbol2_uuid(const std::string& value) {
  _internal_set_symbol2_uuid(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymAddrAddr.symbol2_uuid)
}
inline std::string* SymAddrAddr::mutable_symbol2_uuid() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymAddrAddr.symbol2_uuid)
  return _internal_mutable_symbol2_uuid();
}
inline const std::string& SymAddrAddr::_internal_symbol2_uuid() const {
  return symbol2_uuid_.Get();
}
inline void SymAddrAddr::_internal_set_symbol2_uuid(const std::string& value) {
  
  symbol2_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SymAddrAddr::set_symbol2_uuid(std::string&& value) {
  
  symbol2_uuid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.SymAddrAddr.symbol2_uuid)
}
inline void SymAddrAddr::set_symbol2_uuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  symbol2_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.SymAddrAddr.symbol2_uuid)
}
inline void SymAddrAddr::set_symbol2_uuid(const void* value,
    size_t size) {
  
  symbol2_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.SymAddrAddr.symbol2_uuid)
}
inline std::string* SymAddrAddr::_internal_mutable_symbol2_uuid() {
  
  return symbol2_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SymAddrAddr::release_symbol2_uuid() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymAddrAddr.symbol2_uuid)
  return symbol2_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SymAddrAddr::set_allocated_symbol2_uuid(std::string* symbol2_uuid) {
  if (symbol2_uuid != nullptr) {
    
  } else {
    
  }
  symbol2_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol2_uuid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.SymAddrAddr.symbol2_uuid)
}

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

// SymbolicExpression

// .gtirb.proto.SymAddrConst addr_const = 2;
inline bool SymbolicExpression::_internal_has_addr_const() const {
  return value_case() == kAddrConst;
}
inline bool SymbolicExpression::has_addr_const() const {
  return _internal_has_addr_const();
}
inline void SymbolicExpression::set_has_addr_const() {
  _oneof_case_[0] = kAddrConst;
}
inline void SymbolicExpression::clear_addr_const() {
  if (_internal_has_addr_const()) {
    if (GetArena() == nullptr) {
      delete value_.addr_const_;
    }
    clear_has_value();
  }
}
inline ::gtirb::proto::SymAddrConst* SymbolicExpression::release_addr_const() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymbolicExpression.addr_const)
  if (_internal_has_addr_const()) {
    clear_has_value();
      ::gtirb::proto::SymAddrConst* temp = value_.addr_const_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.addr_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gtirb::proto::SymAddrConst& SymbolicExpression::_internal_addr_const() const {
  return _internal_has_addr_const()
      ? *value_.addr_const_
      : reinterpret_cast< ::gtirb::proto::SymAddrConst&>(::gtirb::proto::_SymAddrConst_default_instance_);
}
inline const ::gtirb::proto::SymAddrConst& SymbolicExpression::addr_const() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymbolicExpression.addr_const)
  return _internal_addr_const();
}
inline ::gtirb::proto::SymAddrConst* SymbolicExpression::unsafe_arena_release_addr_const() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gtirb.proto.SymbolicExpression.addr_const)
  if (_internal_has_addr_const()) {
    clear_has_value();
    ::gtirb::proto::SymAddrConst* temp = value_.addr_const_;
    value_.addr_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SymbolicExpression::unsafe_arena_set_allocated_addr_const(::gtirb::proto::SymAddrConst* addr_const) {
  clear_value();
  if (addr_const) {
    set_has_addr_const();
    value_.addr_const_ = addr_const;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtirb.proto.SymbolicExpression.addr_const)
}
inline ::gtirb::proto::SymAddrConst* SymbolicExpression::_internal_mutable_addr_const() {
  if (!_internal_has_addr_const()) {
    clear_value();
    set_has_addr_const();
    value_.addr_const_ = CreateMaybeMessage< ::gtirb::proto::SymAddrConst >(GetArena());
  }
  return value_.addr_const_;
}
inline ::gtirb::proto::SymAddrConst* SymbolicExpression::mutable_addr_const() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymbolicExpression.addr_const)
  return _internal_mutable_addr_const();
}

// .gtirb.proto.SymAddrAddr addr_addr = 3;
inline bool SymbolicExpression::_internal_has_addr_addr() const {
  return value_case() == kAddrAddr;
}
inline bool SymbolicExpression::has_addr_addr() const {
  return _internal_has_addr_addr();
}
inline void SymbolicExpression::set_has_addr_addr() {
  _oneof_case_[0] = kAddrAddr;
}
inline void SymbolicExpression::clear_addr_addr() {
  if (_internal_has_addr_addr()) {
    if (GetArena() == nullptr) {
      delete value_.addr_addr_;
    }
    clear_has_value();
  }
}
inline ::gtirb::proto::SymAddrAddr* SymbolicExpression::release_addr_addr() {
  // @@protoc_insertion_point(field_release:gtirb.proto.SymbolicExpression.addr_addr)
  if (_internal_has_addr_addr()) {
    clear_has_value();
      ::gtirb::proto::SymAddrAddr* temp = value_.addr_addr_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.addr_addr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gtirb::proto::SymAddrAddr& SymbolicExpression::_internal_addr_addr() const {
  return _internal_has_addr_addr()
      ? *value_.addr_addr_
      : reinterpret_cast< ::gtirb::proto::SymAddrAddr&>(::gtirb::proto::_SymAddrAddr_default_instance_);
}
inline const ::gtirb::proto::SymAddrAddr& SymbolicExpression::addr_addr() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymbolicExpression.addr_addr)
  return _internal_addr_addr();
}
inline ::gtirb::proto::SymAddrAddr* SymbolicExpression::unsafe_arena_release_addr_addr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gtirb.proto.SymbolicExpression.addr_addr)
  if (_internal_has_addr_addr()) {
    clear_has_value();
    ::gtirb::proto::SymAddrAddr* temp = value_.addr_addr_;
    value_.addr_addr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SymbolicExpression::unsafe_arena_set_allocated_addr_addr(::gtirb::proto::SymAddrAddr* addr_addr) {
  clear_value();
  if (addr_addr) {
    set_has_addr_addr();
    value_.addr_addr_ = addr_addr;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtirb.proto.SymbolicExpression.addr_addr)
}
inline ::gtirb::proto::SymAddrAddr* SymbolicExpression::_internal_mutable_addr_addr() {
  if (!_internal_has_addr_addr()) {
    clear_value();
    set_has_addr_addr();
    value_.addr_addr_ = CreateMaybeMessage< ::gtirb::proto::SymAddrAddr >(GetArena());
  }
  return value_.addr_addr_;
}
inline ::gtirb::proto::SymAddrAddr* SymbolicExpression::mutable_addr_addr() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.SymbolicExpression.addr_addr)
  return _internal_mutable_addr_addr();
}

// repeated .gtirb.proto.SymAttribute attribute_flags = 4;
inline int SymbolicExpression::_internal_attribute_flags_size() const {
  return attribute_flags_.size();
}
inline int SymbolicExpression::attribute_flags_size() const {
  return _internal_attribute_flags_size();
}
inline void SymbolicExpression::clear_attribute_flags() {
  attribute_flags_.Clear();
}
inline ::gtirb::proto::SymAttribute SymbolicExpression::_internal_attribute_flags(int index) const {
  return static_cast< ::gtirb::proto::SymAttribute >(attribute_flags_.Get(index));
}
inline ::gtirb::proto::SymAttribute SymbolicExpression::attribute_flags(int index) const {
  // @@protoc_insertion_point(field_get:gtirb.proto.SymbolicExpression.attribute_flags)
  return _internal_attribute_flags(index);
}
inline void SymbolicExpression::set_attribute_flags(int index, ::gtirb::proto::SymAttribute value) {
  attribute_flags_.Set(index, value);
  // @@protoc_insertion_point(field_set:gtirb.proto.SymbolicExpression.attribute_flags)
}
inline void SymbolicExpression::_internal_add_attribute_flags(::gtirb::proto::SymAttribute value) {
  attribute_flags_.Add(value);
}
inline void SymbolicExpression::add_attribute_flags(::gtirb::proto::SymAttribute value) {
  // @@protoc_insertion_point(field_add:gtirb.proto.SymbolicExpression.attribute_flags)
  _internal_add_attribute_flags(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SymbolicExpression::attribute_flags() const {
  // @@protoc_insertion_point(field_list:gtirb.proto.SymbolicExpression.attribute_flags)
  return attribute_flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SymbolicExpression::_internal_mutable_attribute_flags() {
  return &attribute_flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SymbolicExpression::mutable_attribute_flags() {
  // @@protoc_insertion_point(field_mutable_list:gtirb.proto.SymbolicExpression.attribute_flags)
  return _internal_mutable_attribute_flags();
}

inline bool SymbolicExpression::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void SymbolicExpression::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline SymbolicExpression::ValueCase SymbolicExpression::value_case() const {
  return SymbolicExpression::ValueCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace gtirb

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::gtirb::proto::SymAttribute> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::gtirb::proto::SymAttribute>() {
  return ::gtirb::proto::SymAttribute_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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