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

#include "CoreDump.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_CoreDump_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Edge_CoreDump_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_CoreDump_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StackFrame_CoreDump_2eproto;
namespace mozilla {
namespace devtools {
namespace protobuf {
class MetadataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Metadata> _instance;
} _Metadata_default_instance_;
class StackFrame_DataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StackFrame_Data> _instance;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
  ::PROTOBUF_NAMESPACE_ID::uint64 sourceref_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr functiondisplayname_;
  ::PROTOBUF_NAMESPACE_ID::uint64 functiondisplaynameref_;
} _StackFrame_Data_default_instance_;
class StackFrameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StackFrame> _instance;
  const ::mozilla::devtools::protobuf::StackFrame_Data* data_;
  ::PROTOBUF_NAMESPACE_ID::uint64 ref_;
} _StackFrame_default_instance_;
class NodeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Node> _instance;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr typename__;
  ::PROTOBUF_NAMESPACE_ID::uint64 typenameref_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jsobjectclassname_;
  ::PROTOBUF_NAMESPACE_ID::uint64 jsobjectclassnameref_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scriptfilename_;
  ::PROTOBUF_NAMESPACE_ID::uint64 scriptfilenameref_;
} _Node_default_instance_;
class EdgeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Edge> _instance;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::uint64 nameref_;
} _Edge_default_instance_;
}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla
static void InitDefaultsscc_info_Edge_CoreDump_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::mozilla::devtools::protobuf::_Edge_default_instance_;
    new (ptr) ::mozilla::devtools::protobuf::Edge();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::mozilla::devtools::protobuf::Edge::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Edge_CoreDump_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Edge_CoreDump_2eproto}, {}};

static void InitDefaultsscc_info_Metadata_CoreDump_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::mozilla::devtools::protobuf::_Metadata_default_instance_;
    new (ptr) ::mozilla::devtools::protobuf::Metadata();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::mozilla::devtools::protobuf::Metadata::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Metadata_CoreDump_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Metadata_CoreDump_2eproto}, {}};

static void InitDefaultsscc_info_Node_CoreDump_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::mozilla::devtools::protobuf::_Node_default_instance_;
    new (ptr) ::mozilla::devtools::protobuf::Node();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::mozilla::devtools::protobuf::Node::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Node_CoreDump_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_Node_CoreDump_2eproto}, {
      &scc_info_Edge_CoreDump_2eproto.base,
      &scc_info_StackFrame_CoreDump_2eproto.base,}};

static void InitDefaultsscc_info_StackFrame_CoreDump_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::mozilla::devtools::protobuf::_StackFrame_Data_default_instance_;
    new (ptr) ::mozilla::devtools::protobuf::StackFrame_Data();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  {
    void* ptr = &::mozilla::devtools::protobuf::_StackFrame_default_instance_;
    new (ptr) ::mozilla::devtools::protobuf::StackFrame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::mozilla::devtools::protobuf::StackFrame_Data::InitAsDefaultInstance();
  ::mozilla::devtools::protobuf::StackFrame::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StackFrame_CoreDump_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StackFrame_CoreDump_2eproto}, {}};

namespace mozilla {
namespace devtools {
namespace protobuf {

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

void Metadata::InitAsDefaultInstance() {
}
class Metadata::_Internal {
 public:
  using HasBits = decltype(std::declval<Metadata>()._has_bits_);
  static void set_has_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Metadata::Metadata()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Metadata)
}
Metadata::Metadata(const Metadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  timestamp_ = from.timestamp_;
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Metadata)
}

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

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

void Metadata::SharedDtor() {
}

void Metadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Metadata& Metadata::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Metadata_CoreDump_2eproto.base);
  return *internal_default_instance();
}


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

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

const char* Metadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 timeStamp = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_timestamp(&has_bits);
          timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Metadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.Metadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 timeStamp = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_timestamp(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Metadata)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 timeStamp = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_timestamp());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Metadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<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_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_timestamp()) {
    _internal_set_timestamp(from._internal_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::InternalSwap(Metadata* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(timestamp_, other->timestamp_);
}

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


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

void StackFrame_Data::InitAsDefaultInstance() {
  ::mozilla::devtools::protobuf::_StackFrame_Data_default_instance_._instance.get_mutable()->parent_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(
      ::mozilla::devtools::protobuf::StackFrame::internal_default_instance());
}
class StackFrame_Data::_Internal {
 public:
  using HasBits = decltype(std::declval<StackFrame_Data>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::mozilla::devtools::protobuf::StackFrame& parent(const StackFrame_Data* msg);
  static void set_has_parent(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_line(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_column(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_issystem(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_isselfhosted(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::mozilla::devtools::protobuf::StackFrame&
StackFrame_Data::_Internal::parent(const StackFrame_Data* msg) {
  return *msg->parent_;
}
StackFrame_Data::StackFrame_Data()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame.Data)
}
StackFrame_Data::StackFrame_Data(const StackFrame_Data& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_parent()) {
    parent_ = new ::mozilla::devtools::protobuf::StackFrame(*from.parent_);
  } else {
    parent_ = nullptr;
  }
  ::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: {
      _internal_set_source(from._internal_source());
      break;
    }
    case kSourceRef: {
      _internal_set_sourceref(from._internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_FunctionDisplayNameOrRef();
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      _internal_set_functiondisplayname(from._internal_functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      _internal_set_functiondisplaynameref(from._internal_functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame.Data)
}

void StackFrame_Data::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StackFrame_CoreDump_2eproto.base);
  ::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 {
  _cached_size_.Set(size);
}
const StackFrame_Data& StackFrame_Data::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StackFrame_CoreDump_2eproto.base);
  return *internal_default_instance();
}


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(&::PROTOBUF_NAMESPACE_ID::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(&::PROTOBUF_NAMESPACE_ID::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)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(parent_ != nullptr);
    parent_->Clear();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::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();
}

const char* StackFrame_Data::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_parent(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 line = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_line(&has_bits);
          line_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 column = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_column(&has_bits);
          column_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes source = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_source();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 sourceRef = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _internal_set_sourceref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes functionDisplayName = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_functiondisplayname();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 functionDisplayNameRef = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _internal_set_functiondisplaynameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool isSystem = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_issystem(&has_bits);
          issystem_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool isSelfHosted = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_isselfhosted(&has_bits);
          isselfhosted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* StackFrame_Data::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame.Data)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
  }

  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::parent(this), target, stream);
  }

  // optional uint32 line = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_line(), target);
  }

  // optional uint32 column = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_column(), target);
  }

  switch (SourceOrRef_case()) {
    case kSource: {
      target = stream->WriteBytesMaybeAliased(
          5, this->_internal_source(), target);
      break;
    }
    case kSourceRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_sourceref(), target);
      break;
    }
    default: ;
  }
  switch (FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      target = stream->WriteBytesMaybeAliased(
          7, this->_internal_functiondisplayname(), target);
      break;
    }
    case kFunctionDisplayNameRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_functiondisplaynameref(), target);
      break;
    }
    default: ;
  }
  // optional bool isSystem = 9;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_issystem(), target);
  }

  // optional bool isSelfHosted = 10;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_isselfhosted(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame.Data)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *parent_);
    }

    // optional uint64 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_id());
    }

    // optional uint32 line = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_line());
    }

    // optional uint32 column = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_column());
    }

    // optional bool isSystem = 9;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool isSelfHosted = 10;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  switch (SourceOrRef_case()) {
    // optional bytes source = 5;
    case kSource: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_source());
      break;
    }
    // optional uint64 sourceRef = 6;
    case kSourceRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (FunctionDisplayNameOrRef_case()) {
    // optional bytes functionDisplayName = 7;
    case kFunctionDisplayName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_functiondisplayname());
      break;
    }
    // optional uint64 functionDisplayNameRef = 8;
    case kFunctionDisplayNameRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StackFrame_Data::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<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_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_parent()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from._internal_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: {
      _internal_set_source(from._internal_source());
      break;
    }
    case kSourceRef: {
      _internal_set_sourceref(from._internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      _internal_set_functiondisplayname(from._internal_functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      _internal_set_functiondisplaynameref(from._internal_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::InternalSwap(StackFrame_Data* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  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(FunctionDisplayNameOrRef_, other->FunctionDisplayNameOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_oneof_case_[1], other->_oneof_case_[1]);
}

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


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

void StackFrame::InitAsDefaultInstance() {
}
class StackFrame::_Internal {
 public:
  using HasBits = decltype(std::declval<StackFrame>()._has_bits_);
  static const ::mozilla::devtools::protobuf::StackFrame_Data& data(const StackFrame* msg);
};

const ::mozilla::devtools::protobuf::StackFrame_Data&
StackFrame::_Internal::data(const StackFrame* msg) {
  return *msg->StackFrameType_.data_;
}
void StackFrame::set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_StackFrameType();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    StackFrameType_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.data)
}
StackFrame::StackFrame()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame)
}
StackFrame::StackFrame(const StackFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_StackFrameType();
  switch (from.StackFrameType_case()) {
    case kData: {
      _internal_mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(from._internal_data());
      break;
    }
    case kRef: {
      _internal_set_ref(from._internal_ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame)
}

void StackFrame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StackFrame_CoreDump_2eproto.base);
  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 {
  _cached_size_.Set(size);
}
const StackFrame& StackFrame::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StackFrame_CoreDump_2eproto.base);
  return *internal_default_instance();
}


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)
  ::PROTOBUF_NAMESPACE_ID::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();
}

const char* StackFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 ref = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _internal_set_ref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* StackFrame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (StackFrameType_case()) {
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::data(this), target, stream);
      break;
    }
    case kRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ref(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (StackFrameType_case()) {
    // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *StackFrameType_.data_);
      break;
    }
    // optional uint64 ref = 2;
    case kRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StackFrame::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<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_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.StackFrameType_case()) {
    case kData: {
      _internal_mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(from._internal_data());
      break;
    }
    case kRef: {
      _internal_set_ref(from._internal_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::InternalSwap(StackFrame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(StackFrameType_, other->StackFrameType_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void Node::InitAsDefaultInstance() {
  ::mozilla::devtools::protobuf::_Node_default_instance_._instance.get_mutable()->allocationstack_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(
      ::mozilla::devtools::protobuf::StackFrame::internal_default_instance());
}
class Node::_Internal {
 public:
  using HasBits = decltype(std::declval<Node>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::mozilla::devtools::protobuf::StackFrame& allocationstack(const Node* msg);
  static void set_has_allocationstack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_coarsetype(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::mozilla::devtools::protobuf::StackFrame&
Node::_Internal::allocationstack(const Node* msg) {
  return *msg->allocationstack_;
}
Node::Node()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Node)
}
Node::Node(const Node& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      edges_(from.edges_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_allocationstack()) {
    allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame(*from.allocationstack_);
  } else {
    allocationstack_ = nullptr;
  }
  ::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: {
      _internal_set_typename_(from._internal_typename_());
      break;
    }
    case kTypeNameRef: {
      _internal_set_typenameref(from._internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_JSObjectClassNameOrRef();
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      _internal_set_jsobjectclassname(from._internal_jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      _internal_set_jsobjectclassnameref(from._internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_ScriptFilenameOrRef();
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      _internal_set_scriptfilename(from._internal_scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      _internal_set_scriptfilenameref(from._internal_scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Node)
}

void Node::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Node_CoreDump_2eproto.base);
  ::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 {
  _cached_size_.Set(size);
}
const Node& Node::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Node_CoreDump_2eproto.base);
  return *internal_default_instance();
}


void Node::clear_TypeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (TypeNameOrRef_case()) {
    case kTypeName: {
      TypeNameOrRef_.typename__.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::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(&::PROTOBUF_NAMESPACE_ID::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(&::PROTOBUF_NAMESPACE_ID::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)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  edges_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(allocationstack_ != nullptr);
    allocationstack_->Clear();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::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();
}

const char* Node::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes typeName = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_typename_();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 typeNameRef = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _internal_set_typenameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 size = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .mozilla.devtools.protobuf.Edge edges = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_edges(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_allocationstack(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes jsObjectClassName = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_jsobjectclassname();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 jsObjectClassNameRef = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _internal_set_jsobjectclassnameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 coarseType = 9 [default = 0];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_coarsetype(&has_bits);
          coarsetype_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes scriptFilename = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          auto str = _internal_mutable_scriptfilename();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 scriptFilenameRef = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _internal_set_scriptfilenameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Node::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.Node)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
  }

  switch (TypeNameOrRef_case()) {
    case kTypeName: {
      target = stream->WriteBytesMaybeAliased(
          2, this->_internal_typename_(), target);
      break;
    }
    case kTypeNameRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->_internal_typenameref(), target);
      break;
    }
    default: ;
  }
  // optional uint64 size = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->_internal_size(), target);
  }

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_edges_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_edges(i), target, stream);
  }

  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::allocationstack(this), target, stream);
  }

  switch (JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      target = stream->WriteBytesMaybeAliased(
          7, this->_internal_jsobjectclassname(), target);
      break;
    }
    case kJsObjectClassNameRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_jsobjectclassnameref(), target);
      break;
    }
    default: ;
  }
  // optional uint32 coarseType = 9 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_coarsetype(), target);
  }

  switch (ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      target = stream->WriteBytesMaybeAliased(
          10, this->_internal_scriptfilename(), target);
      break;
    }
    case kScriptFilenameRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->_internal_scriptfilenameref(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Node)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  total_size += 1UL * this->_internal_edges_size();
  for (const auto& msg : this->edges_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *allocationstack_);
    }

    // optional uint64 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_id());
    }

    // optional uint64 size = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_size());
    }

    // optional uint32 coarseType = 9 [default = 0];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_coarsetype());
    }

  }
  switch (TypeNameOrRef_case()) {
    // optional bytes typeName = 2;
    case kTypeName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_typename_());
      break;
    }
    // optional uint64 typeNameRef = 3;
    case kTypeNameRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (JSObjectClassNameOrRef_case()) {
    // optional bytes jsObjectClassName = 7;
    case kJsObjectClassName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_jsobjectclassname());
      break;
    }
    // optional uint64 jsObjectClassNameRef = 8;
    case kJsObjectClassNameRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (ScriptFilenameOrRef_case()) {
    // optional bytes scriptFilename = 10;
    case kScriptFilename: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_scriptfilename());
      break;
    }
    // optional uint64 scriptFilenameRef = 11;
    case kScriptFilenameRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Node::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<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_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  edges_.MergeFrom(from.edges_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_allocationstack()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from._internal_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: {
      _internal_set_typename_(from._internal_typename_());
      break;
    }
    case kTypeNameRef: {
      _internal_set_typenameref(from._internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      _internal_set_jsobjectclassname(from._internal_jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      _internal_set_jsobjectclassnameref(from._internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      _internal_set_scriptfilename(from._internal_scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      _internal_set_scriptfilenameref(from._internal_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::InternalSwap(Node* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  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(JSObjectClassNameOrRef_, other->JSObjectClassNameOrRef_);
  swap(ScriptFilenameOrRef_, other->ScriptFilenameOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_oneof_case_[1], other->_oneof_case_[1]);
  swap(_oneof_case_[2], other->_oneof_case_[2]);
}

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


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

void Edge::InitAsDefaultInstance() {
}
class Edge::_Internal {
 public:
  using HasBits = decltype(std::declval<Edge>()._has_bits_);
  static void set_has_referent(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Edge::Edge()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Edge)
}
Edge::Edge(const Edge& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  referent_ = from.referent_;
  clear_has_EdgeNameOrRef();
  switch (from.EdgeNameOrRef_case()) {
    case kName: {
      _internal_set_name(from._internal_name());
      break;
    }
    case kNameRef: {
      _internal_set_nameref(from._internal_nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Edge)
}

void Edge::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Edge_CoreDump_2eproto.base);
  referent_ = PROTOBUF_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 {
  _cached_size_.Set(size);
}
const Edge& Edge::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Edge_CoreDump_2eproto.base);
  return *internal_default_instance();
}


void Edge::clear_EdgeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Edge)
  switch (EdgeNameOrRef_case()) {
    case kName: {
      EdgeNameOrRef_.name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::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)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* Edge::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 referent = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_referent(&has_bits);
          referent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 nameRef = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _internal_set_nameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Edge::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.Edge)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 referent = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_referent(), target);
  }

  switch (EdgeNameOrRef_case()) {
    case kName: {
      target = stream->WriteBytesMaybeAliased(
          2, this->_internal_name(), target);
      break;
    }
    case kNameRef: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->_internal_nameref(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Edge)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 referent = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_referent());
  }

  switch (EdgeNameOrRef_case()) {
    // optional bytes name = 2;
    case kName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_name());
      break;
    }
    // optional uint64 nameRef = 3;
    case kNameRef: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Edge::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<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_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_referent()) {
    _internal_set_referent(from._internal_referent());
  }
  switch (from.EdgeNameOrRef_case()) {
    case kName: {
      _internal_set_name(from._internal_name());
      break;
    }
    case kNameRef: {
      _internal_set_nameref(from._internal_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::InternalSwap(Edge* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(referent_, other->referent_);
  swap(EdgeNameOrRef_, other->EdgeNameOrRef_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::mozilla::devtools::protobuf::Metadata* Arena::CreateMaybeMessage< ::mozilla::devtools::protobuf::Metadata >(Arena* arena) {
  return Arena::CreateInternal< ::mozilla::devtools::protobuf::Metadata >(arena);
}
template<> PROTOBUF_NOINLINE ::mozilla::devtools::protobuf::StackFrame_Data* Arena::CreateMaybeMessage< ::mozilla::devtools::protobuf::StackFrame_Data >(Arena* arena) {
  return Arena::CreateInternal< ::mozilla::devtools::protobuf::StackFrame_Data >(arena);
}
template<> PROTOBUF_NOINLINE ::mozilla::devtools::protobuf::StackFrame* Arena::CreateMaybeMessage< ::mozilla::devtools::protobuf::StackFrame >(Arena* arena) {
  return Arena::CreateInternal< ::mozilla::devtools::protobuf::StackFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::mozilla::devtools::protobuf::Node* Arena::CreateMaybeMessage< ::mozilla::devtools::protobuf::Node >(Arena* arena) {
  return Arena::CreateInternal< ::mozilla::devtools::protobuf::Node >(arena);
}
template<> PROTOBUF_NOINLINE ::mozilla::devtools::protobuf::Edge* Arena::CreateMaybeMessage< ::mozilla::devtools::protobuf::Edge >(Arena* arena) {
  return Arena::CreateInternal< ::mozilla::devtools::protobuf::Edge >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
