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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "CoreDump.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace mozilla {
namespace devtools {
namespace protobuf {
class MetadataDefaultTypeInternal {
public:
 ::google::protobuf::internal::ExplicitlyConstructed<Metadata>
     _instance;
} _Metadata_default_instance_;
class StackFrame_DataDefaultTypeInternal {
public:
 ::google::protobuf::internal::ExplicitlyConstructed<StackFrame_Data>
     _instance;
  ::google::protobuf::internal::ArenaStringPtr source_;
  ::google::protobuf::uint64 sourceref_;
  ::google::protobuf::internal::ArenaStringPtr functiondisplayname_;
  ::google::protobuf::uint64 functiondisplaynameref_;
} _StackFrame_Data_default_instance_;
class StackFrameDefaultTypeInternal {
public:
 ::google::protobuf::internal::ExplicitlyConstructed<StackFrame>
     _instance;
  const ::mozilla::devtools::protobuf::StackFrame_Data* data_;
  ::google::protobuf::uint64 ref_;
} _StackFrame_default_instance_;
class NodeDefaultTypeInternal {
public:
 ::google::protobuf::internal::ExplicitlyConstructed<Node>
     _instance;
  ::google::protobuf::internal::ArenaStringPtr typename__;
  ::google::protobuf::uint64 typenameref_;
  ::google::protobuf::internal::ArenaStringPtr jsobjectclassname_;
  ::google::protobuf::uint64 jsobjectclassnameref_;
  ::google::protobuf::internal::ArenaStringPtr scriptfilename_;
  ::google::protobuf::uint64 scriptfilenameref_;
} _Node_default_instance_;
class EdgeDefaultTypeInternal {
public:
 ::google::protobuf::internal::ExplicitlyConstructed<Edge>
     _instance;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::uint64 nameref_;
} _Edge_default_instance_;

namespace protobuf_CoreDump_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] GOOGLE_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] GOOGLE_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] GOOGLE_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  { NULL, NULL, 0, -1, -1, -1, -1, NULL, false },
  { NULL, NULL, 0, -1, -1, -1, -1, NULL, false },
  { NULL, NULL, 0, -1, -1, -1, -1, NULL, false },
  { NULL, NULL, 0, -1, -1, -1, -1, NULL, false },
  { NULL, NULL, 0, -1, -1, -1, -1, NULL, false },
};

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _Metadata_default_instance_._instance.DefaultConstruct();
  ::google::protobuf::internal::OnShutdownDestroyMessage(
      &_Metadata_default_instance_);_StackFrame_Data_default_instance_._instance.DefaultConstruct();
  ::google::protobuf::internal::OnShutdownDestroyMessage(
      &_StackFrame_Data_default_instance_);_StackFrame_default_instance_._instance.DefaultConstruct();
  ::google::protobuf::internal::OnShutdownDestroyMessage(
      &_StackFrame_default_instance_);_Node_default_instance_._instance.DefaultConstruct();
  ::google::protobuf::internal::OnShutdownDestroyMessage(
      &_Node_default_instance_);_Edge_default_instance_._instance.DefaultConstruct();
  ::google::protobuf::internal::OnShutdownDestroyMessage(
      &_Edge_default_instance_);_StackFrame_Data_default_instance_._instance.get_mutable()->parent_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(
      ::mozilla::devtools::protobuf::StackFrame::internal_default_instance());
  _Node_default_instance_._instance.get_mutable()->allocationstack_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(
      ::mozilla::devtools::protobuf::StackFrame::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
namespace {
void AddDescriptorsImpl() {
  InitDefaults();
}
} // anonymous namespace

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_CoreDump_2eproto


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Metadata::kTimeStampFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Metadata::Metadata()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_CoreDump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Metadata)
}
Metadata::Metadata(const Metadata& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  timestamp_ = from.timestamp_;
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Metadata)
}

void Metadata::SharedCtor() {
  _cached_size_ = 0;
  timestamp_ = GOOGLE_ULONGLONG(0);
}

Metadata::~Metadata() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Metadata)
  SharedDtor();
}

void Metadata::SharedDtor() {
}

void Metadata::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Metadata& Metadata::default_instance() {
  protobuf_CoreDump_2eproto::InitDefaults();
  return *internal_default_instance();
}

Metadata* Metadata::New(::google::protobuf::Arena* arena) const {
  Metadata* n = new Metadata;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Metadata::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.Metadata)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  timestamp_ = GOOGLE_ULONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Metadata::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.Metadata)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 timeStamp = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_timestamp();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.Metadata)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.Metadata)
  return false;
#undef DO_
}

void Metadata::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.Metadata)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 timeStamp = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->timestamp(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.Metadata)
}

size_t Metadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.Metadata)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  // optional uint64 timeStamp = 1;
  if (has_timestamp()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt64Size(
        this->timestamp());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Metadata::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Metadata*>(&from));
}

void Metadata::MergeFrom(const Metadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.Metadata)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_timestamp()) {
    set_timestamp(from.timestamp());
  }
}

void Metadata::CopyFrom(const Metadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.Metadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Metadata::IsInitialized() const {
  return true;
}

void Metadata::Swap(Metadata* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Metadata::InternalSwap(Metadata* other) {
  using std::swap;
  swap(timestamp_, other->timestamp_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::std::string Metadata::GetTypeName() const {
  return "mozilla.devtools.protobuf.Metadata";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Metadata

// optional uint64 timeStamp = 1;
bool Metadata::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Metadata::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
void Metadata::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
void Metadata::clear_timestamp() {
  timestamp_ = GOOGLE_ULONGLONG(0);
  clear_has_timestamp();
}
::google::protobuf::uint64 Metadata::timestamp() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Metadata.timeStamp)
  return timestamp_;
}
void Metadata::set_timestamp(::google::protobuf::uint64 value) {
  set_has_timestamp();
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int StackFrame_Data::kIdFieldNumber;
const int StackFrame_Data::kParentFieldNumber;
const int StackFrame_Data::kLineFieldNumber;
const int StackFrame_Data::kColumnFieldNumber;
const int StackFrame_Data::kSourceFieldNumber;
const int StackFrame_Data::kSourceRefFieldNumber;
const int StackFrame_Data::kFunctionDisplayNameFieldNumber;
const int StackFrame_Data::kFunctionDisplayNameRefFieldNumber;
const int StackFrame_Data::kIsSystemFieldNumber;
const int StackFrame_Data::kIsSelfHostedFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

StackFrame_Data::StackFrame_Data()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_CoreDump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame.Data)
}
StackFrame_Data::StackFrame_Data(const StackFrame_Data& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_parent()) {
    parent_ = new ::mozilla::devtools::protobuf::StackFrame(*from.parent_);
  } else {
    parent_ = NULL;
  }
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&isselfhosted_) -
    reinterpret_cast<char*>(&id_)) + sizeof(isselfhosted_));
  clear_has_SourceOrRef();
  switch (from.SourceOrRef_case()) {
    case kSource: {
      set_source(from.source());
      break;
    }
    case kSourceRef: {
      set_sourceref(from.sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_FunctionDisplayNameOrRef();
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      set_functiondisplayname(from.functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      set_functiondisplaynameref(from.functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame.Data)
}

void StackFrame_Data::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&parent_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isselfhosted_) -
      reinterpret_cast<char*>(&parent_)) + sizeof(isselfhosted_));
  clear_has_SourceOrRef();
  clear_has_FunctionDisplayNameOrRef();
}

StackFrame_Data::~StackFrame_Data() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame.Data)
  SharedDtor();
}

void StackFrame_Data::SharedDtor() {
  if (this != internal_default_instance()) delete parent_;
  if (has_SourceOrRef()) {
    clear_SourceOrRef();
  }
  if (has_FunctionDisplayNameOrRef()) {
    clear_FunctionDisplayNameOrRef();
  }
}

void StackFrame_Data::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StackFrame_Data& StackFrame_Data::default_instance() {
  protobuf_CoreDump_2eproto::InitDefaults();
  return *internal_default_instance();
}

StackFrame_Data* StackFrame_Data::New(::google::protobuf::Arena* arena) const {
  StackFrame_Data* n = new StackFrame_Data;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void StackFrame_Data::clear_SourceOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  switch (SourceOrRef_case()) {
    case kSource: {
      SourceOrRef_.source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kSourceRef: {
      // No need to clear
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SOURCEORREF_NOT_SET;
}

void StackFrame_Data::clear_FunctionDisplayNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  switch (FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      FunctionDisplayNameOrRef_.functiondisplayname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kFunctionDisplayNameRef: {
      // No need to clear
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET;
}


void StackFrame_Data::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (has_parent()) {
    GOOGLE_DCHECK(parent_ != NULL);
    parent_->::mozilla::devtools::protobuf::StackFrame::Clear();
  }
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 62u) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&isselfhosted_) -
        reinterpret_cast<char*>(&id_)) + sizeof(isselfhosted_));
  }
  clear_SourceOrRef();
  clear_FunctionDisplayNameOrRef();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool StackFrame_Data::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.StackFrame.Data)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_parent()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 line = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_line();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &line_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 column = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_column();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &column_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes source = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_source()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 sourceRef = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          clear_SourceOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &SourceOrRef_.sourceref_)));
          set_has_sourceref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes functionDisplayName = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_functiondisplayname()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 functionDisplayNameRef = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          clear_FunctionDisplayNameOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &FunctionDisplayNameOrRef_.functiondisplaynameref_)));
          set_has_functiondisplaynameref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool isSystem = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_issystem();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &issystem_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool isSelfHosted = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_isselfhosted();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isselfhosted_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.StackFrame.Data)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.StackFrame.Data)
  return false;
#undef DO_
}

void StackFrame_Data::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.StackFrame.Data)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->id(), output);
  }

  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->parent_, output);
  }

  // optional uint32 line = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->line(), output);
  }

  // optional uint32 column = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->column(), output);
  }

  switch (SourceOrRef_case()) {
    case kSource:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        5, this->source(), output);
      break;
    case kSourceRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->sourceref(), output);
      break;
    default: ;
  }
  switch (FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        7, this->functiondisplayname(), output);
      break;
    case kFunctionDisplayNameRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->functiondisplaynameref(), output);
      break;
    default: ;
  }
  // optional bool isSystem = 9;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->issystem(), output);
  }

  // optional bool isSelfHosted = 10;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->isselfhosted(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.StackFrame.Data)
}

size_t StackFrame_Data::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.StackFrame.Data)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  if (_has_bits_[0 / 32] & 63u) {
    // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
    if (has_parent()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->parent_);
    }

    // optional uint64 id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->id());
    }

    // optional uint32 line = 3;
    if (has_line()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->line());
    }

    // optional uint32 column = 4;
    if (has_column()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->column());
    }

    // optional bool isSystem = 9;
    if (has_issystem()) {
      total_size += 1 + 1;
    }

    // optional bool isSelfHosted = 10;
    if (has_isselfhosted()) {
      total_size += 1 + 1;
    }

  }
  switch (SourceOrRef_case()) {
    // optional bytes source = 5;
    case kSource: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->source());
      break;
    }
    // optional uint64 sourceRef = 6;
    case kSourceRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (FunctionDisplayNameOrRef_case()) {
    // optional bytes functionDisplayName = 7;
    case kFunctionDisplayName: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->functiondisplayname());
      break;
    }
    // optional uint64 functionDisplayNameRef = 8;
    case kFunctionDisplayNameRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StackFrame_Data::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StackFrame_Data*>(&from));
}

void StackFrame_Data::MergeFrom(const StackFrame_Data& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.StackFrame.Data)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_parent()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from.parent());
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      line_ = from.line_;
    }
    if (cached_has_bits & 0x00000008u) {
      column_ = from.column_;
    }
    if (cached_has_bits & 0x00000010u) {
      issystem_ = from.issystem_;
    }
    if (cached_has_bits & 0x00000020u) {
      isselfhosted_ = from.isselfhosted_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.SourceOrRef_case()) {
    case kSource: {
      set_source(from.source());
      break;
    }
    case kSourceRef: {
      set_sourceref(from.sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      set_functiondisplayname(from.functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      set_functiondisplaynameref(from.functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
}

void StackFrame_Data::CopyFrom(const StackFrame_Data& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.StackFrame.Data)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackFrame_Data::IsInitialized() const {
  return true;
}

void StackFrame_Data::Swap(StackFrame_Data* other) {
  if (other == this) return;
  InternalSwap(other);
}
void StackFrame_Data::InternalSwap(StackFrame_Data* other) {
  using std::swap;
  swap(parent_, other->parent_);
  swap(id_, other->id_);
  swap(line_, other->line_);
  swap(column_, other->column_);
  swap(issystem_, other->issystem_);
  swap(isselfhosted_, other->isselfhosted_);
  swap(SourceOrRef_, other->SourceOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(FunctionDisplayNameOrRef_, other->FunctionDisplayNameOrRef_);
  swap(_oneof_case_[1], other->_oneof_case_[1]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::std::string StackFrame_Data::GetTypeName() const {
  return "mozilla.devtools.protobuf.StackFrame.Data";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// StackFrame_Data

// optional uint64 id = 1;
bool StackFrame_Data::has_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void StackFrame_Data::set_has_id() {
  _has_bits_[0] |= 0x00000002u;
}
void StackFrame_Data::clear_has_id() {
  _has_bits_[0] &= ~0x00000002u;
}
void StackFrame_Data::clear_id() {
  id_ = GOOGLE_ULONGLONG(0);
  clear_has_id();
}
::google::protobuf::uint64 StackFrame_Data::id() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id)
  return id_;
}
void StackFrame_Data::set_id(::google::protobuf::uint64 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id)
}

// optional .mozilla.devtools.protobuf.StackFrame parent = 2;
bool StackFrame_Data::has_parent() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void StackFrame_Data::set_has_parent() {
  _has_bits_[0] |= 0x00000001u;
}
void StackFrame_Data::clear_has_parent() {
  _has_bits_[0] &= ~0x00000001u;
}
void StackFrame_Data::clear_parent() {
  if (parent_ != NULL) parent_->::mozilla::devtools::protobuf::StackFrame::Clear();
  clear_has_parent();
}
const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const {
  const ::mozilla::devtools::protobuf::StackFrame* p = parent_;
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent)
  return p != NULL ? *p : *reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame*>(
      &::mozilla::devtools::protobuf::_StackFrame_default_instance_);
}
::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::mutable_parent() {
  set_has_parent();
  if (parent_ == NULL) {
    parent_ = new ::mozilla::devtools::protobuf::StackFrame;
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent)
  return parent_;
}
::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::release_parent() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.parent)
  clear_has_parent();
  ::mozilla::devtools::protobuf::StackFrame* temp = parent_;
  parent_ = NULL;
  return temp;
}
void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent) {
  delete parent_;
  parent_ = parent;
  if (parent) {
    set_has_parent();
  } else {
    clear_has_parent();
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent)
}

// optional uint32 line = 3;
bool StackFrame_Data::has_line() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void StackFrame_Data::set_has_line() {
  _has_bits_[0] |= 0x00000004u;
}
void StackFrame_Data::clear_has_line() {
  _has_bits_[0] &= ~0x00000004u;
}
void StackFrame_Data::clear_line() {
  line_ = 0u;
  clear_has_line();
}
::google::protobuf::uint32 StackFrame_Data::line() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line)
  return line_;
}
void StackFrame_Data::set_line(::google::protobuf::uint32 value) {
  set_has_line();
  line_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line)
}

// optional uint32 column = 4;
bool StackFrame_Data::has_column() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void StackFrame_Data::set_has_column() {
  _has_bits_[0] |= 0x00000008u;
}
void StackFrame_Data::clear_has_column() {
  _has_bits_[0] &= ~0x00000008u;
}
void StackFrame_Data::clear_column() {
  column_ = 0u;
  clear_has_column();
}
::google::protobuf::uint32 StackFrame_Data::column() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column)
  return column_;
}
void StackFrame_Data::set_column(::google::protobuf::uint32 value) {
  set_has_column();
  column_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column)
}

// optional bytes source = 5;
bool StackFrame_Data::has_source() const {
  return SourceOrRef_case() == kSource;
}
void StackFrame_Data::set_has_source() {
  _oneof_case_[0] = kSource;
}
void StackFrame_Data::clear_source() {
  if (has_source()) {
    SourceOrRef_.source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_SourceOrRef();
  }
}
const ::std::string& StackFrame_Data::source() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.source)
  if (has_source()) {
    return SourceOrRef_.source_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void StackFrame_Data::set_source(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source)
  if (!has_source()) {
    clear_SourceOrRef();
    set_has_source();
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  SourceOrRef_.source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source)
}
#if LANG_CXX11
void StackFrame_Data::set_source(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source)
  if (!has_source()) {
    clear_SourceOrRef();
    set_has_source();
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  SourceOrRef_.source_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.StackFrame.Data.source)
}
#endif
void StackFrame_Data::set_source(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_source()) {
    clear_SourceOrRef();
    set_has_source();
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  SourceOrRef_.source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.StackFrame.Data.source)
}
void StackFrame_Data::set_source(const void* value, size_t size) {
  if (!has_source()) {
    clear_SourceOrRef();
    set_has_source();
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  SourceOrRef_.source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.StackFrame.Data.source)
}
::std::string* StackFrame_Data::mutable_source() {
  if (!has_source()) {
    clear_SourceOrRef();
    set_has_source();
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.source)
  return SourceOrRef_.source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* StackFrame_Data::release_source() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.source)
  if (has_source()) {
    clear_has_SourceOrRef();
    return SourceOrRef_.source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void StackFrame_Data::set_allocated_source(::std::string* source) {
  if (!has_source()) {
    SourceOrRef_.source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_SourceOrRef();
  if (source != NULL) {
    set_has_source();
    SourceOrRef_.source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        source);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.source)
}

// optional uint64 sourceRef = 6;
bool StackFrame_Data::has_sourceref() const {
  return SourceOrRef_case() == kSourceRef;
}
void StackFrame_Data::set_has_sourceref() {
  _oneof_case_[0] = kSourceRef;
}
void StackFrame_Data::clear_sourceref() {
  if (has_sourceref()) {
    SourceOrRef_.sourceref_ = GOOGLE_ULONGLONG(0);
    clear_has_SourceOrRef();
  }
}
::google::protobuf::uint64 StackFrame_Data::sourceref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.sourceRef)
  if (has_sourceref()) {
    return SourceOrRef_.sourceref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void StackFrame_Data::set_sourceref(::google::protobuf::uint64 value) {
  if (!has_sourceref()) {
    clear_SourceOrRef();
    set_has_sourceref();
  }
  SourceOrRef_.sourceref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.sourceRef)
}

// optional bytes functionDisplayName = 7;
bool StackFrame_Data::has_functiondisplayname() const {
  return FunctionDisplayNameOrRef_case() == kFunctionDisplayName;
}
void StackFrame_Data::set_has_functiondisplayname() {
  _oneof_case_[1] = kFunctionDisplayName;
}
void StackFrame_Data::clear_functiondisplayname() {
  if (has_functiondisplayname()) {
    FunctionDisplayNameOrRef_.functiondisplayname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_FunctionDisplayNameOrRef();
  }
}
const ::std::string& StackFrame_Data::functiondisplayname() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  if (has_functiondisplayname()) {
    return FunctionDisplayNameOrRef_.functiondisplayname_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void StackFrame_Data::set_functiondisplayname(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  if (!has_functiondisplayname()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  FunctionDisplayNameOrRef_.functiondisplayname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}
#if LANG_CXX11
void StackFrame_Data::set_functiondisplayname(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  if (!has_functiondisplayname()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  FunctionDisplayNameOrRef_.functiondisplayname_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}
#endif
void StackFrame_Data::set_functiondisplayname(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_functiondisplayname()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  FunctionDisplayNameOrRef_.functiondisplayname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}
void StackFrame_Data::set_functiondisplayname(const void* value, size_t size) {
  if (!has_functiondisplayname()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  FunctionDisplayNameOrRef_.functiondisplayname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}
::std::string* StackFrame_Data::mutable_functiondisplayname() {
  if (!has_functiondisplayname()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  return FunctionDisplayNameOrRef_.functiondisplayname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* StackFrame_Data::release_functiondisplayname() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  if (has_functiondisplayname()) {
    clear_has_FunctionDisplayNameOrRef();
    return FunctionDisplayNameOrRef_.functiondisplayname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void StackFrame_Data::set_allocated_functiondisplayname(::std::string* functiondisplayname) {
  if (!has_functiondisplayname()) {
    FunctionDisplayNameOrRef_.functiondisplayname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_FunctionDisplayNameOrRef();
  if (functiondisplayname != NULL) {
    set_has_functiondisplayname();
    FunctionDisplayNameOrRef_.functiondisplayname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        functiondisplayname);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}

// optional uint64 functionDisplayNameRef = 8;
bool StackFrame_Data::has_functiondisplaynameref() const {
  return FunctionDisplayNameOrRef_case() == kFunctionDisplayNameRef;
}
void StackFrame_Data::set_has_functiondisplaynameref() {
  _oneof_case_[1] = kFunctionDisplayNameRef;
}
void StackFrame_Data::clear_functiondisplaynameref() {
  if (has_functiondisplaynameref()) {
    FunctionDisplayNameOrRef_.functiondisplaynameref_ = GOOGLE_ULONGLONG(0);
    clear_has_FunctionDisplayNameOrRef();
  }
}
::google::protobuf::uint64 StackFrame_Data::functiondisplaynameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef)
  if (has_functiondisplaynameref()) {
    return FunctionDisplayNameOrRef_.functiondisplaynameref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void StackFrame_Data::set_functiondisplaynameref(::google::protobuf::uint64 value) {
  if (!has_functiondisplaynameref()) {
    clear_FunctionDisplayNameOrRef();
    set_has_functiondisplaynameref();
  }
  FunctionDisplayNameOrRef_.functiondisplaynameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef)
}

// optional bool isSystem = 9;
bool StackFrame_Data::has_issystem() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void StackFrame_Data::set_has_issystem() {
  _has_bits_[0] |= 0x00000010u;
}
void StackFrame_Data::clear_has_issystem() {
  _has_bits_[0] &= ~0x00000010u;
}
void StackFrame_Data::clear_issystem() {
  issystem_ = false;
  clear_has_issystem();
}
bool StackFrame_Data::issystem() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
  return issystem_;
}
void StackFrame_Data::set_issystem(bool value) {
  set_has_issystem();
  issystem_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
}

// optional bool isSelfHosted = 10;
bool StackFrame_Data::has_isselfhosted() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void StackFrame_Data::set_has_isselfhosted() {
  _has_bits_[0] |= 0x00000020u;
}
void StackFrame_Data::clear_has_isselfhosted() {
  _has_bits_[0] &= ~0x00000020u;
}
void StackFrame_Data::clear_isselfhosted() {
  isselfhosted_ = false;
  clear_has_isselfhosted();
}
bool StackFrame_Data::isselfhosted() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
  return isselfhosted_;
}
void StackFrame_Data::set_isselfhosted(bool value) {
  set_has_isselfhosted();
  isselfhosted_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
}

bool StackFrame_Data::has_SourceOrRef() const {
  return SourceOrRef_case() != SOURCEORREF_NOT_SET;
}
void StackFrame_Data::clear_has_SourceOrRef() {
  _oneof_case_[0] = SOURCEORREF_NOT_SET;
}
bool StackFrame_Data::has_FunctionDisplayNameOrRef() const {
  return FunctionDisplayNameOrRef_case() != FUNCTIONDISPLAYNAMEORREF_NOT_SET;
}
void StackFrame_Data::clear_has_FunctionDisplayNameOrRef() {
  _oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET;
}
StackFrame_Data::SourceOrRefCase StackFrame_Data::SourceOrRef_case() const {
  return StackFrame_Data::SourceOrRefCase(_oneof_case_[0]);
}
StackFrame_Data::FunctionDisplayNameOrRefCase StackFrame_Data::FunctionDisplayNameOrRef_case() const {
  return StackFrame_Data::FunctionDisplayNameOrRefCase(_oneof_case_[1]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int StackFrame::kDataFieldNumber;
const int StackFrame::kRefFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

StackFrame::StackFrame()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_CoreDump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame)
}
StackFrame::StackFrame(const StackFrame& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_StackFrameType();
  switch (from.StackFrameType_case()) {
    case kData: {
      mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(from.data());
      break;
    }
    case kRef: {
      set_ref(from.ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame)
}

void StackFrame::SharedCtor() {
  _cached_size_ = 0;
  clear_has_StackFrameType();
}

StackFrame::~StackFrame() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame)
  SharedDtor();
}

void StackFrame::SharedDtor() {
  if (has_StackFrameType()) {
    clear_StackFrameType();
  }
}

void StackFrame::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StackFrame& StackFrame::default_instance() {
  protobuf_CoreDump_2eproto::InitDefaults();
  return *internal_default_instance();
}

StackFrame* StackFrame::New(::google::protobuf::Arena* arena) const {
  StackFrame* n = new StackFrame;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void StackFrame::clear_StackFrameType() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame)
  switch (StackFrameType_case()) {
    case kData: {
      delete StackFrameType_.data_;
      break;
    }
    case kRef: {
      // No need to clear
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
}


void StackFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.StackFrame)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_StackFrameType();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool StackFrame::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.StackFrame)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 ref = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          clear_StackFrameType();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &StackFrameType_.ref_)));
          set_has_ref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.StackFrame)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.StackFrame)
  return false;
#undef DO_
}

void StackFrame::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.StackFrame)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (StackFrameType_case()) {
    case kData:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        1, *StackFrameType_.data_, output);
      break;
    case kRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->ref(), output);
      break;
    default: ;
  }
  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.StackFrame)
}

size_t StackFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.StackFrame)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  switch (StackFrameType_case()) {
    // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
    case kData: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *StackFrameType_.data_);
      break;
    }
    // optional uint64 ref = 2;
    case kRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StackFrame::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StackFrame*>(&from));
}

void StackFrame::MergeFrom(const StackFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.StackFrame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.StackFrameType_case()) {
    case kData: {
      mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(from.data());
      break;
    }
    case kRef: {
      set_ref(from.ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
}

void StackFrame::CopyFrom(const StackFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.StackFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackFrame::IsInitialized() const {
  return true;
}

void StackFrame::Swap(StackFrame* other) {
  if (other == this) return;
  InternalSwap(other);
}
void StackFrame::InternalSwap(StackFrame* other) {
  using std::swap;
  swap(StackFrameType_, other->StackFrameType_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::std::string StackFrame::GetTypeName() const {
  return "mozilla.devtools.protobuf.StackFrame";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// StackFrame

// optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
bool StackFrame::has_data() const {
  return StackFrameType_case() == kData;
}
void StackFrame::set_has_data() {
  _oneof_case_[0] = kData;
}
void StackFrame::clear_data() {
  if (has_data()) {
    delete StackFrameType_.data_;
    clear_has_StackFrameType();
  }
}
 const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.data)
  return has_data()
      ? *StackFrameType_.data_
      : ::mozilla::devtools::protobuf::StackFrame_Data::default_instance();
}
::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::mutable_data() {
  if (!has_data()) {
    clear_StackFrameType();
    set_has_data();
    StackFrameType_.data_ = new ::mozilla::devtools::protobuf::StackFrame_Data;
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.data)
  return StackFrameType_.data_;
}
::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::release_data() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.data)
  if (has_data()) {
    clear_has_StackFrameType();
    ::mozilla::devtools::protobuf::StackFrame_Data* temp = StackFrameType_.data_;
    StackFrameType_.data_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void StackFrame::set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) {
  clear_StackFrameType();
  if (data) {
    set_has_data();
    StackFrameType_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.data)
}

// optional uint64 ref = 2;
bool StackFrame::has_ref() const {
  return StackFrameType_case() == kRef;
}
void StackFrame::set_has_ref() {
  _oneof_case_[0] = kRef;
}
void StackFrame::clear_ref() {
  if (has_ref()) {
    StackFrameType_.ref_ = GOOGLE_ULONGLONG(0);
    clear_has_StackFrameType();
  }
}
::google::protobuf::uint64 StackFrame::ref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.ref)
  if (has_ref()) {
    return StackFrameType_.ref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void StackFrame::set_ref(::google::protobuf::uint64 value) {
  if (!has_ref()) {
    clear_StackFrameType();
    set_has_ref();
  }
  StackFrameType_.ref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.ref)
}

bool StackFrame::has_StackFrameType() const {
  return StackFrameType_case() != STACKFRAMETYPE_NOT_SET;
}
void StackFrame::clear_has_StackFrameType() {
  _oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
}
StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const {
  return StackFrame::StackFrameTypeCase(_oneof_case_[0]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Node::kIdFieldNumber;
const int Node::kTypeNameFieldNumber;
const int Node::kTypeNameRefFieldNumber;
const int Node::kSizeFieldNumber;
const int Node::kEdgesFieldNumber;
const int Node::kAllocationStackFieldNumber;
const int Node::kJsObjectClassNameFieldNumber;
const int Node::kJsObjectClassNameRefFieldNumber;
const int Node::kCoarseTypeFieldNumber;
const int Node::kScriptFilenameFieldNumber;
const int Node::kScriptFilenameRefFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Node::Node()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_CoreDump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Node)
}
Node::Node(const Node& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      edges_(from.edges_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_allocationstack()) {
    allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame(*from.allocationstack_);
  } else {
    allocationstack_ = NULL;
  }
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&coarsetype_) -
    reinterpret_cast<char*>(&id_)) + sizeof(coarsetype_));
  clear_has_TypeNameOrRef();
  switch (from.TypeNameOrRef_case()) {
    case kTypeName: {
      set_typename_(from.typename_());
      break;
    }
    case kTypeNameRef: {
      set_typenameref(from.typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_JSObjectClassNameOrRef();
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      set_jsobjectclassname(from.jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      set_jsobjectclassnameref(from.jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_ScriptFilenameOrRef();
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      set_scriptfilename(from.scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      set_scriptfilenameref(from.scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Node)
}

void Node::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&allocationstack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&coarsetype_) -
      reinterpret_cast<char*>(&allocationstack_)) + sizeof(coarsetype_));
  clear_has_TypeNameOrRef();
  clear_has_JSObjectClassNameOrRef();
  clear_has_ScriptFilenameOrRef();
}

Node::~Node() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Node)
  SharedDtor();
}

void Node::SharedDtor() {
  if (this != internal_default_instance()) delete allocationstack_;
  if (has_TypeNameOrRef()) {
    clear_TypeNameOrRef();
  }
  if (has_JSObjectClassNameOrRef()) {
    clear_JSObjectClassNameOrRef();
  }
  if (has_ScriptFilenameOrRef()) {
    clear_ScriptFilenameOrRef();
  }
}

void Node::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Node& Node::default_instance() {
  protobuf_CoreDump_2eproto::InitDefaults();
  return *internal_default_instance();
}

Node* Node::New(::google::protobuf::Arena* arena) const {
  Node* n = new Node;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Node::clear_TypeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (TypeNameOrRef_case()) {
    case kTypeName: {
      TypeNameOrRef_.typename__.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kTypeNameRef: {
      // No need to clear
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = TYPENAMEORREF_NOT_SET;
}

void Node::clear_JSObjectClassNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      JSObjectClassNameOrRef_.jsobjectclassname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kJsObjectClassNameRef: {
      // No need to clear
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET;
}

void Node::clear_ScriptFilenameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      ScriptFilenameOrRef_.scriptfilename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kScriptFilenameRef: {
      // No need to clear
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET;
}


void Node::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.Node)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  edges_.Clear();
  if (has_allocationstack()) {
    GOOGLE_DCHECK(allocationstack_ != NULL);
    allocationstack_->::mozilla::devtools::protobuf::StackFrame::Clear();
  }
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 14u) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&coarsetype_) -
        reinterpret_cast<char*>(&id_)) + sizeof(coarsetype_));
  }
  clear_TypeNameOrRef();
  clear_JSObjectClassNameOrRef();
  clear_ScriptFilenameOrRef();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Node::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.Node)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes typeName = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_typename_()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 typeNameRef = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          clear_TypeNameOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &TypeNameOrRef_.typenameref_)));
          set_has_typenameref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 size = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .mozilla.devtools.protobuf.Edge edges = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_edges()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_allocationstack()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes jsObjectClassName = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_jsobjectclassname()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 jsObjectClassNameRef = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          clear_JSObjectClassNameOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &JSObjectClassNameOrRef_.jsobjectclassnameref_)));
          set_has_jsobjectclassnameref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 coarseType = 9 [default = 0];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_coarsetype();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &coarsetype_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes scriptFilename = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_scriptfilename()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 scriptFilenameRef = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          clear_ScriptFilenameOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &ScriptFilenameOrRef_.scriptfilenameref_)));
          set_has_scriptfilenameref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.Node)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.Node)
  return false;
#undef DO_
}

void Node::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.Node)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->id(), output);
  }

  switch (TypeNameOrRef_case()) {
    case kTypeName:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        2, this->typename_(), output);
      break;
    case kTypeNameRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->typenameref(), output);
      break;
    default: ;
  }
  // optional uint64 size = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->size(), output);
  }

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->edges_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->edges(static_cast<int>(i)), output);
  }

  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, *this->allocationstack_, output);
  }

  switch (JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        7, this->jsobjectclassname(), output);
      break;
    case kJsObjectClassNameRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->jsobjectclassnameref(), output);
      break;
    default: ;
  }
  // optional uint32 coarseType = 9 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->coarsetype(), output);
  }

  switch (ScriptFilenameOrRef_case()) {
    case kScriptFilename:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        10, this->scriptfilename(), output);
      break;
    case kScriptFilenameRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(11, this->scriptfilenameref(), output);
      break;
    default: ;
  }
  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.Node)
}

size_t Node::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.Node)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->edges_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->edges(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 15u) {
    // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
    if (has_allocationstack()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->allocationstack_);
    }

    // optional uint64 id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->id());
    }

    // optional uint64 size = 4;
    if (has_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->size());
    }

    // optional uint32 coarseType = 9 [default = 0];
    if (has_coarsetype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->coarsetype());
    }

  }
  switch (TypeNameOrRef_case()) {
    // optional bytes typeName = 2;
    case kTypeName: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->typename_());
      break;
    }
    // optional uint64 typeNameRef = 3;
    case kTypeNameRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (JSObjectClassNameOrRef_case()) {
    // optional bytes jsObjectClassName = 7;
    case kJsObjectClassName: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->jsobjectclassname());
      break;
    }
    // optional uint64 jsObjectClassNameRef = 8;
    case kJsObjectClassNameRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (ScriptFilenameOrRef_case()) {
    // optional bytes scriptFilename = 10;
    case kScriptFilename: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->scriptfilename());
      break;
    }
    // optional uint64 scriptFilenameRef = 11;
    case kScriptFilenameRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Node::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Node*>(&from));
}

void Node::MergeFrom(const Node& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.Node)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  edges_.MergeFrom(from.edges_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_allocationstack()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from.allocationstack());
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      coarsetype_ = from.coarsetype_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.TypeNameOrRef_case()) {
    case kTypeName: {
      set_typename_(from.typename_());
      break;
    }
    case kTypeNameRef: {
      set_typenameref(from.typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      set_jsobjectclassname(from.jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      set_jsobjectclassnameref(from.jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      set_scriptfilename(from.scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      set_scriptfilenameref(from.scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
}

void Node::CopyFrom(const Node& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.Node)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Node::IsInitialized() const {
  return true;
}

void Node::Swap(Node* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Node::InternalSwap(Node* other) {
  using std::swap;
  edges_.InternalSwap(&other->edges_);
  swap(allocationstack_, other->allocationstack_);
  swap(id_, other->id_);
  swap(size_, other->size_);
  swap(coarsetype_, other->coarsetype_);
  swap(TypeNameOrRef_, other->TypeNameOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(JSObjectClassNameOrRef_, other->JSObjectClassNameOrRef_);
  swap(_oneof_case_[1], other->_oneof_case_[1]);
  swap(ScriptFilenameOrRef_, other->ScriptFilenameOrRef_);
  swap(_oneof_case_[2], other->_oneof_case_[2]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::std::string Node::GetTypeName() const {
  return "mozilla.devtools.protobuf.Node";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Node

// optional uint64 id = 1;
bool Node::has_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Node::set_has_id() {
  _has_bits_[0] |= 0x00000002u;
}
void Node::clear_has_id() {
  _has_bits_[0] &= ~0x00000002u;
}
void Node::clear_id() {
  id_ = GOOGLE_ULONGLONG(0);
  clear_has_id();
}
::google::protobuf::uint64 Node::id() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.id)
  return id_;
}
void Node::set_id(::google::protobuf::uint64 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.id)
}

// optional bytes typeName = 2;
bool Node::has_typename_() const {
  return TypeNameOrRef_case() == kTypeName;
}
void Node::set_has_typename_() {
  _oneof_case_[0] = kTypeName;
}
void Node::clear_typename_() {
  if (has_typename_()) {
    TypeNameOrRef_.typename__.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_TypeNameOrRef();
  }
}
const ::std::string& Node::typename_() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeName)
  if (has_typename_()) {
    return TypeNameOrRef_.typename__.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void Node::set_typename_(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName)
  if (!has_typename_()) {
    clear_TypeNameOrRef();
    set_has_typename_();
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  TypeNameOrRef_.typename__.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName)
}
#if LANG_CXX11
void Node::set_typename_(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName)
  if (!has_typename_()) {
    clear_TypeNameOrRef();
    set_has_typename_();
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  TypeNameOrRef_.typename__.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.Node.typeName)
}
#endif
void Node::set_typename_(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_typename_()) {
    clear_TypeNameOrRef();
    set_has_typename_();
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  TypeNameOrRef_.typename__.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.Node.typeName)
}
void Node::set_typename_(const void* value, size_t size) {
  if (!has_typename_()) {
    clear_TypeNameOrRef();
    set_has_typename_();
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  TypeNameOrRef_.typename__.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.Node.typeName)
}
::std::string* Node::mutable_typename_() {
  if (!has_typename_()) {
    clear_TypeNameOrRef();
    set_has_typename_();
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.typeName)
  return TypeNameOrRef_.typename__.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Node::release_typename_() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.typeName)
  if (has_typename_()) {
    clear_has_TypeNameOrRef();
    return TypeNameOrRef_.typename__.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void Node::set_allocated_typename_(::std::string* typename_) {
  if (!has_typename_()) {
    TypeNameOrRef_.typename__.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_TypeNameOrRef();
  if (typename_ != NULL) {
    set_has_typename_();
    TypeNameOrRef_.typename__.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        typename_);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.typeName)
}

// optional uint64 typeNameRef = 3;
bool Node::has_typenameref() const {
  return TypeNameOrRef_case() == kTypeNameRef;
}
void Node::set_has_typenameref() {
  _oneof_case_[0] = kTypeNameRef;
}
void Node::clear_typenameref() {
  if (has_typenameref()) {
    TypeNameOrRef_.typenameref_ = GOOGLE_ULONGLONG(0);
    clear_has_TypeNameOrRef();
  }
}
::google::protobuf::uint64 Node::typenameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeNameRef)
  if (has_typenameref()) {
    return TypeNameOrRef_.typenameref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void Node::set_typenameref(::google::protobuf::uint64 value) {
  if (!has_typenameref()) {
    clear_TypeNameOrRef();
    set_has_typenameref();
  }
  TypeNameOrRef_.typenameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeNameRef)
}

// optional uint64 size = 4;
bool Node::has_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Node::set_has_size() {
  _has_bits_[0] |= 0x00000004u;
}
void Node::clear_has_size() {
  _has_bits_[0] &= ~0x00000004u;
}
void Node::clear_size() {
  size_ = GOOGLE_ULONGLONG(0);
  clear_has_size();
}
::google::protobuf::uint64 Node::size() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.size)
  return size_;
}
void Node::set_size(::google::protobuf::uint64 value) {
  set_has_size();
  size_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.size)
}

// repeated .mozilla.devtools.protobuf.Edge edges = 5;
int Node::edges_size() const {
  return edges_.size();
}
void Node::clear_edges() {
  edges_.Clear();
}
const ::mozilla::devtools::protobuf::Edge& Node::edges(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.edges)
  return edges_.Get(index);
}
::mozilla::devtools::protobuf::Edge* Node::mutable_edges(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.edges)
  return edges_.Mutable(index);
}
::mozilla::devtools::protobuf::Edge* Node::add_edges() {
  // @@protoc_insertion_point(field_add:mozilla.devtools.protobuf.Node.edges)
  return edges_.Add();
}
::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >*
Node::mutable_edges() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges)
  return &edges_;
}
const ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >&
Node::edges() const {
  // @@protoc_insertion_point(field_list:mozilla.devtools.protobuf.Node.edges)
  return edges_;
}

// optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
bool Node::has_allocationstack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Node::set_has_allocationstack() {
  _has_bits_[0] |= 0x00000001u;
}
void Node::clear_has_allocationstack() {
  _has_bits_[0] &= ~0x00000001u;
}
void Node::clear_allocationstack() {
  if (allocationstack_ != NULL) allocationstack_->::mozilla::devtools::protobuf::StackFrame::Clear();
  clear_has_allocationstack();
}
const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const {
  const ::mozilla::devtools::protobuf::StackFrame* p = allocationstack_;
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack)
  return p != NULL ? *p : *reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame*>(
      &::mozilla::devtools::protobuf::_StackFrame_default_instance_);
}
::mozilla::devtools::protobuf::StackFrame* Node::mutable_allocationstack() {
  set_has_allocationstack();
  if (allocationstack_ == NULL) {
    allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame;
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack)
  return allocationstack_;
}
::mozilla::devtools::protobuf::StackFrame* Node::release_allocationstack() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.allocationStack)
  clear_has_allocationstack();
  ::mozilla::devtools::protobuf::StackFrame* temp = allocationstack_;
  allocationstack_ = NULL;
  return temp;
}
void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack) {
  delete allocationstack_;
  allocationstack_ = allocationstack;
  if (allocationstack) {
    set_has_allocationstack();
  } else {
    clear_has_allocationstack();
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack)
}

// optional bytes jsObjectClassName = 7;
bool Node::has_jsobjectclassname() const {
  return JSObjectClassNameOrRef_case() == kJsObjectClassName;
}
void Node::set_has_jsobjectclassname() {
  _oneof_case_[1] = kJsObjectClassName;
}
void Node::clear_jsobjectclassname() {
  if (has_jsobjectclassname()) {
    JSObjectClassNameOrRef_.jsobjectclassname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_JSObjectClassNameOrRef();
  }
}
const ::std::string& Node::jsobjectclassname() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassName)
  if (has_jsobjectclassname()) {
    return JSObjectClassNameOrRef_.jsobjectclassname_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void Node::set_jsobjectclassname(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName)
  if (!has_jsobjectclassname()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  JSObjectClassNameOrRef_.jsobjectclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName)
}
#if LANG_CXX11
void Node::set_jsobjectclassname(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName)
  if (!has_jsobjectclassname()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  JSObjectClassNameOrRef_.jsobjectclassname_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.Node.jsObjectClassName)
}
#endif
void Node::set_jsobjectclassname(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_jsobjectclassname()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  JSObjectClassNameOrRef_.jsobjectclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.Node.jsObjectClassName)
}
void Node::set_jsobjectclassname(const void* value, size_t size) {
  if (!has_jsobjectclassname()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  JSObjectClassNameOrRef_.jsobjectclassname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.Node.jsObjectClassName)
}
::std::string* Node::mutable_jsobjectclassname() {
  if (!has_jsobjectclassname()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.jsObjectClassName)
  return JSObjectClassNameOrRef_.jsobjectclassname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Node::release_jsobjectclassname() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.jsObjectClassName)
  if (has_jsobjectclassname()) {
    clear_has_JSObjectClassNameOrRef();
    return JSObjectClassNameOrRef_.jsobjectclassname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void Node::set_allocated_jsobjectclassname(::std::string* jsobjectclassname) {
  if (!has_jsobjectclassname()) {
    JSObjectClassNameOrRef_.jsobjectclassname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_JSObjectClassNameOrRef();
  if (jsobjectclassname != NULL) {
    set_has_jsobjectclassname();
    JSObjectClassNameOrRef_.jsobjectclassname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        jsobjectclassname);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.jsObjectClassName)
}

// optional uint64 jsObjectClassNameRef = 8;
bool Node::has_jsobjectclassnameref() const {
  return JSObjectClassNameOrRef_case() == kJsObjectClassNameRef;
}
void Node::set_has_jsobjectclassnameref() {
  _oneof_case_[1] = kJsObjectClassNameRef;
}
void Node::clear_jsobjectclassnameref() {
  if (has_jsobjectclassnameref()) {
    JSObjectClassNameOrRef_.jsobjectclassnameref_ = GOOGLE_ULONGLONG(0);
    clear_has_JSObjectClassNameOrRef();
  }
}
::google::protobuf::uint64 Node::jsobjectclassnameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassNameRef)
  if (has_jsobjectclassnameref()) {
    return JSObjectClassNameOrRef_.jsobjectclassnameref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void Node::set_jsobjectclassnameref(::google::protobuf::uint64 value) {
  if (!has_jsobjectclassnameref()) {
    clear_JSObjectClassNameOrRef();
    set_has_jsobjectclassnameref();
  }
  JSObjectClassNameOrRef_.jsobjectclassnameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassNameRef)
}

// optional uint32 coarseType = 9 [default = 0];
bool Node::has_coarsetype() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Node::set_has_coarsetype() {
  _has_bits_[0] |= 0x00000008u;
}
void Node::clear_has_coarsetype() {
  _has_bits_[0] &= ~0x00000008u;
}
void Node::clear_coarsetype() {
  coarsetype_ = 0u;
  clear_has_coarsetype();
}
::google::protobuf::uint32 Node::coarsetype() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.coarseType)
  return coarsetype_;
}
void Node::set_coarsetype(::google::protobuf::uint32 value) {
  set_has_coarsetype();
  coarsetype_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.coarseType)
}

// optional bytes scriptFilename = 10;
bool Node::has_scriptfilename() const {
  return ScriptFilenameOrRef_case() == kScriptFilename;
}
void Node::set_has_scriptfilename() {
  _oneof_case_[2] = kScriptFilename;
}
void Node::clear_scriptfilename() {
  if (has_scriptfilename()) {
    ScriptFilenameOrRef_.scriptfilename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_ScriptFilenameOrRef();
  }
}
const ::std::string& Node::scriptfilename() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilename)
  if (has_scriptfilename()) {
    return ScriptFilenameOrRef_.scriptfilename_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void Node::set_scriptfilename(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename)
  if (!has_scriptfilename()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ScriptFilenameOrRef_.scriptfilename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename)
}
#if LANG_CXX11
void Node::set_scriptfilename(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename)
  if (!has_scriptfilename()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ScriptFilenameOrRef_.scriptfilename_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.Node.scriptFilename)
}
#endif
void Node::set_scriptfilename(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_scriptfilename()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ScriptFilenameOrRef_.scriptfilename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.Node.scriptFilename)
}
void Node::set_scriptfilename(const void* value, size_t size) {
  if (!has_scriptfilename()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ScriptFilenameOrRef_.scriptfilename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.Node.scriptFilename)
}
::std::string* Node::mutable_scriptfilename() {
  if (!has_scriptfilename()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.scriptFilename)
  return ScriptFilenameOrRef_.scriptfilename_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Node::release_scriptfilename() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.scriptFilename)
  if (has_scriptfilename()) {
    clear_has_ScriptFilenameOrRef();
    return ScriptFilenameOrRef_.scriptfilename_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void Node::set_allocated_scriptfilename(::std::string* scriptfilename) {
  if (!has_scriptfilename()) {
    ScriptFilenameOrRef_.scriptfilename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_ScriptFilenameOrRef();
  if (scriptfilename != NULL) {
    set_has_scriptfilename();
    ScriptFilenameOrRef_.scriptfilename_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        scriptfilename);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.scriptFilename)
}

// optional uint64 scriptFilenameRef = 11;
bool Node::has_scriptfilenameref() const {
  return ScriptFilenameOrRef_case() == kScriptFilenameRef;
}
void Node::set_has_scriptfilenameref() {
  _oneof_case_[2] = kScriptFilenameRef;
}
void Node::clear_scriptfilenameref() {
  if (has_scriptfilenameref()) {
    ScriptFilenameOrRef_.scriptfilenameref_ = GOOGLE_ULONGLONG(0);
    clear_has_ScriptFilenameOrRef();
  }
}
::google::protobuf::uint64 Node::scriptfilenameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilenameRef)
  if (has_scriptfilenameref()) {
    return ScriptFilenameOrRef_.scriptfilenameref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void Node::set_scriptfilenameref(::google::protobuf::uint64 value) {
  if (!has_scriptfilenameref()) {
    clear_ScriptFilenameOrRef();
    set_has_scriptfilenameref();
  }
  ScriptFilenameOrRef_.scriptfilenameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilenameRef)
}

bool Node::has_TypeNameOrRef() const {
  return TypeNameOrRef_case() != TYPENAMEORREF_NOT_SET;
}
void Node::clear_has_TypeNameOrRef() {
  _oneof_case_[0] = TYPENAMEORREF_NOT_SET;
}
bool Node::has_JSObjectClassNameOrRef() const {
  return JSObjectClassNameOrRef_case() != JSOBJECTCLASSNAMEORREF_NOT_SET;
}
void Node::clear_has_JSObjectClassNameOrRef() {
  _oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET;
}
bool Node::has_ScriptFilenameOrRef() const {
  return ScriptFilenameOrRef_case() != SCRIPTFILENAMEORREF_NOT_SET;
}
void Node::clear_has_ScriptFilenameOrRef() {
  _oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET;
}
Node::TypeNameOrRefCase Node::TypeNameOrRef_case() const {
  return Node::TypeNameOrRefCase(_oneof_case_[0]);
}
Node::JSObjectClassNameOrRefCase Node::JSObjectClassNameOrRef_case() const {
  return Node::JSObjectClassNameOrRefCase(_oneof_case_[1]);
}
Node::ScriptFilenameOrRefCase Node::ScriptFilenameOrRef_case() const {
  return Node::ScriptFilenameOrRefCase(_oneof_case_[2]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Edge::kReferentFieldNumber;
const int Edge::kNameFieldNumber;
const int Edge::kNameRefFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Edge::Edge()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_CoreDump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Edge)
}
Edge::Edge(const Edge& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  referent_ = from.referent_;
  clear_has_EdgeNameOrRef();
  switch (from.EdgeNameOrRef_case()) {
    case kName: {
      set_name(from.name());
      break;
    }
    case kNameRef: {
      set_nameref(from.nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Edge)
}

void Edge::SharedCtor() {
  _cached_size_ = 0;
  referent_ = GOOGLE_ULONGLONG(0);
  clear_has_EdgeNameOrRef();
}

Edge::~Edge() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Edge)
  SharedDtor();
}

void Edge::SharedDtor() {
  if (has_EdgeNameOrRef()) {
    clear_EdgeNameOrRef();
  }
}

void Edge::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Edge& Edge::default_instance() {
  protobuf_CoreDump_2eproto::InitDefaults();
  return *internal_default_instance();
}

Edge* Edge::New(::google::protobuf::Arena* arena) const {
  Edge* n = new Edge;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Edge::clear_EdgeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Edge)
  switch (EdgeNameOrRef_case()) {
    case kName: {
      EdgeNameOrRef_.name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kNameRef: {
      // No need to clear
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EDGENAMEORREF_NOT_SET;
}


void Edge::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.Edge)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  referent_ = GOOGLE_ULONGLONG(0);
  clear_EdgeNameOrRef();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Edge::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.Edge)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 referent = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_referent();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &referent_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes name = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 nameRef = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          clear_EdgeNameOrRef();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &EdgeNameOrRef_.nameref_)));
          set_has_nameref();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.Edge)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.Edge)
  return false;
#undef DO_
}

void Edge::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.Edge)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 referent = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->referent(), output);
  }

  switch (EdgeNameOrRef_case()) {
    case kName:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        2, this->name(), output);
      break;
    case kNameRef:
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->nameref(), output);
      break;
    default: ;
  }
  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.Edge)
}

size_t Edge::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.Edge)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  // optional uint64 referent = 1;
  if (has_referent()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt64Size(
        this->referent());
  }

  switch (EdgeNameOrRef_case()) {
    // optional bytes name = 2;
    case kName: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->name());
      break;
    }
    // optional uint64 nameRef = 3;
    case kNameRef: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Edge::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Edge*>(&from));
}

void Edge::MergeFrom(const Edge& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.Edge)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_referent()) {
    set_referent(from.referent());
  }
  switch (from.EdgeNameOrRef_case()) {
    case kName: {
      set_name(from.name());
      break;
    }
    case kNameRef: {
      set_nameref(from.nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
}

void Edge::CopyFrom(const Edge& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.Edge)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Edge::IsInitialized() const {
  return true;
}

void Edge::Swap(Edge* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Edge::InternalSwap(Edge* other) {
  using std::swap;
  swap(referent_, other->referent_);
  swap(EdgeNameOrRef_, other->EdgeNameOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::std::string Edge::GetTypeName() const {
  return "mozilla.devtools.protobuf.Edge";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Edge

// optional uint64 referent = 1;
bool Edge::has_referent() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Edge::set_has_referent() {
  _has_bits_[0] |= 0x00000001u;
}
void Edge::clear_has_referent() {
  _has_bits_[0] &= ~0x00000001u;
}
void Edge::clear_referent() {
  referent_ = GOOGLE_ULONGLONG(0);
  clear_has_referent();
}
::google::protobuf::uint64 Edge::referent() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.referent)
  return referent_;
}
void Edge::set_referent(::google::protobuf::uint64 value) {
  set_has_referent();
  referent_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.referent)
}

// optional bytes name = 2;
bool Edge::has_name() const {
  return EdgeNameOrRef_case() == kName;
}
void Edge::set_has_name() {
  _oneof_case_[0] = kName;
}
void Edge::clear_name() {
  if (has_name()) {
    EdgeNameOrRef_.name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_EdgeNameOrRef();
  }
}
const ::std::string& Edge::name() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.name)
  if (has_name()) {
    return EdgeNameOrRef_.name_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void Edge::set_name(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name)
  if (!has_name()) {
    clear_EdgeNameOrRef();
    set_has_name();
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  EdgeNameOrRef_.name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name)
}
#if LANG_CXX11
void Edge::set_name(::std::string&& value) {
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name)
  if (!has_name()) {
    clear_EdgeNameOrRef();
    set_has_name();
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  EdgeNameOrRef_.name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mozilla.devtools.protobuf.Edge.name)
}
#endif
void Edge::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_name()) {
    clear_EdgeNameOrRef();
    set_has_name();
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  EdgeNameOrRef_.name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.Edge.name)
}
void Edge::set_name(const void* value, size_t size) {
  if (!has_name()) {
    clear_EdgeNameOrRef();
    set_has_name();
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  EdgeNameOrRef_.name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.Edge.name)
}
::std::string* Edge::mutable_name() {
  if (!has_name()) {
    clear_EdgeNameOrRef();
    set_has_name();
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Edge.name)
  return EdgeNameOrRef_.name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Edge::release_name() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Edge.name)
  if (has_name()) {
    clear_has_EdgeNameOrRef();
    return EdgeNameOrRef_.name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void Edge::set_allocated_name(::std::string* name) {
  if (!has_name()) {
    EdgeNameOrRef_.name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_EdgeNameOrRef();
  if (name != NULL) {
    set_has_name();
    EdgeNameOrRef_.name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        name);
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Edge.name)
}

// optional uint64 nameRef = 3;
bool Edge::has_nameref() const {
  return EdgeNameOrRef_case() == kNameRef;
}
void Edge::set_has_nameref() {
  _oneof_case_[0] = kNameRef;
}
void Edge::clear_nameref() {
  if (has_nameref()) {
    EdgeNameOrRef_.nameref_ = GOOGLE_ULONGLONG(0);
    clear_has_EdgeNameOrRef();
  }
}
::google::protobuf::uint64 Edge::nameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.nameRef)
  if (has_nameref()) {
    return EdgeNameOrRef_.nameref_;
  }
  return GOOGLE_ULONGLONG(0);
}
void Edge::set_nameref(::google::protobuf::uint64 value) {
  if (!has_nameref()) {
    clear_EdgeNameOrRef();
    set_has_nameref();
  }
  EdgeNameOrRef_.nameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.nameRef)
}

bool Edge::has_EdgeNameOrRef() const {
  return EdgeNameOrRef_case() != EDGENAMEORREF_NOT_SET;
}
void Edge::clear_has_EdgeNameOrRef() {
  _oneof_case_[0] = EDGENAMEORREF_NOT_SET;
}
Edge::EdgeNameOrRefCase Edge::EdgeNameOrRef_case() const {
  return Edge::EdgeNameOrRefCase(_oneof_case_[0]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla

// @@protoc_insertion_point(global_scope)
