// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: CoreDump.proto
// Protobuf C++ Version: 7.35.0

#ifndef CoreDump_2eproto_2epb_2eh
#define CoreDump_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7035000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_CoreDump_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_CoreDump_2eproto {
  static const ::uint32_t offsets[];
};
namespace mozilla {
namespace devtools {
namespace protobuf {
class Edge;
struct EdgeGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern EdgeGlobalsTypeInternal Edge_globals_;
extern const ::google::protobuf::internal::ClassDataLite Edge_class_data_;
#else
extern const EdgeGlobalsTypeInternal Edge_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Metadata;
struct MetadataGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MetadataGlobalsTypeInternal Metadata_globals_;
extern const ::google::protobuf::internal::ClassDataLite Metadata_class_data_;
#else
extern const MetadataGlobalsTypeInternal Metadata_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Node;
struct NodeGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NodeGlobalsTypeInternal Node_globals_;
extern const ::google::protobuf::internal::ClassDataLite Node_class_data_;
#else
extern const NodeGlobalsTypeInternal Node_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class StackFrame;
struct StackFrameGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern StackFrameGlobalsTypeInternal StackFrame_globals_;
extern const ::google::protobuf::internal::ClassDataLite StackFrame_class_data_;
#else
extern const StackFrameGlobalsTypeInternal StackFrame_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class StackFrame_Data;
struct StackFrame_DataGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern StackFrame_DataGlobalsTypeInternal StackFrame_Data_globals_;
extern const ::google::protobuf::internal::ClassDataLite StackFrame_Data_class_data_;
#else
extern const StackFrame_DataGlobalsTypeInternal StackFrame_Data_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace mozilla {
namespace devtools {
namespace protobuf {

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED StackFrame final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame) */ {
 public:
  inline StackFrame() : StackFrame(nullptr) {}
  ~StackFrame() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(StackFrame* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(StackFrame));
  }
#endif

  template <typename = void>
  explicit constexpr StackFrame(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline StackFrame(const StackFrame& from) : StackFrame(nullptr, from) {}
  inline StackFrame(StackFrame&& from) noexcept : StackFrame(nullptr, ::std::move(from)) {}
  inline StackFrame& operator=(const StackFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline StackFrame& operator=(StackFrame&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const StackFrame& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<StackFrame>(&StackFrame_globals_);
  }
  enum StackFrameTypeCase {
    kData = 1,
    kRef = 2,
    STACKFRAMETYPE_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(StackFrame& a, StackFrame& b) { a.Swap(&b); }
  inline void Swap(StackFrame* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StackFrame* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] StackFrame* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<StackFrame>(arena);
  }
  void CopyFrom(const StackFrame& from);
  void MergeFrom(const StackFrame& from) { StackFrame::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& ;msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(StackFrame* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "mozilla.devtools.protobuf.StackFrame"; }

  explicit StackFrame(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  StackFrame(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StackFrame& from);
  StackFrame(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StackFrame&& from) noexcept
      : StackFrame(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------
  using Data = StackFrame_Data;

  // accessors -------------------------------------------------------
  enum : int {
    kDataFieldNumber = 1,
    kRefFieldNumber = 2,
  };
  // .mozilla.devtools.protobuf.StackFrame.Data data = 1;
  [[nodiscard]] bool has_data()
      const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  [[nodiscard]] const ::mozilla::devtools::protobuf::StackFrame_Data& data() const;
  [[nodiscard]] ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE release_data();
  ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NONNULL mutable_data();
  void set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE value);
  ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE unsafe_arena_release_data();

  private:
  const ::mozilla::devtools::protobuf::StackFrame_Data& _internal_data() const;
  ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NONNULL _internal_mutable_data();

  public:
  // uint64 ref = 2;
  [[nodiscard]] bool has_ref()
      const;
  void clear_ref() ;
  [[nodiscard]] ::uint64_t ref() const;
  void set_ref(::uint64_t value);

  private:
  ::uint64_t _internal_ref() const;
  void _internal_set_ref(::uint64_t value);

  public:
  void clear_StackFrameType();
  StackFrameTypeCase StackFrameType_case() const;
  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame)
 private:
  class _Internal;
  void set_has_data();
  void set_has_ref();
  [[nodiscard]] inline bool has_StackFrameType() const;
  inline void clear_has_StackFrameType();
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 2,
                          1, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const StackFrame& from_msg);
    union StackFrameTypeUnion {
      constexpr StackFrameTypeUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE data_;
      ::uint64_t ref_;
    } StackFrameType_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_CoreDump_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED StackFrame_Data final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame.Data) */ {
 public:
  inline StackFrame_Data() : StackFrame_Data(nullptr) {}
  ~StackFrame_Data() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(StackFrame_Data* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(StackFrame_Data));
  }
#endif

  template <typename = void>
  explicit constexpr StackFrame_Data(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline StackFrame_Data(const StackFrame_Data& from) : StackFrame_Data(nullptr, from) {}
  inline StackFrame_Data(StackFrame_Data&& from) noexcept : StackFrame_Data(nullptr, ::std::move(from)) {}
  inline StackFrame_Data& operator=(const StackFrame_Data& from) {
    CopyFrom(from);
    return *this;
  }
  inline StackFrame_Data& operator=(StackFrame_Data&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const StackFrame_Data& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<StackFrame_Data>(&StackFrame_Data_globals_);
  }
  enum SourceOrRefCase {
    kSource = 5,
    kSourceRef = 6,
    SOURCEORREF_NOT_SET = 0,
  };
  enum FunctionDisplayNameOrRefCase {
    kFunctionDisplayName = 7,
    kFunctionDisplayNameRef = 8,
    FUNCTIONDISPLAYNAMEORREF_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(StackFrame_Data& a, StackFrame_Data& b) { a.Swap(&b); }
  inline void Swap(StackFrame_Data* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StackFrame_Data* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] StackFrame_Data* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<StackFrame_Data>(arena);
  }
  void CopyFrom(const StackFrame_Data& from);
  void MergeFrom(const StackFrame_Data& from) { StackFrame_Data::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& ;msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(StackFrame_Data* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "mozilla.devtools.protobuf.StackFrame.Data"; }

  explicit StackFrame_Data(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  StackFrame_Data(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StackFrame_Data& from);
  StackFrame_Data(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StackFrame_Data&& from) noexcept
      : StackFrame_Data(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

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

  // accessors -------------------------------------------------------
  enum : int {
    kParentFieldNumber = 2,
    kIdFieldNumber = 1,
    kLineFieldNumber = 3,
    kColumnFieldNumber = 4,
    kIsSystemFieldNumber = 9,
    kIsSelfHostedFieldNumber = 10,
    kSourceFieldNumber = 5,
    kSourceRefFieldNumber = 6,
    kFunctionDisplayNameFieldNumber = 7,
    kFunctionDisplayNameRefFieldNumber = 8,
  };
  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
  [[nodiscard]] bool has_parent()
      const;
  void clear_parent() ;
  [[nodiscard]] const ::mozilla::devtools::protobuf::StackFrame& parent() const;
  [[nodiscard]] ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE release_parent();
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL mutable_parent();
  void set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value);
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE unsafe_arena_release_parent();

  private:
  const ::mozilla::devtools::protobuf::StackFrame& _internal_parent() const;
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL _internal_mutable_parent();

  public:
  // optional uint64 id = 1;
  [[nodiscard]] bool has_id()
      const;
  void clear_id() ;
  [[nodiscard]] ::uint64_t id() const;
  void set_id(::uint64_t value);

  private:
  ::uint64_t _internal_id() const;
  void _internal_set_id(::uint64_t value);

  public:
  // optional uint32 line = 3;
  [[nodiscard]] bool has_line()
      const;
  void clear_line() ;
  [[nodiscard]] ::uint32_t line() const;
  void set_line(::uint32_t value);

  private:
  ::uint32_t _internal_line() const;
  void _internal_set_line(::uint32_t value);

  public:
  // optional uint32 column = 4;
  [[nodiscard]] bool has_column()
      const;
  void clear_column() ;
  [[nodiscard]] ::uint32_t column() const;
  void set_column(::uint32_t value);

  private:
  ::uint32_t _internal_column() const;
  void _internal_set_column(::uint32_t value);

  public:
  // optional bool isSystem = 9;
  [[nodiscard]] bool has_issystem()
      const;
  void clear_issystem() ;
  [[nodiscard]] bool issystem() const;
  void set_issystem(bool value);

  private:
  bool _internal_issystem() const;
  void _internal_set_issystem(bool value);

  public:
  // optional bool isSelfHosted = 10;
  [[nodiscard]] bool has_isselfhosted()
      const;
  void clear_isselfhosted() ;
  [[nodiscard]] bool isselfhosted() const;
  void set_isselfhosted(bool value);

  private:
  bool _internal_isselfhosted() const;
  void _internal_set_isselfhosted(bool value);

  public:
  // bytes source = 5;
  [[nodiscard]] bool has_source()
      const;
  void clear_source() ;
  [[nodiscard]] const ::std::string& source() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_source(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_source();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_source();
  void set_allocated_source(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_source() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_source(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_source();

  public:
  // uint64 sourceRef = 6;
  [[nodiscard]] bool has_sourceref()
      const;
  void clear_sourceref() ;
  [[nodiscard]] ::uint64_t sourceref() const;
  void set_sourceref(::uint64_t value);

  private:
  ::uint64_t _internal_sourceref() const;
  void _internal_set_sourceref(::uint64_t value);

  public:
  // bytes functionDisplayName = 7;
  [[nodiscard]] bool has_functiondisplayname()
      const;
  void clear_functiondisplayname() ;
  [[nodiscard]] const ::std::string& functiondisplayname() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_functiondisplayname(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_functiondisplayname();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_functiondisplayname();
  void set_allocated_functiondisplayname(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_functiondisplayname() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_functiondisplayname(const ::std::string&&nbsp;value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_functiondisplayname();

  public:
  // uint64 functionDisplayNameRef = 8;
  [[nodiscard]] bool has_functiondisplaynameref()
      const;
  void clear_functiondisplaynameref() ;
  [[nodiscard]] ::uint64_t functiondisplaynameref() const;
  void set_functiondisplaynameref(::uint64_t value);

  private:
  ::uint64_t _internal_functiondisplaynameref() const;
  void _internal_set_functiondisplaynameref(::uint64_t value);

  public:
  void clear_SourceOrRef();
  SourceOrRefCase SourceOrRef_case() const;
  void clear_FunctionDisplayNameOrRef();
  FunctionDisplayNameOrRefCase FunctionDisplayNameOrRef_case() const;
  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame.Data)
 private:
  class _Internal;
  void set_has_source();
  void set_has_sourceref();
  void set_has_functiondisplayname();
  void set_has_functiondisplaynameref();
  [[nodiscard]] inline bool has_SourceOrRef() const;
  inline void clear_has_SourceOrRef();
  [[nodiscard]] inline bool has_FunctionDisplayNameOrRef() const;
  inline void clear_has_FunctionDisplayNameOrRef();
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 10,
                          1, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const StackFrame_Data& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE parent_;
    ::uint64_t id_;
    ::uint32_t line_;
    ::uint32_t column_;
    bool issystem_;
    bool isselfhosted_;
    union SourceOrRefUnion {
      constexpr SourceOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr source_;
      ::uint64_t sourceref_;
    } SourceOrRef_;
    union FunctionDisplayNameOrRefUnion {
      constexpr FunctionDisplayNameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr functiondisplayname_;
      ::uint64_t functiondisplaynameref_;
    } FunctionDisplayNameOrRef_;
    ::uint32_t _oneof_case_[2];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_CoreDump_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Metadata final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Metadata) */ {
 public:
  inline Metadata() : Metadata(nullptr) {}
  ~Metadata() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Metadata* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Metadata));
  }
#endif

  template <typename = void>
  explicit constexpr Metadata(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Metadata(const Metadata& from) : Metadata(nullptr, from) {}
  inline Metadata(Metadata&& from) noexcept : Metadata(nullptr, ::std::move(from)) {}
  inline Metadata& operator=(const Metadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline Metadata& operator=(Metadata&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const Metadata& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Metadata>(&Metadata_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(Metadata& a, Metadata& b) { a.Swap(&b); }
  inline void Swap(Metadata* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Metadata* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Metadata* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<Metadata>(arena);
  }
  void CopyFrom(const Metadata& from);
  void MergeFrom(const Metadata& from) { Metadata::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& ;msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Metadata* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "mozilla.devtools.protobuf.Metadata"; }

  explicit Metadata(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Metadata(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Metadata& from);
  Metadata(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Metadata&& from) noexcept
      : Metadata(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

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

  // accessors -------------------------------------------------------
  enum : int {
    kTimeStampFieldNumber = 1,
  };
  // optional uint64 timeStamp = 1;
  [[nodiscard]] bool has_timestamp()
      const;
  void clear_timestamp() ;
  [[nodiscard]] ::uint64_t timestamp() const;
  void set_timestamp(::uint64_t value);

  private:
  ::uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Metadata)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Metadata& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t timestamp_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_CoreDump_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Edge final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Edge) */ {
 public:
  inline Edge() : Edge(nullptr) {}
  ~Edge() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Edge* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Edge));
  }
#endif

  template <typename = void>
  explicit constexpr Edge(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Edge(const Edge& from) : Edge(nullptr, from) {}
  inline Edge(Edge&& from) noexcept : Edge(nullptr, ::std::move(from)) {}
  inline Edge& operator=(const Edge& from) {
    CopyFrom(from);
    return *this;
  }
  inline Edge& operator=(Edge&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const Edge& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Edge>(&Edge_globals_);
  }
  enum EdgeNameOrRefCase {
    kName = 2,
    kNameRef = 3,
    EDGENAMEORREF_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(Edge& a, Edge& b) { a.Swap(&b); }
  inline void Swap(Edge* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Edge* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Edge* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<Edge>(arena);
  }
  void CopyFrom(const Edge& from);
  void MergeFrom(const Edge& from) { Edge::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& ;msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Edge* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "mozilla.devtools.protobuf.Edge"; }

  explicit Edge(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Edge(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Edge& from);
  Edge(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Edge&& from) noexcept
      : Edge(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

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

  // accessors -------------------------------------------------------
  enum : int {
    kReferentFieldNumber = 1,
    kNameFieldNumber = 2,
    kNameRefFieldNumber = 3,
  };
  // optional uint64 referent = 1;
  [[nodiscard]] bool has_referent()
      const;
  void clear_referent() ;
  [[nodiscard]] ::uint64_t referent() const;
  void set_referent(::uint64_t value);

  private:
  ::uint64_t _internal_referent() const;
  void _internal_set_referent(::uint64_t value);

  public:
  // bytes name = 2;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // uint64 nameRef = 3;
  [[nodiscard]] bool has_nameref()
      const;
  void clear_nameref() ;
  [[nodiscard]] ::uint64_t nameref() const;
  void set_nameref(::uint64_t value);

  private:
  ::uint64_t _internal_nameref() const;
  void _internal_set_nameref(::uint64_t value);

  public:
  void clear_EdgeNameOrRef();
  EdgeNameOrRefCase EdgeNameOrRef_case() const;
  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Edge)
 private:
  class _Internal;
  void set_has_name();
  void set_has_nameref();
  [[nodiscard]] inline bool has_EdgeNameOrRef() const;
  inline void clear_has_EdgeNameOrRef();
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Edge& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t referent_;
    union EdgeNameOrRefUnion {
      constexpr EdgeNameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr name_;
      ::uint64_t nameref_;
    } EdgeNameOrRef_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_CoreDump_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Node final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Node) */ {
 public:
  inline Node() : Node(nullptr) {}
  ~Node() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Node* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Node));
  }
#endif

  template <typename = void>
  explicit constexpr Node(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Node(const Node& from) : Node(nullptr, from) {}
  inline Node(Node&& from) noexcept : Node(nullptr, ::std::move(from)) {}
  inline Node& operator=(const Node& from) {
    CopyFrom(from);
    return *this;
  }
  inline Node& operator=(Node&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const Node& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Node>(&Node_globals_);
  }
  enum TypeNameOrRefCase {
    kTypeName = 2,
    kTypeNameRef = 3,
    TYPENAMEORREF_NOT_SET = 0,
  };
  enum JSObjectClassNameOrRefCase {
    kJsObjectClassName = 7,
    kJsObjectClassNameRef = 8,
    JSOBJECTCLASSNAMEORREF_NOT_SET = 0,
  };
  enum ScriptFilenameOrRefCase {
    kScriptFilename = 10,
    kScriptFilenameRef = 11,
    SCRIPTFILENAMEORREF_NOT_SET = 0,
  };
  enum DescriptiveTypeNameOrRefCase {
    kDescriptiveTypeName = 12,
    kDescriptiveTypeNameRef = 13,
    DESCRIPTIVETYPENAMEORREF_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(Node& a, Node& b) { a.Swap(&b); }
  inline void Swap(Node* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Node* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Node* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<Node>(arena);
  }
  void CopyFrom(const Node& from);
  void MergeFrom(const Node& from) { Node::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& ;msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Node* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "mozilla.devtools.protobuf.Node"; }

  explicit Node(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Node(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Node& from);
  Node(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Node&& from) noexcept
      : Node(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

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

  // accessors -------------------------------------------------------
  enum : int {
    kEdgesFieldNumber = 5,
    kAllocationStackFieldNumber = 6,
    kIdFieldNumber = 1,
    kSizeFieldNumber = 4,
    kCoarseTypeFieldNumber = 9,
    kTypeNameFieldNumber = 2,
    kTypeNameRefFieldNumber = 3,
    kJsObjectClassNameFieldNumber = 7,
    kJsObjectClassNameRefFieldNumber = 8,
    kScriptFilenameFieldNumber = 10,
    kScriptFilenameRefFieldNumber = 11,
    kDescriptiveTypeNameFieldNumber = 12,
    kDescriptiveTypeNameRefFieldNumber = 13,
  };
  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  [[nodiscard]] int edges_size()
      const;
  private:
  int _internal_edges_size() const;

  public:
  void clear_edges() ;
  [[nodiscard]] const ::mozilla::devtools::protobuf::Edge& edges(int index) const;
  [[nodiscard]] ::mozilla::devtools::protobuf::Edge* PROTOBUF_NONNULL mutable_edges(int index);
  ::mozilla::devtools::protobuf::Edge* PROTOBUF_NONNULL add_edges();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>&
  edges() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>* PROTOBUF_NONNULL
  mutable_edges();

  private:
  const ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>& ;_internal_edges() const;
  ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>* PROTOBUF_NONNULL _internal_mutable_edges();

  public:
  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
  [[nodiscard]] bool has_allocationstack()
      const;
  void clear_allocationstack() ;
  [[nodiscard]] const ::mozilla::devtools::protobuf::StackFrame& allocationstack() const;
  [[nodiscard]] ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE release_allocationstack();
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL mutable_allocationstack();
  void set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value);
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE unsafe_arena_release_allocationstack();

  private:
  const ::mozilla::devtools::protobuf::StackFrame& _internal_allocationstack() const;
  ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL _internal_mutable_allocationstack();

  public:
  // optional uint64 id = 1;
  [[nodiscard]] bool has_id()
      const;
  void clear_id() ;
  [[nodiscard]] ::uint64_t id() const;
  void set_id(::uint64_t value);

  private:
  ::uint64_t _internal_id() const;
  void _internal_set_id(::uint64_t value);

  public:
  // optional uint64 size = 4;
  [[nodiscard]] bool has_size()
      const;
  void clear_size() ;
  [[nodiscard]] ::uint64_t size() const;
  void set_size(::uint64_t value);

  private:
  ::uint64_t _internal_size() const;
  void _internal_set_size(::uint64_t value);

  public:
  // optional uint32 coarseType = 9 [default = 0];
  [[nodiscard]] bool has_coarsetype()
      const;
  void clear_coarsetype() ;
  [[nodiscard]] ::uint32_t coarsetype() const;
  void set_coarsetype(::uint32_t value);

  private:
  ::uint32_t _internal_coarsetype() const;
  void _internal_set_coarsetype(::uint32_t value);

  public:
  // bytes typeName = 2;
  [[nodiscard]] bool has_typename_()
      const;
  void clear_typename_() ;
  [[nodiscard]] const ::std::string& typename_() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_typename_(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_typename_();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_typename_();
  void set_allocated_typename_(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_typename_() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_typename_(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_typename_();

  public:
  // uint64 typeNameRef = 3;
  [[nodiscard]] bool has_typenameref()
      const;
  void clear_typenameref() ;
  [[nodiscard]] ::uint64_t typenameref() const;
  void set_typenameref(::uint64_t value);

  private:
  ::uint64_t _internal_typenameref() const;
  void _internal_set_typenameref(::uint64_t value);

  public:
  // bytes jsObjectClassName = 7;
  [[nodiscard]] bool has_jsobjectclassname()
      const;
  void clear_jsobjectclassname() ;
  [[nodiscard]] const ::std::string& jsobjectclassname() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_jsobjectclassname(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_jsobjectclassname();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_jsobjectclassname();
  void set_allocated_jsobjectclassname(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_jsobjectclassname() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_jsobjectclassname(const ::std::string& ;value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_jsobjectclassname();

  public:
  // uint64 jsObjectClassNameRef = 8;
  [[nodiscard]] bool has_jsobjectclassnameref()
      const;
  void clear_jsobjectclassnameref() ;
  [[nodiscard]] ::uint64_t jsobjectclassnameref() const;
  void set_jsobjectclassnameref(::uint64_t value);

  private:
  ::uint64_t _internal_jsobjectclassnameref() const;
  void _internal_set_jsobjectclassnameref(::uint64_t value);

  public:
  // bytes scriptFilename = 10;
  [[nodiscard]] bool has_scriptfilename()
      const;
  void clear_scriptfilename() ;
  [[nodiscard]] const ::std::string& scriptfilename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_scriptfilename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_scriptfilename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_scriptfilename();
  void set_allocated_scriptfilename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_scriptfilename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_scriptfilename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_scriptfilename();

  public:
  // uint64 scriptFilenameRef = 11;
  [[nodiscard]] bool has_scriptfilenameref()
      const;
  void clear_scriptfilenameref() ;
  [[nodiscard]] ::uint64_t scriptfilenameref() const;
  void set_scriptfilenameref(::uint64_t value);

  private:
  ::uint64_t _internal_scriptfilenameref() const;
  void _internal_set_scriptfilenameref(::uint64_t value);

  public:
  // bytes descriptiveTypeName = 12;
  [[nodiscard]] bool has_descriptivetypename()
      const;
  void clear_descriptivetypename() ;
  [[nodiscard]] const ::std::string& descriptivetypename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_descriptivetypename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_descriptivetypename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_descriptivetypename();
  void set_allocated_descriptivetypename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_descriptivetypename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_descriptivetypename(const ::std::string&&nbsp;value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_descriptivetypename();

  public:
  // uint64 descriptiveTypeNameRef = 13;
  [[nodiscard]] bool has_descriptivetypenameref()
      const;
  void clear_descriptivetypenameref() ;
  [[nodiscard]] ::uint64_t descriptivetypenameref() const;
  void set_descriptivetypenameref(::uint64_t value);

  private:
  ::uint64_t _internal_descriptivetypenameref() const;
  void _internal_set_descriptivetypenameref(::uint64_t value);

  public:
  void clear_TypeNameOrRef();
  TypeNameOrRefCase TypeNameOrRef_case() const;
  void clear_JSObjectClassNameOrRef();
  JSObjectClassNameOrRefCase JSObjectClassNameOrRef_case() const;
  void clear_ScriptFilenameOrRef();
  ScriptFilenameOrRefCase ScriptFilenameOrRef_case() const;
  void clear_descriptiveTypeNameOrRef();
  DescriptiveTypeNameOrRefCase descriptiveTypeNameOrRef_case() const;
  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Node)
 private:
  class _Internal;
  void set_has_typename_();
  void set_has_typenameref();
  void set_has_jsobjectclassname();
  void set_has_jsobjectclassnameref();
  void set_has_scriptfilename();
  void set_has_scriptfilenameref();
  void set_has_descriptivetypename();
  void set_has_descriptivetypenameref();
  [[nodiscard]] inline bool has_TypeNameOrRef() const;
  inline void clear_has_TypeNameOrRef();
  [[nodiscard]] inline bool has_JSObjectClassNameOrRef() const;
  inline void clear_has_JSObjectClassNameOrRef();
  [[nodiscard]] inline bool has_ScriptFilenameOrRef() const;
  inline void clear_has_ScriptFilenameOrRef();
  [[nodiscard]] inline bool has_descriptiveTypeNameOrRef() const;
  inline void clear_has_descriptiveTypeNameOrRef();
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 13,
                          2, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Node& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge > edges_;
    ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE allocationstack_;
    ::uint64_t id_;
    ::uint64_t size_;
    ::uint32_t coarsetype_;
    union TypeNameOrRefUnion {
      constexpr TypeNameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr typename__;
      ::uint64_t typenameref_;
    } TypeNameOrRef_;
    union JSObjectClassNameOrRefUnion {
      constexpr JSObjectClassNameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr jsobjectclassname_;
      ::uint64_t jsobjectclassnameref_;
    } JSObjectClassNameOrRef_;
    union ScriptFilenameOrRefUnion {
      constexpr ScriptFilenameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr scriptfilename_;
      ::uint64_t scriptfilenameref_;
    } ScriptFilenameOrRef_;
    union DescriptiveTypeNameOrRefUnion {
      constexpr DescriptiveTypeNameOrRefUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr descriptivetypename_;
      ::uint64_t descriptivetypenameref_;
    } descriptiveTypeNameOrRef_;
    ::uint32_t _oneof_case_[4];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_CoreDump_2eproto;
};

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




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


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

// Metadata

// optional uint64 timeStamp = 1;
inline bool Metadata::has_timestamp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void Metadata::clear_timestamp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.timestamp_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t Metadata::timestamp() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Metadata.timeStamp)
  return _internal_timestamp();
}
inline void Metadata::set_timestamp(::uint64_t value) {
  _internal_set_timestamp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp)
}
inline ::uint64_t Metadata::_internal_timestamp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.timestamp_;
}
inline void Metadata::_internal_set_timestamp(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.timestamp_ = value;
}

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

// StackFrame_Data

// optional uint64 id = 1;
inline bool StackFrame_Data::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void StackFrame_Data::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t StackFrame_Data::id() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id)
  return _internal_id();
}
inline void StackFrame_Data::set_id(::uint64_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id)
}
inline ::uint64_t StackFrame_Data::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void StackFrame_Data::_internal_set_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// optional .mozilla.devtools.protobuf.StackFrame parent = 2;
inline bool StackFrame_Data::has_parent() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.parent_ != nullptr);
  return value;
}
inline void StackFrame_Data::clear_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.parent_ != nullptr) _impl_.parent_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::_internal_parent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.parent_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mozilla::devtools::protobuf::StackFrame>(&::mozilla::devtools::protobuf::StackFrame_globals_);
}
inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent)
  return _internal_parent();
}
inline void StackFrame_Data::unsafe_arena_set_allocated_parent(
    ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_);
  }
  _impl_.parent_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent)
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE StackFrame_Data::release_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mozilla::devtools::protobuf::StackFrame* released = _impl_.parent_;
  _impl_.parent_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE StackFrame_Data::unsafe_arena_release_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.parent)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.parent_;
  _impl_.parent_ = nullptr;
  return temp;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL StackFrame_Data::_internal_mutable_parent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.parent_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::mozilla::devtools::protobuf::StackFrame>(GetArena());
    _impl_.parent_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(p);
  }
  return _impl_.parent_;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL StackFrame_Data::mutable_parent()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_parent();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent)
  return _msg;
}
inline void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.parent_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(value);
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent)
}

// optional uint32 line = 3;
inline bool StackFrame_Data::has_line() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void StackFrame_Data::clear_line() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.line_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t StackFrame_Data::line() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line)
  return _internal_line();
}
inline void StackFrame_Data::set_line(::uint32_t value) {
  _internal_set_line(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line)
}
inline ::uint32_t StackFrame_Data::_internal_line() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.line_;
}
inline void StackFrame_Data::_internal_set_line(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.line_ = value;
}

// optional uint32 column = 4;
inline bool StackFrame_Data::has_column() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void StackFrame_Data::clear_column() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.column_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t StackFrame_Data::column() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column)
  return _internal_column();
}
inline void StackFrame_Data::set_column(::uint32_t value) {
  _internal_set_column(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column)
}
inline ::uint32_t StackFrame_Data::_internal_column() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.column_;
}
inline void StackFrame_Data::_internal_set_column(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.column_ = value;
}

// bytes source = 5;
inline bool StackFrame_Data::has_source() const {
  return SourceOrRef_case() == kSource;
}
inline void StackFrame_Data::set_has_source() {
  _impl_._oneof_case_[0] = kSource;
}
inline void StackFrame_Data::clear_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (SourceOrRef_case() == kSource) {
    _impl_.SourceOrRef_.source_.Destroy();
    clear_has_SourceOrRef();
  }
}
inline const ::std::string& StackFrame_Data::source() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.source)
  return _internal_source();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void StackFrame_Data::set_source(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (SourceOrRef_case() != kSource) {
    clear_SourceOrRef();

    set_has_source();
    _impl_.SourceOrRef_.source_.InitDefault();
  }
  _impl_.SourceOrRef_.source_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source)
}
inline ::std::string* PROTOBUF_NONNULL StackFrame_Data::mutable_source()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (SourceOrRef_case() != kSource) {
    clear_SourceOrRef();

    set_has_source();
    _impl_.SourceOrRef_.source_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.source)
  return _s;
}
inline const ::std::string& StackFrame_Data::_internal_source() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (SourceOrRef_case() != kSource) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.SourceOrRef_.source_.Get();
}
inline void StackFrame_Data::_internal_set_source(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.SourceOrRef_.source_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL StackFrame_Data::_internal_mutable_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.SourceOrRef_.source_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE StackFrame_Data::release_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.source)
  if (SourceOrRef_case() != kSource) {
    return nullptr;
  }
  clear_has_SourceOrRef();
  return _impl_.SourceOrRef_.source_.Release();
}
inline void StackFrame_Data::set_allocated_source(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_SourceOrRef()) {
    clear_SourceOrRef();
  }
  if (value != nullptr) {
    set_has_source();
    _impl_.SourceOrRef_.source_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.source)
}

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

// bytes functionDisplayName = 7;
inline bool StackFrame_Data::has_functiondisplayname() const {
  return FunctionDisplayNameOrRef_case() == kFunctionDisplayName;
}
inline void StackFrame_Data::set_has_functiondisplayname() {
  _impl_._oneof_case_[1] = kFunctionDisplayName;
}
inline void StackFrame_Data::clear_functiondisplayname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (FunctionDisplayNameOrRef_case() == kFunctionDisplayName) {
    _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Destroy();
    clear_has_FunctionDisplayNameOrRef();
  }
}
inline const ::std::string& StackFrame_Data::functiondisplayname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  return _internal_functiondisplayname();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void StackFrame_Data::set_functiondisplayname(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (FunctionDisplayNameOrRef_case() != kFunctionDisplayName) {
    clear_FunctionDisplayNameOrRef();

    set_has_functiondisplayname();
    _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault();
  }
  _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}
inline ::std::string* PROTOBUF_NONNULL StackFrame_Data::mutable_functiondisplayname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (FunctionDisplayNameOrRef_case() != kFunctionDisplayName) {
    clear_FunctionDisplayNameOrRef();

    set_has_functiondisplayname();
    _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_functiondisplayname();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  return _s;
}
inline const ::std::string& StackFrame_Data::_internal_functiondisplayname() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (FunctionDisplayNameOrRef_case() != kFunctionDisplayName) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Get();
}
inline void StackFrame_Data::_internal_set_functiondisplayname(const ::std::string&&nbsp;value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL StackFrame_Data::_internal_mutable_functiondisplayname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE StackFrame_Data::release_functiondisplayname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
  if (FunctionDisplayNameOrRef_case() != kFunctionDisplayName) {
    return nullptr;
  }
  clear_has_FunctionDisplayNameOrRef();
  return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Release();
}
inline void StackFrame_Data::set_allocated_functiondisplayname(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_FunctionDisplayNameOrRef()) {
    clear_FunctionDisplayNameOrRef();
  }
  if (value != nullptr) {
    set_has_functiondisplayname();
    _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
}

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

// optional bool isSystem = 9;
inline bool StackFrame_Data::has_issystem() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void StackFrame_Data::clear_issystem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.issystem_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline bool StackFrame_Data::issystem() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
  return _internal_issystem();
}
inline void StackFrame_Data::set_issystem(bool value) {
  _internal_set_issystem(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
}
inline bool StackFrame_Data::_internal_issystem() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.issystem_;
}
inline void StackFrame_Data::_internal_set_issystem(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.issystem_ = value;
}

// optional bool isSelfHosted = 10;
inline bool StackFrame_Data::has_isselfhosted() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void StackFrame_Data::clear_isselfhosted() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.isselfhosted_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline bool StackFrame_Data::isselfhosted() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
  return _internal_isselfhosted();
}
inline void StackFrame_Data::set_isselfhosted(bool value) {
  _internal_set_isselfhosted(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
}
inline bool StackFrame_Data::_internal_isselfhosted() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.isselfhosted_;
}
inline void StackFrame_Data::_internal_set_isselfhosted(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.isselfhosted_ = value;
}

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

// StackFrame

// .mozilla.devtools.protobuf.StackFrame.Data data = 1;
inline bool StackFrame::has_data() const {
  return StackFrameType_case() == kData;
}
inline bool StackFrame::_internal_has_data() const {
  return StackFrameType_case() == kData;
}
inline void StackFrame::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void StackFrame::clear_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (StackFrameType_case() == kData) {
    if (GetArena() == nullptr) {
      delete _impl_.StackFrameType_.data_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      if (_impl_.StackFrameType_.data_ != nullptr) {
        _impl_.StackFrameType_.data_->Clear();
      }
    }
    clear_has_StackFrameType();
  }
}
inline ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE StackFrame::release_data() {
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.data)
  if (StackFrameType_case() == kData) {
    clear_has_StackFrameType();
    auto* temp = _impl_.StackFrameType_.data_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.StackFrameType_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::_internal_data() const {
  return StackFrameType_case() == kData ? static_cast<const ::mozilla::devtools::protobuf::StackFrame_Data&>(*_impl_.StackFrameType_.data_)
                     : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mozilla::devtools::protobuf::StackFrame_Data>(&::mozilla::devtools::protobuf::StackFrame_Data_globals_);
}
inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.data)
  return _internal_data();
}
inline ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE StackFrame::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.devtools.protobuf.StackFrame.data)
  if (StackFrameType_case() == kData) {
    clear_has_StackFrameType();
    auto* temp = _impl_.StackFrameType_.data_;
    _impl_.StackFrameType_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void StackFrame::unsafe_arena_set_allocated_data(
    ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_StackFrameType();
  if (value) {
    set_has_data();
    _impl_.StackFrameType_.data_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.data)
}
inline ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NONNULL StackFrame::_internal_mutable_data() {
  if (StackFrameType_case() != kData) {
    clear_StackFrameType();
    set_has_data();
    _impl_.StackFrameType_.data_ = 
        ::google::protobuf::MessageLite::DefaultConstruct<::mozilla::devtools::protobuf::StackFrame_Data>(GetArena());
  }
  return _impl_.StackFrameType_.data_;
}
inline ::mozilla::devtools::protobuf::StackFrame_Data* PROTOBUF_NONNULL StackFrame::mutable_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::mozilla::devtools::protobuf::StackFrame_Data* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.data)
  return _msg;
}

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

inline bool StackFrame::has_StackFrameType() const {
  return StackFrameType_case() != STACKFRAMETYPE_NOT_SET;
}
inline void StackFrame::clear_has_StackFrameType() {
  _impl_._oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
}
inline StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const {
  return StackFrame::StackFrameTypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Node

// optional uint64 id = 1;
inline bool Node::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void Node::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t Node::id() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.id)
  return _internal_id();
}
inline void Node::set_id(::uint64_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.id)
}
inline ::uint64_t Node::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void Node::_internal_set_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// bytes typeName = 2;
inline bool Node::has_typename_() const {
  return TypeNameOrRef_case() == kTypeName;
}
inline void Node::set_has_typename_() {
  _impl_._oneof_case_[0] = kTypeName;
}
inline void Node::clear_typename_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (TypeNameOrRef_case() == kTypeName) {
    _impl_.TypeNameOrRef_.typename__.Destroy();
    clear_has_TypeNameOrRef();
  }
}
inline const ::std::string& Node::typename_() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeName)
  return _internal_typename_();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Node::set_typename_(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (TypeNameOrRef_case() != kTypeName) {
    clear_TypeNameOrRef();

    set_has_typename_();
    _impl_.TypeNameOrRef_.typename__.InitDefault();
  }
  _impl_.TypeNameOrRef_.typename__.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName)
}
inline ::std::string* PROTOBUF_NONNULL Node::mutable_typename_()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (TypeNameOrRef_case() != kTypeName) {
    clear_TypeNameOrRef();

    set_has_typename_();
    _impl_.TypeNameOrRef_.typename__.InitDefault();
  }
  ::std::string* _s = _internal_mutable_typename_();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.typeName)
  return _s;
}
inline const ::std::string& Node::_internal_typename_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (TypeNameOrRef_case() != kTypeName) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.TypeNameOrRef_.typename__.Get();
}
inline void Node::_internal_set_typename_(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.TypeNameOrRef_.typename__.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Node::_internal_mutable_typename_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.TypeNameOrRef_.typename__.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Node::release_typename_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.typeName)
  if (TypeNameOrRef_case() != kTypeName) {
    return nullptr;
  }
  clear_has_TypeNameOrRef();
  return _impl_.TypeNameOrRef_.typename__.Release();
}
inline void Node::set_allocated_typename_(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_TypeNameOrRef()) {
    clear_TypeNameOrRef();
  }
  if (value != nullptr) {
    set_has_typename_();
    _impl_.TypeNameOrRef_.typename__.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.typeName)
}

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

// optional uint64 size = 4;
inline bool Node::has_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void Node::clear_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.size_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t Node::size() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.size)
  return _internal_size();
}
inline void Node::set_size(::uint64_t value) {
  _internal_set_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.size)
}
inline ::uint64_t Node::_internal_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.size_;
}
inline void Node::_internal_set_size(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.size_ = value;
}

// repeated .mozilla.devtools.protobuf.Edge edges = 5;
inline int Node::_internal_edges_size() const {
  return _internal_edges().size();
}
inline int Node::edges_size() const {
  return _internal_edges_size();
}
inline void Node::clear_edges() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.edges_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::mozilla::devtools::protobuf::Edge& Node::edges(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.edges)
  return _internal_edges().Get(index);
}
inline ::mozilla::devtools::protobuf::Edge* PROTOBUF_NONNULL Node::mutable_edges(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.edges)
  return _internal_mutable_edges()->Mutable(index);
}
inline ::mozilla::devtools::protobuf::Edge* PROTOBUF_NONNULL Node::add_edges()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::mozilla::devtools::protobuf::Edge* _add =
      _internal_mutable_edges()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:mozilla.devtools.protobuf.Node.edges)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>& Node::edges() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:mozilla.devtools.protobuf.Node.edges)
  return _internal_edges();
}
inline ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>* PROTOBUF_NONNULL
Node::mutable_edges() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_edges();
}
inline const ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>&
Node::_internal_edges() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.edges_;
}
inline ::google::protobuf::RepeatedPtrField<::mozilla::devtools::protobuf::Edge>* PROTOBUF_NONNULL
Node::_internal_mutable_edges() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.edges_;
}

// optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
inline bool Node::has_allocationstack() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.allocationstack_ != nullptr);
  return value;
}
inline void Node::clear_allocationstack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.allocationstack_ != nullptr) _impl_.allocationstack_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::mozilla::devtools::protobuf::StackFrame& Node::_internal_allocationstack() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.allocationstack_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::mozilla::devtools::protobuf::StackFrame>(&::mozilla::devtools::protobuf::StackFrame_globals_);
}
inline const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack)
  return _internal_allocationstack();
}
inline void Node::unsafe_arena_set_allocated_allocationstack(
    ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.allocationstack_);
  }
  _impl_.allocationstack_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.Node.allocationStack)
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE Node::release_allocationstack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mozilla::devtools::protobuf::StackFrame* released = _impl_.allocationstack_;
  _impl_.allocationstack_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE Node::unsafe_arena_release_allocationstack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.allocationStack)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.allocationstack_;
  _impl_.allocationstack_ = nullptr;
  return temp;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL Node::_internal_mutable_allocationstack() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.allocationstack_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::mozilla::devtools::protobuf::StackFrame>(GetArena());
    _impl_.allocationstack_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(p);
  }
  return _impl_.allocationstack_;
}
inline ::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NONNULL Node::mutable_allocationstack()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_allocationstack();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack)
  return _msg;
}
inline void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.allocationstack_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.allocationstack_ = reinterpret_cast<::mozilla::devtools::protobuf::StackFrame*>(value);
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack)
}

// bytes jsObjectClassName = 7;
inline bool Node::has_jsobjectclassname() const {
  return JSObjectClassNameOrRef_case() == kJsObjectClassName;
}
inline void Node::set_has_jsobjectclassname() {
  _impl_._oneof_case_[1] = kJsObjectClassName;
}
inline void Node::clear_jsobjectclassname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (JSObjectClassNameOrRef_case() == kJsObjectClassName) {
    _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Destroy();
    clear_has_JSObjectClassNameOrRef();
  }
}
inline const ::std::string& Node::jsobjectclassname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassName)
  return _internal_jsobjectclassname();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Node::set_jsobjectclassname(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (JSObjectClassNameOrRef_case() != kJsObjectClassName) {
    clear_JSObjectClassNameOrRef();

    set_has_jsobjectclassname();
    _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault();
  }
  _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName)
}
inline ::std::string* PROTOBUF_NONNULL Node::mutable_jsobjectclassname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (JSObjectClassNameOrRef_case() != kJsObjectClassName) {
    clear_JSObjectClassNameOrRef();

    set_has_jsobjectclassname();
    _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_jsobjectclassname();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.jsObjectClassName)
  return _s;
}
inline const ::std::string& Node::_internal_jsobjectclassname() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (JSObjectClassNameOrRef_case() != kJsObjectClassName) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Get();
}
inline void Node::_internal_set_jsobjectclassname(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Node::_internal_mutable_jsobjectclassname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Node::release_jsobjectclassname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.jsObjectClassName)
  if (JSObjectClassNameOrRef_case() != kJsObjectClassName) {
    return nullptr;
  }
  clear_has_JSObjectClassNameOrRef();
  return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Release();
}
inline void Node::set_allocated_jsobjectclassname(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_JSObjectClassNameOrRef()) {
    clear_JSObjectClassNameOrRef();
  }
  if (value != nullptr) {
    set_has_jsobjectclassname();
    _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.jsObjectClassName)
}

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

// optional uint32 coarseType = 9 [default = 0];
inline bool Node::has_coarsetype() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void Node::clear_coarsetype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.coarsetype_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint32_t Node::coarsetype() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.coarseType)
  return _internal_coarsetype();
}
inline void Node::set_coarsetype(::uint32_t value) {
  _internal_set_coarsetype(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.coarseType)
}
inline ::uint32_t Node::_internal_coarsetype() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.coarsetype_;
}
inline void Node::_internal_set_coarsetype(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.coarsetype_ = value;
}

// bytes scriptFilename = 10;
inline bool Node::has_scriptfilename() const {
  return ScriptFilenameOrRef_case() == kScriptFilename;
}
inline void Node::set_has_scriptfilename() {
  _impl_._oneof_case_[2] = kScriptFilename;
}
inline void Node::clear_scriptfilename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (ScriptFilenameOrRef_case() == kScriptFilename) {
    _impl_.ScriptFilenameOrRef_.scriptfilename_.Destroy();
    clear_has_ScriptFilenameOrRef();
  }
}
inline const ::std::string& Node::scriptfilename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilename)
  return _internal_scriptfilename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Node::set_scriptfilename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (ScriptFilenameOrRef_case() != kScriptFilename) {
    clear_ScriptFilenameOrRef();

    set_has_scriptfilename();
    _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault();
  }
  _impl_.ScriptFilenameOrRef_.scriptfilename_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename)
}
inline ::std::string* PROTOBUF_NONNULL Node::mutable_scriptfilename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (ScriptFilenameOrRef_case() != kScriptFilename) {
    clear_ScriptFilenameOrRef();

    set_has_scriptfilename();
    _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_scriptfilename();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.scriptFilename)
  return _s;
}
inline const ::std::string& Node::_internal_scriptfilename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (ScriptFilenameOrRef_case() != kScriptFilename) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.ScriptFilenameOrRef_.scriptfilename_.Get();
}
inline void Node::_internal_set_scriptfilename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ScriptFilenameOrRef_.scriptfilename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Node::_internal_mutable_scriptfilename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.ScriptFilenameOrRef_.scriptfilename_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Node::release_scriptfilename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.scriptFilename)
  if (ScriptFilenameOrRef_case() != kScriptFilename) {
    return nullptr;
  }
  clear_has_ScriptFilenameOrRef();
  return _impl_.ScriptFilenameOrRef_.scriptfilename_.Release();
}
inline void Node::set_allocated_scriptfilename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_ScriptFilenameOrRef()) {
    clear_ScriptFilenameOrRef();
  }
  if (value != nullptr) {
    set_has_scriptfilename();
    _impl_.ScriptFilenameOrRef_.scriptfilename_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.scriptFilename)
}

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

// bytes descriptiveTypeName = 12;
inline bool Node::has_descriptivetypename() const {
  return descriptiveTypeNameOrRef_case() == kDescriptiveTypeName;
}
inline void Node::set_has_descriptivetypename() {
  _impl_._oneof_case_[3] = kDescriptiveTypeName;
}
inline void Node::clear_descriptivetypename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (descriptiveTypeNameOrRef_case() == kDescriptiveTypeName) {
    _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Destroy();
    clear_has_descriptiveTypeNameOrRef();
  }
}
inline const ::std::string& Node::descriptivetypename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeName)
  return _internal_descriptivetypename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Node::set_descriptivetypename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (descriptiveTypeNameOrRef_case() != kDescriptiveTypeName) {
    clear_descriptiveTypeNameOrRef();

    set_has_descriptivetypename();
    _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault();
  }
  _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeName)
}
inline ::std::string* PROTOBUF_NONNULL Node::mutable_descriptivetypename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (descriptiveTypeNameOrRef_case() != kDescriptiveTypeName) {
    clear_descriptiveTypeNameOrRef();

    set_has_descriptivetypename();
    _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_descriptivetypename();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.descriptiveTypeName)
  return _s;
}
inline const ::std::string& Node::_internal_descriptivetypename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (descriptiveTypeNameOrRef_case() != kDescriptiveTypeName) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Get();
}
inline void Node::_internal_set_descriptivetypename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Node::_internal_mutable_descriptivetypename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Node::release_descriptivetypename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.descriptiveTypeName)
  if (descriptiveTypeNameOrRef_case() != kDescriptiveTypeName) {
    return nullptr;
  }
  clear_has_descriptiveTypeNameOrRef();
  return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Release();
}
inline void Node::set_allocated_descriptivetypename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_descriptiveTypeNameOrRef()) {
    clear_descriptiveTypeNameOrRef();
  }
  if (value != nullptr) {
    set_has_descriptivetypename();
    _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.descriptiveTypeName)
}

// uint64 descriptiveTypeNameRef = 13;
inline bool Node::has_descriptivetypenameref() const {
  return descriptiveTypeNameOrRef_case() == kDescriptiveTypeNameRef;
}
inline void Node::set_has_descriptivetypenameref() {
  _impl_._oneof_case_[3] = kDescriptiveTypeNameRef;
}
inline void Node::clear_descriptivetypenameref() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (descriptiveTypeNameOrRef_case() == kDescriptiveTypeNameRef) {
    _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = ::uint64_t{0u};
    clear_has_descriptiveTypeNameOrRef();
  }
}
inline ::uint64_t Node::descriptivetypenameref() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef)
  return _internal_descriptivetypenameref();
}
inline void Node::set_descriptivetypenameref(::uint64_t value) {
  if (descriptiveTypeNameOrRef_case() != kDescriptiveTypeNameRef) {
    clear_descriptiveTypeNameOrRef();
    set_has_descriptivetypenameref();
  }
  _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = value;
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef)
}
inline ::uint64_t Node::_internal_descriptivetypenameref() const {
  if (descriptiveTypeNameOrRef_case() == kDescriptiveTypeNameRef) {
    return _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_;
  }
  return ::uint64_t{0u};
}

inline bool Node::has_TypeNameOrRef() const {
  return TypeNameOrRef_case() != TYPENAMEORREF_NOT_SET;
}
inline void Node::clear_has_TypeNameOrRef() {
  _impl_._oneof_case_[0] = TYPENAMEORREF_NOT_SET;
}
inline bool Node::has_JSObjectClassNameOrRef() const {
  return JSObjectClassNameOrRef_case() != JSOBJECTCLASSNAMEORREF_NOT_SET;
}
inline void Node::clear_has_JSObjectClassNameOrRef() {
  _impl_._oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET;
}
inline bool Node::has_ScriptFilenameOrRef() const {
  return ScriptFilenameOrRef_case() != SCRIPTFILENAMEORREF_NOT_SET;
}
inline void Node::clear_has_ScriptFilenameOrRef() {
  _impl_._oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET;
}
inline bool Node::has_descriptiveTypeNameOrRef() const {
  return descriptiveTypeNameOrRef_case() != DESCRIPTIVETYPENAMEORREF_NOT_SET;
}
inline void Node::clear_has_descriptiveTypeNameOrRef() {
  _impl_._oneof_case_[3] = DESCRIPTIVETYPENAMEORREF_NOT_SET;
}
inline Node::TypeNameOrRefCase Node::TypeNameOrRef_case() const {
  return Node::TypeNameOrRefCase(_impl_._oneof_case_[0]);
}
inline Node::JSObjectClassNameOrRefCase Node::JSObjectClassNameOrRef_case() const {
  return Node::JSObjectClassNameOrRefCase(_impl_._oneof_case_[1]);
}
inline Node::ScriptFilenameOrRefCase Node::ScriptFilenameOrRef_case() const {
  return Node::ScriptFilenameOrRefCase(_impl_._oneof_case_[2]);
}
inline Node::DescriptiveTypeNameOrRefCase Node::descriptiveTypeNameOrRef_case() const {
  return Node::DescriptiveTypeNameOrRefCase(_impl_._oneof_case_[3]);
}
// -------------------------------------------------------------------

// Edge

// optional uint64 referent = 1;
inline bool Edge::has_referent() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void Edge::clear_referent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.referent_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t Edge::referent() const {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.referent)
  return _internal_referent();
}
inline void Edge::set_referent(::uint64_t value) {
  _internal_set_referent(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.referent)
}
inline ::uint64_t Edge::_internal_referent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.referent_;
}
inline void Edge::_internal_set_referent(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.referent_ = value;
}

// bytes name = 2;
inline bool Edge::has_name() const {
  return EdgeNameOrRef_case() == kName;
}
inline void Edge::set_has_name() {
  _impl_._oneof_case_[0] = kName;
}
inline void Edge::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (EdgeNameOrRef_case() == kName) {
    _impl_.EdgeNameOrRef_.name_.Destroy();
    clear_has_EdgeNameOrRef();
  }
}
inline const ::std::string& Edge::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Edge::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (EdgeNameOrRef_case() != kName) {
    clear_EdgeNameOrRef();

    set_has_name();
    _impl_.EdgeNameOrRef_.name_.InitDefault();
  }
  _impl_.EdgeNameOrRef_.name_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name)
}
inline ::std::string* PROTOBUF_NONNULL Edge::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  if (EdgeNameOrRef_case() != kName) {
    clear_EdgeNameOrRef();

    set_has_name();
    _impl_.EdgeNameOrRef_.name_.InitDefault();
  }
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Edge.name)
  return _s;
}
inline const ::std::string& Edge::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (EdgeNameOrRef_case() != kName) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.EdgeNameOrRef_.name_.Get();
}
inline void Edge::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.EdgeNameOrRef_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Edge::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.EdgeNameOrRef_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Edge::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Edge.name)
  if (EdgeNameOrRef_case() != kName) {
    return nullptr;
  }
  clear_has_EdgeNameOrRef();
  return _impl_.EdgeNameOrRef_.name_.Release();
}
inline void Edge::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has_EdgeNameOrRef()) {
    clear_EdgeNameOrRef();
  }
  if (value != nullptr) {
    set_has_name();
    _impl_.EdgeNameOrRef_.name_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Edge.name)
}

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

inline bool Edge::has_EdgeNameOrRef() const {
  return EdgeNameOrRef_case() != EDGENAMEORREF_NOT_SET;
}
inline void Edge::clear_has_EdgeNameOrRef() {
  _impl_._oneof_case_[0] = EDGENAMEORREF_NOT_SET;
}
inline Edge::EdgeNameOrRefCase Edge::EdgeNameOrRef_case() const {
  return Edge::EdgeNameOrRefCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // CoreDump_2eproto_2epb_2eh