Adding process_state protobuf and derived C++ files. Included README as well.

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@663 4c0a9323-5329-0410-9bdc-e9ce6186880e

4 files changed, 4369 insertions, 0 deletions

diff --git a/src/processor/proto/README b/src/processor/proto/README
new file mode 100644
index 00000000..f53f3f0d
--- /dev/null
+++ b/src/processor/proto/README
@@ -0,0 +1,23 @@
+All sourcecode in this file is generated using the .proto and protoc from
+the protobuf project (http://code.google.com/p/protobuf/).
+
+To make changes edit the .proto file and regenerate the dependent files for
+check in.
+
+-----
+Troubleshooting for Protobuf:
+
+Install:
+If you are getting permission errors install, make sure you are not trying to
+install from an NFS.
+
+
+Running protoc:
+protoc: error while loading shared libraries: libprotobuf.so.0: cannot open
+shared object file: No such file or directory
+
+The issue is that Ubuntu 8.04 doesn't include /usr/local/lib in
+library paths. 
+
+To fix it for your current terminal session, just type in
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib 
diff --git a/src/processor/proto/process_state.pb.cc b/src/processor/proto/process_state.pb.cc
new file mode 100644
index 00000000..3a0541e8
--- /dev/null
+++ b/src/processor/proto/process_state.pb.cc
@@ -0,0 +1,2498 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "process_state.pb.h"
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+
+namespace {
+
+const ::google::protobuf::Descriptor* ProcessStateProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProcessStateProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ProcessStateProto_Crash_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProcessStateProto_Crash_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ProcessStateProto_Thread_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProcessStateProto_Thread_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StackFrame_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StackFrame_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CodeModule_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CodeModule_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_process_5fstate_2eproto() {
+  protobuf_AddDesc_process_5fstate_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "process_state.proto");
+  GOOGLE_CHECK(file != NULL);
+  ProcessStateProto_descriptor_ = file->message_type(0);
+  static const int ProcessStateProto_offsets_[12] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, time_date_stamp_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, crash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, assertion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, requesting_thread_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, threads_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, modules_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_short_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_version_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_count_),
+  };
+  ProcessStateProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProcessStateProto_descriptor_,
+      ProcessStateProto::default_instance_,
+      ProcessStateProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProcessStateProto));
+  ProcessStateProto_Crash_descriptor_ = ProcessStateProto_descriptor_->nested_type(0);
+  static const int ProcessStateProto_Crash_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, address_),
+  };
+  ProcessStateProto_Crash_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProcessStateProto_Crash_descriptor_,
+      ProcessStateProto_Crash::default_instance_,
+      ProcessStateProto_Crash_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProcessStateProto_Crash));
+  ProcessStateProto_Thread_descriptor_ = ProcessStateProto_descriptor_->nested_type(1);
+  static const int ProcessStateProto_Thread_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, frames_),
+  };
+  ProcessStateProto_Thread_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProcessStateProto_Thread_descriptor_,
+      ProcessStateProto_Thread::default_instance_,
+      ProcessStateProto_Thread_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProcessStateProto_Thread));
+  StackFrame_descriptor_ = file->message_type(1);
+  static const int StackFrame_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, instruction_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, module_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, function_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, function_base_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_file_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_line_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_line_base_),
+  };
+  StackFrame_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StackFrame_descriptor_,
+      StackFrame::default_instance_,
+      StackFrame_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StackFrame));
+  CodeModule_descriptor_ = file->message_type(2);
+  static const int CodeModule_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, base_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, code_file_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, code_identifier_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, debug_file_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, debug_identifier_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, version_),
+  };
+  CodeModule_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CodeModule_descriptor_,
+      CodeModule::default_instance_,
+      CodeModule_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CodeModule));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_process_5fstate_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProcessStateProto_descriptor_, &ProcessStateProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProcessStateProto_Crash_descriptor_, &ProcessStateProto_Crash::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProcessStateProto_Thread_descriptor_, &ProcessStateProto_Thread::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StackFrame_descriptor_, &StackFrame::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CodeModule_descriptor_, &CodeModule::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_process_5fstate_2eproto() {
+  delete ProcessStateProto::default_instance_;
+  delete ProcessStateProto_reflection_;
+  delete ProcessStateProto_Crash::default_instance_;
+  delete ProcessStateProto_Crash_reflection_;
+  delete ProcessStateProto_Thread::default_instance_;
+  delete ProcessStateProto_Thread_reflection_;
+  delete StackFrame::default_instance_;
+  delete StackFrame_reflection_;
+  delete CodeModule::default_instance_;
+  delete CodeModule_reflection_;
+}
+
+void protobuf_AddDesc_process_5fstate_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023process_state.proto\"\202\003\n\021ProcessStatePr"
+    "oto\022\027\n\017time_date_stamp\030\001 \001(\003\022\'\n\005crash\030\002 "
+    "\001(\0132\030.ProcessStateProto.Crash\022\021\n\tasserti"
+    "on\030\003 \001(\t\022\031\n\021requesting_thread\030\004 \001(\005\022*\n\007t"
+    "hreads\030\005 \003(\0132\031.ProcessStateProto.Thread\022"
+    "\034\n\007modules\030\006 \003(\0132\013.CodeModule\022\n\n\002os\030\007 \001("
+    "\t\022\020\n\010os_short\030\010 \001(\t\022\022\n\nos_version\030\t \001(\t\022"
+    "\013\n\003cpu\030\n \001(\t\022\020\n\010cpu_info\030\013 \001(\t\022\021\n\tcpu_co"
+    "unt\030\014 \001(\005\032(\n\005Crash\022\016\n\006reason\030\001 \002(\t\022\017\n\007ad"
+    "dress\030\002 \002(\003\032%\n\006Thread\022\033\n\006frames\030\001 \003(\0132\013."
+    "StackFrame\"\265\001\n\nStackFrame\022\023\n\013instruction"
+    "\030\001 \002(\003\022\033\n\006module\030\002 \001(\0132\013.CodeModule\022\025\n\rf"
+    "unction_name\030\003 \001(\t\022\025\n\rfunction_base\030\004 \001("
+    "\003\022\030\n\020source_file_name\030\005 \001(\t\022\023\n\013source_li"
+    "ne\030\006 \001(\005\022\030\n\020source_line_base\030\007 \001(\003\"\233\001\n\nC"
+    "odeModule\022\024\n\014base_address\030\001 \001(\003\022\014\n\004size\030"
+    "\002 \001(\003\022\021\n\tcode_file\030\003 \001(\t\022\027\n\017code_identif"
+    "ier\030\004 \001(\t\022\022\n\ndebug_file\030\005 \001(\t\022\030\n\020debug_i"
+    "dentifier\030\006 \001(\t\022\017\n\007version\030\007 \001(\t", 752);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "process_state.proto", &protobuf_RegisterTypes);
+  ProcessStateProto::default_instance_ = new ProcessStateProto();
+  ProcessStateProto_Crash::default_instance_ = new ProcessStateProto_Crash();
+  ProcessStateProto_Thread::default_instance_ = new ProcessStateProto_Thread();
+  StackFrame::default_instance_ = new StackFrame();
+  CodeModule::default_instance_ = new CodeModule();
+  ProcessStateProto::default_instance_->InitAsDefaultInstance();
+  ProcessStateProto_Crash::default_instance_->InitAsDefaultInstance();
+  ProcessStateProto_Thread::default_instance_->InitAsDefaultInstance();
+  StackFrame::default_instance_->InitAsDefaultInstance();
+  CodeModule::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_process_5fstate_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_process_5fstate_2eproto {
+  StaticDescriptorInitializer_process_5fstate_2eproto() {
+    protobuf_AddDesc_process_5fstate_2eproto();
+  }
+} static_descriptor_initializer_process_5fstate_2eproto_;
+
+
+// ===================================================================
+
+const ::std::string ProcessStateProto_Crash::_default_reason_;
+#ifndef _MSC_VER
+const int ProcessStateProto_Crash::kReasonFieldNumber;
+const int ProcessStateProto_Crash::kAddressFieldNumber;
+#endif  // !_MSC_VER
+
+ProcessStateProto_Crash::ProcessStateProto_Crash()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ProcessStateProto_Crash::InitAsDefaultInstance() {
+}
+
+ProcessStateProto_Crash::ProcessStateProto_Crash(const ProcessStateProto_Crash& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ProcessStateProto_Crash::SharedCtor() {
+  _cached_size_ = 0;
+  reason_ = const_cast< ::std::string*>(&_default_reason_);
+  address_ = GOOGLE_LONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProcessStateProto_Crash::~ProcessStateProto_Crash() {
+  SharedDtor();
+}
+
+void ProcessStateProto_Crash::SharedDtor() {
+  if (reason_ != &_default_reason_) {
+    delete reason_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ProcessStateProto_Crash::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProcessStateProto_Crash::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProcessStateProto_Crash_descriptor_;
+}
+
+const ProcessStateProto_Crash& ProcessStateProto_Crash::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto();  return *default_instance_;
+}
+
+ProcessStateProto_Crash* ProcessStateProto_Crash::default_instance_ = NULL;
+
+ProcessStateProto_Crash* ProcessStateProto_Crash::New() const {
+  return new ProcessStateProto_Crash;
+}
+
+void ProcessStateProto_Crash::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (_has_bit(0)) {
+      if (reason_ != &_default_reason_) {
+        reason_->clear();
+      }
+    }
+    address_ = GOOGLE_LONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProcessStateProto_Crash::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string reason = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->reason().data(), this->reason().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_address;
+        break;
+      }
+      
+      // required int64 address = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_address:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &address_)));
+          _set_bit(1);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ProcessStateProto_Crash::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required string reason = 1;
+  if (_has_bit(0)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->reason(), output);
+  }
+  
+  // required int64 address = 2;
+  if (_has_bit(1)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->address(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ProcessStateProto_Crash::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required string reason = 1;
+  if (_has_bit(0)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->reason(), target);
+  }
+  
+  // required int64 address = 2;
+  if (_has_bit(1)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->address(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ProcessStateProto_Crash::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string reason = 1;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->reason());
+    }
+    
+    // required int64 address = 2;
+    if (has_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->address());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProcessStateProto_Crash::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProcessStateProto_Crash* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto_Crash*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProcessStateProto_Crash::MergeFrom(const ProcessStateProto_Crash& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from._has_bit(0)) {
+      set_reason(from.reason());
+    }
+    if (from._has_bit(1)) {
+      set_address(from.address());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessStateProto_Crash::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProcessStateProto_Crash::CopyFrom(const ProcessStateProto_Crash& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProcessStateProto_Crash::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void ProcessStateProto_Crash::Swap(ProcessStateProto_Crash* other) {
+  if (other != this) {
+    std::swap(reason_, other->reason_);
+    std::swap(address_, other->address_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProcessStateProto_Crash::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProcessStateProto_Crash_descriptor_;
+  metadata.reflection = ProcessStateProto_Crash_reflection_;
+  return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ProcessStateProto_Thread::kFramesFieldNumber;
+#endif  // !_MSC_VER
+
+ProcessStateProto_Thread::ProcessStateProto_Thread()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ProcessStateProto_Thread::InitAsDefaultInstance() {
+}
+
+ProcessStateProto_Thread::ProcessStateProto_Thread(const ProcessStateProto_Thread& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ProcessStateProto_Thread::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProcessStateProto_Thread::~ProcessStateProto_Thread() {
+  SharedDtor();
+}
+
+void ProcessStateProto_Thread::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ProcessStateProto_Thread::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProcessStateProto_Thread::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProcessStateProto_Thread_descriptor_;
+}
+
+const ProcessStateProto_Thread& ProcessStateProto_Thread::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto();  return *default_instance_;
+}
+
+ProcessStateProto_Thread* ProcessStateProto_Thread::default_instance_ = NULL;
+
+ProcessStateProto_Thread* ProcessStateProto_Thread::New() const {
+  return new ProcessStateProto_Thread;
+}
+
+void ProcessStateProto_Thread::Clear() {
+  frames_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProcessStateProto_Thread::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .StackFrame frames = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_frames:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_frames()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(10)) goto parse_frames;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ProcessStateProto_Thread::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // repeated .StackFrame frames = 1;
+  for (int i = 0; i < this->frames_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->frames(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ProcessStateProto_Thread::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // repeated .StackFrame frames = 1;
+  for (int i = 0; i < this->frames_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->frames(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ProcessStateProto_Thread::ByteSize() const {
+  int total_size = 0;
+  
+  // repeated .StackFrame frames = 1;
+  total_size += 1 * this->frames_size();
+  for (int i = 0; i < this->frames_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->frames(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProcessStateProto_Thread::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProcessStateProto_Thread* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto_Thread*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProcessStateProto_Thread::MergeFrom(const ProcessStateProto_Thread& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  frames_.MergeFrom(from.frames_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessStateProto_Thread::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProcessStateProto_Thread::CopyFrom(const ProcessStateProto_Thread& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProcessStateProto_Thread::IsInitialized() const {
+  
+  for (int i = 0; i < frames_size(); i++) {
+    if (!this->frames(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ProcessStateProto_Thread::Swap(ProcessStateProto_Thread* other) {
+  if (other != this) {
+    frames_.Swap(&other->frames_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProcessStateProto_Thread::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProcessStateProto_Thread_descriptor_;
+  metadata.reflection = ProcessStateProto_Thread_reflection_;
+  return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+const ::std::string ProcessStateProto::_default_assertion_;
+const ::std::string ProcessStateProto::_default_os_;
+const ::std::string ProcessStateProto::_default_os_short_;
+const ::std::string ProcessStateProto::_default_os_version_;
+const ::std::string ProcessStateProto::_default_cpu_;
+const ::std::string ProcessStateProto::_default_cpu_info_;
+#ifndef _MSC_VER
+const int ProcessStateProto::kTimeDateStampFieldNumber;
+const int ProcessStateProto::kCrashFieldNumber;
+const int ProcessStateProto::kAssertionFieldNumber;
+const int ProcessStateProto::kRequestingThreadFieldNumber;
+const int ProcessStateProto::kThreadsFieldNumber;
+const int ProcessStateProto::kModulesFieldNumber;
+const int ProcessStateProto::kOsFieldNumber;
+const int ProcessStateProto::kOsShortFieldNumber;
+const int ProcessStateProto::kOsVersionFieldNumber;
+const int ProcessStateProto::kCpuFieldNumber;
+const int ProcessStateProto::kCpuInfoFieldNumber;
+const int ProcessStateProto::kCpuCountFieldNumber;
+#endif  // !_MSC_VER
+
+ProcessStateProto::ProcessStateProto()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ProcessStateProto::InitAsDefaultInstance() {
+  crash_ = const_cast< ::ProcessStateProto_Crash*>(&::ProcessStateProto_Crash::default_instance());
+}
+
+ProcessStateProto::ProcessStateProto(const ProcessStateProto& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ProcessStateProto::SharedCtor() {
+  _cached_size_ = 0;
+  time_date_stamp_ = GOOGLE_LONGLONG(0);
+  crash_ = NULL;
+  assertion_ = const_cast< ::std::string*>(&_default_assertion_);
+  requesting_thread_ = 0;
+  os_ = const_cast< ::std::string*>(&_default_os_);
+  os_short_ = const_cast< ::std::string*>(&_default_os_short_);
+  os_version_ = const_cast< ::std::string*>(&_default_os_version_);
+  cpu_ = const_cast< ::std::string*>(&_default_cpu_);
+  cpu_info_ = const_cast< ::std::string*>(&_default_cpu_info_);
+  cpu_count_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProcessStateProto::~ProcessStateProto() {
+  SharedDtor();
+}
+
+void ProcessStateProto::SharedDtor() {
+  if (assertion_ != &_default_assertion_) {
+    delete assertion_;
+  }
+  if (os_ != &_default_os_) {
+    delete os_;
+  }
+  if (os_short_ != &_default_os_short_) {
+    delete os_short_;
+  }
+  if (os_version_ != &_default_os_version_) {
+    delete os_version_;
+  }
+  if (cpu_ != &_default_cpu_) {
+    delete cpu_;
+  }
+  if (cpu_info_ != &_default_cpu_info_) {
+    delete cpu_info_;
+  }
+  if (this != default_instance_) {
+    delete crash_;
+  }
+}
+
+void ProcessStateProto::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProcessStateProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProcessStateProto_descriptor_;
+}
+
+const ProcessStateProto& ProcessStateProto::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto();  return *default_instance_;
+}
+
+ProcessStateProto* ProcessStateProto::default_instance_ = NULL;
+
+ProcessStateProto* ProcessStateProto::New() const {
+  return new ProcessStateProto;
+}
+
+void ProcessStateProto::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    time_date_stamp_ = GOOGLE_LONGLONG(0);
+    if (_has_bit(1)) {
+      if (crash_ != NULL) crash_->::ProcessStateProto_Crash::Clear();
+    }
+    if (_has_bit(2)) {
+      if (assertion_ != &_default_assertion_) {
+        assertion_->clear();
+      }
+    }
+    requesting_thread_ = 0;
+    if (_has_bit(6)) {
+      if (os_ != &_default_os_) {
+        os_->clear();
+      }
+    }
+    if (_has_bit(7)) {
+      if (os_short_ != &_default_os_short_) {
+        os_short_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (_has_bit(8)) {
+      if (os_version_ != &_default_os_version_) {
+        os_version_->clear();
+      }
+    }
+    if (_has_bit(9)) {
+      if (cpu_ != &_default_cpu_) {
+        cpu_->clear();
+      }
+    }
+    if (_has_bit(10)) {
+      if (cpu_info_ != &_default_cpu_info_) {
+        cpu_info_->clear();
+      }
+    }
+    cpu_count_ = 0;
+  }
+  threads_.Clear();
+  modules_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProcessStateProto::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 time_date_stamp = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &time_date_stamp_)));
+          _set_bit(0);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_crash;
+        break;
+      }
+      
+      // optional .ProcessStateProto.Crash crash = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_crash:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_crash()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_assertion;
+        break;
+      }
+      
+      // optional string assertion = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_assertion:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_assertion()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->assertion().data(), this->assertion().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_requesting_thread;
+        break;
+      }
+      
+      // optional int32 requesting_thread = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_requesting_thread:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &requesting_thread_)));
+          _set_bit(3);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_threads;
+        break;
+      }
+      
+      // repeated .ProcessStateProto.Thread threads = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_threads:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_threads()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_threads;
+        if (input->ExpectTag(50)) goto parse_modules;
+        break;
+      }
+      
+      // repeated .CodeModule modules = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_modules:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_modules()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_modules;
+        if (input->ExpectTag(58)) goto parse_os;
+        break;
+      }
+      
+      // optional string os = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_os:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_os()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->os().data(), this->os().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(66)) goto parse_os_short;
+        break;
+      }
+      
+      // optional string os_short = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_os_short:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_os_short()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->os_short().data(), this->os_short().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(74)) goto parse_os_version;
+        break;
+      }
+      
+      // optional string os_version = 9;
+      case 9: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_os_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_os_version()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->os_version().data(), this->os_version().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(82)) goto parse_cpu;
+        break;
+      }
+      
+      // optional string cpu = 10;
+      case 10: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_cpu:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_cpu()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->cpu().data(), this->cpu().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(90)) goto parse_cpu_info;
+        break;
+      }
+      
+      // optional string cpu_info = 11;
+      case 11: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_cpu_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_cpu_info()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->cpu_info().data(), this->cpu_info().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(96)) goto parse_cpu_count;
+        break;
+      }
+      
+      // optional int32 cpu_count = 12;
+      case 12: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cpu_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &cpu_count_)));
+          _set_bit(11);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ProcessStateProto::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional int64 time_date_stamp = 1;
+  if (_has_bit(0)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->time_date_stamp(), output);
+  }
+  
+  // optional .ProcessStateProto.Crash crash = 2;
+  if (_has_bit(1)) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->crash(), output);
+  }
+  
+  // optional string assertion = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->assertion().data(), this->assertion().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->assertion(), output);
+  }
+  
+  // optional int32 requesting_thread = 4;
+  if (_has_bit(3)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->requesting_thread(), output);
+  }
+  
+  // repeated .ProcessStateProto.Thread threads = 5;
+  for (int i = 0; i < this->threads_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->threads(i), output);
+  }
+  
+  // repeated .CodeModule modules = 6;
+  for (int i = 0; i < this->modules_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->modules(i), output);
+  }
+  
+  // optional string os = 7;
+  if (_has_bit(6)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os().data(), this->os().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      7, this->os(), output);
+  }
+  
+  // optional string os_short = 8;
+  if (_has_bit(7)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os_short().data(), this->os_short().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      8, this->os_short(), output);
+  }
+  
+  // optional string os_version = 9;
+  if (_has_bit(8)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os_version().data(), this->os_version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      9, this->os_version(), output);
+  }
+  
+  // optional string cpu = 10;
+  if (_has_bit(9)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->cpu().data(), this->cpu().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      10, this->cpu(), output);
+  }
+  
+  // optional string cpu_info = 11;
+  if (_has_bit(10)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->cpu_info().data(), this->cpu_info().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      11, this->cpu_info(), output);
+  }
+  
+  // optional int32 cpu_count = 12;
+  if (_has_bit(11)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->cpu_count(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ProcessStateProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional int64 time_date_stamp = 1;
+  if (_has_bit(0)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->time_date_stamp(), target);
+  }
+  
+  // optional .ProcessStateProto.Crash crash = 2;
+  if (_has_bit(1)) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->crash(), target);
+  }
+  
+  // optional string assertion = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->assertion().data(), this->assertion().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->assertion(), target);
+  }
+  
+  // optional int32 requesting_thread = 4;
+  if (_has_bit(3)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->requesting_thread(), target);
+  }
+  
+  // repeated .ProcessStateProto.Thread threads = 5;
+  for (int i = 0; i < this->threads_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->threads(i), target);
+  }
+  
+  // repeated .CodeModule modules = 6;
+  for (int i = 0; i < this->modules_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->modules(i), target);
+  }
+  
+  // optional string os = 7;
+  if (_has_bit(6)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os().data(), this->os().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->os(), target);
+  }
+  
+  // optional string os_short = 8;
+  if (_has_bit(7)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os_short().data(), this->os_short().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->os_short(), target);
+  }
+  
+  // optional string os_version = 9;
+  if (_has_bit(8)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->os_version().data(), this->os_version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->os_version(), target);
+  }
+  
+  // optional string cpu = 10;
+  if (_has_bit(9)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->cpu().data(), this->cpu().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        10, this->cpu(), target);
+  }
+  
+  // optional string cpu_info = 11;
+  if (_has_bit(10)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->cpu_info().data(), this->cpu_info().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        11, this->cpu_info(), target);
+  }
+  
+  // optional int32 cpu_count = 12;
+  if (_has_bit(11)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->cpu_count(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ProcessStateProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 time_date_stamp = 1;
+    if (has_time_date_stamp()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->time_date_stamp());
+    }
+    
+    // optional .ProcessStateProto.Crash crash = 2;
+    if (has_crash()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->crash());
+    }
+    
+    // optional string assertion = 3;
+    if (has_assertion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->assertion());
+    }
+    
+    // optional int32 requesting_thread = 4;
+    if (has_requesting_thread()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->requesting_thread());
+    }
+    
+    // optional string os = 7;
+    if (has_os()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->os());
+    }
+    
+    // optional string os_short = 8;
+    if (has_os_short()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->os_short());
+    }
+    
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string os_version = 9;
+    if (has_os_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->os_version());
+    }
+    
+    // optional string cpu = 10;
+    if (has_cpu()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->cpu());
+    }
+    
+    // optional string cpu_info = 11;
+    if (has_cpu_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->cpu_info());
+    }
+    
+    // optional int32 cpu_count = 12;
+    if (has_cpu_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->cpu_count());
+    }
+    
+  }
+  // repeated .ProcessStateProto.Thread threads = 5;
+  total_size += 1 * this->threads_size();
+  for (int i = 0; i < this->threads_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->threads(i));
+  }
+  
+  // repeated .CodeModule modules = 6;
+  total_size += 1 * this->modules_size();
+  for (int i = 0; i < this->modules_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->modules(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProcessStateProto::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProcessStateProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProcessStateProto::MergeFrom(const ProcessStateProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  threads_.MergeFrom(from.threads_);
+  modules_.MergeFrom(from.modules_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from._has_bit(0)) {
+      set_time_date_stamp(from.time_date_stamp());
+    }
+    if (from._has_bit(1)) {
+      mutable_crash()->::ProcessStateProto_Crash::MergeFrom(from.crash());
+    }
+    if (from._has_bit(2)) {
+      set_assertion(from.assertion());
+    }
+    if (from._has_bit(3)) {
+      set_requesting_thread(from.requesting_thread());
+    }
+    if (from._has_bit(6)) {
+      set_os(from.os());
+    }
+    if (from._has_bit(7)) {
+      set_os_short(from.os_short());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from._has_bit(8)) {
+      set_os_version(from.os_version());
+    }
+    if (from._has_bit(9)) {
+      set_cpu(from.cpu());
+    }
+    if (from._has_bit(10)) {
+      set_cpu_info(from.cpu_info());
+    }
+    if (from._has_bit(11)) {
+      set_cpu_count(from.cpu_count());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessStateProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProcessStateProto::CopyFrom(const ProcessStateProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProcessStateProto::IsInitialized() const {
+  
+  if (has_crash()) {
+    if (!this->crash().IsInitialized()) return false;
+  }
+  for (int i = 0; i < threads_size(); i++) {
+    if (!this->threads(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ProcessStateProto::Swap(ProcessStateProto* other) {
+  if (other != this) {
+    std::swap(time_date_stamp_, other->time_date_stamp_);
+    std::swap(crash_, other->crash_);
+    std::swap(assertion_, other->assertion_);
+    std::swap(requesting_thread_, other->requesting_thread_);
+    threads_.Swap(&other->threads_);
+    modules_.Swap(&other->modules_);
+    std::swap(os_, other->os_);
+    std::swap(os_short_, other->os_short_);
+    std::swap(os_version_, other->os_version_);
+    std::swap(cpu_, other->cpu_);
+    std::swap(cpu_info_, other->cpu_info_);
+    std::swap(cpu_count_, other->cpu_count_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProcessStateProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProcessStateProto_descriptor_;
+  metadata.reflection = ProcessStateProto_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string StackFrame::_default_function_name_;
+const ::std::string StackFrame::_default_source_file_name_;
+#ifndef _MSC_VER
+const int StackFrame::kInstructionFieldNumber;
+const int StackFrame::kModuleFieldNumber;
+const int StackFrame::kFunctionNameFieldNumber;
+const int StackFrame::kFunctionBaseFieldNumber;
+const int StackFrame::kSourceFileNameFieldNumber;
+const int StackFrame::kSourceLineFieldNumber;
+const int StackFrame::kSourceLineBaseFieldNumber;
+#endif  // !_MSC_VER
+
+StackFrame::StackFrame()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void StackFrame::InitAsDefaultInstance() {
+  module_ = const_cast< ::CodeModule*>(&::CodeModule::default_instance());
+}
+
+StackFrame::StackFrame(const StackFrame& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void StackFrame::SharedCtor() {
+  _cached_size_ = 0;
+  instruction_ = GOOGLE_LONGLONG(0);
+  module_ = NULL;
+  function_name_ = const_cast< ::std::string*>(&_default_function_name_);
+  function_base_ = GOOGLE_LONGLONG(0);
+  source_file_name_ = const_cast< ::std::string*>(&_default_source_file_name_);
+  source_line_ = 0;
+  source_line_base_ = GOOGLE_LONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StackFrame::~StackFrame() {
+  SharedDtor();
+}
+
+void StackFrame::SharedDtor() {
+  if (function_name_ != &_default_function_name_) {
+    delete function_name_;
+  }
+  if (source_file_name_ != &_default_source_file_name_) {
+    delete source_file_name_;
+  }
+  if (this != default_instance_) {
+    delete module_;
+  }
+}
+
+void StackFrame::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StackFrame::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StackFrame_descriptor_;
+}
+
+const StackFrame& StackFrame::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto();  return *default_instance_;
+}
+
+StackFrame* StackFrame::default_instance_ = NULL;
+
+StackFrame* StackFrame::New() const {
+  return new StackFrame;
+}
+
+void StackFrame::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    instruction_ = GOOGLE_LONGLONG(0);
+    if (_has_bit(1)) {
+      if (module_ != NULL) module_->::CodeModule::Clear();
+    }
+    if (_has_bit(2)) {
+      if (function_name_ != &_default_function_name_) {
+        function_name_->clear();
+      }
+    }
+    function_base_ = GOOGLE_LONGLONG(0);
+    if (_has_bit(4)) {
+      if (source_file_name_ != &_default_source_file_name_) {
+        source_file_name_->clear();
+      }
+    }
+    source_line_ = 0;
+    source_line_base_ = GOOGLE_LONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StackFrame::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required int64 instruction = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &instruction_)));
+          _set_bit(0);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_module;
+        break;
+      }
+      
+      // optional .CodeModule module = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_module:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_module()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_function_name;
+        break;
+      }
+      
+      // optional string function_name = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_function_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_function_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->function_name().data(), this->function_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_function_base;
+        break;
+      }
+      
+      // optional int64 function_base = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_function_base:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &function_base_)));
+          _set_bit(3);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_source_file_name;
+        break;
+      }
+      
+      // optional string source_file_name = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_source_file_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_source_file_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->source_file_name().data(), this->source_file_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_source_line;
+        break;
+      }
+      
+      // optional int32 source_line = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_source_line:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &source_line_)));
+          _set_bit(5);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_source_line_base;
+        break;
+      }
+      
+      // optional int64 source_line_base = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_source_line_base:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &source_line_base_)));
+          _set_bit(6);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void StackFrame::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required int64 instruction = 1;
+  if (_has_bit(0)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->instruction(), output);
+  }
+  
+  // optional .CodeModule module = 2;
+  if (_has_bit(1)) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->module(), output);
+  }
+  
+  // optional string function_name = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->function_name().data(), this->function_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->function_name(), output);
+  }
+  
+  // optional int64 function_base = 4;
+  if (_has_bit(3)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->function_base(), output);
+  }
+  
+  // optional string source_file_name = 5;
+  if (_has_bit(4)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->source_file_name().data(), this->source_file_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      5, this->source_file_name(), output);
+  }
+  
+  // optional int32 source_line = 6;
+  if (_has_bit(5)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->source_line(), output);
+  }
+  
+  // optional int64 source_line_base = 7;
+  if (_has_bit(6)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->source_line_base(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* StackFrame::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required int64 instruction = 1;
+  if (_has_bit(0)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->instruction(), target);
+  }
+  
+  // optional .CodeModule module = 2;
+  if (_has_bit(1)) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->module(), target);
+  }
+  
+  // optional string function_name = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->function_name().data(), this->function_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->function_name(), target);
+  }
+  
+  // optional int64 function_base = 4;
+  if (_has_bit(3)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->function_base(), target);
+  }
+  
+  // optional string source_file_name = 5;
+  if (_has_bit(4)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->source_file_name().data(), this->source_file_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->source_file_name(), target);
+  }
+  
+  // optional int32 source_line = 6;
+  if (_has_bit(5)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->source_line(), target);
+  }
+  
+  // optional int64 source_line_base = 7;
+  if (_has_bit(6)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->source_line_base(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int StackFrame::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required int64 instruction = 1;
+    if (has_instruction()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->instruction());
+    }
+    
+    // optional .CodeModule module = 2;
+    if (has_module()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->module());
+    }
+    
+    // optional string function_name = 3;
+    if (has_function_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->function_name());
+    }
+    
+    // optional int64 function_base = 4;
+    if (has_function_base()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->function_base());
+    }
+    
+    // optional string source_file_name = 5;
+    if (has_source_file_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->source_file_name());
+    }
+    
+    // optional int32 source_line = 6;
+    if (has_source_line()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->source_line());
+    }
+    
+    // optional int64 source_line_base = 7;
+    if (has_source_line_base()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->source_line_base());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StackFrame::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StackFrame* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StackFrame*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StackFrame::MergeFrom(const StackFrame& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from._has_bit(0)) {
+      set_instruction(from.instruction());
+    }
+    if (from._has_bit(1)) {
+      mutable_module()->::CodeModule::MergeFrom(from.module());
+    }
+    if (from._has_bit(2)) {
+      set_function_name(from.function_name());
+    }
+    if (from._has_bit(3)) {
+      set_function_base(from.function_base());
+    }
+    if (from._has_bit(4)) {
+      set_source_file_name(from.source_file_name());
+    }
+    if (from._has_bit(5)) {
+      set_source_line(from.source_line());
+    }
+    if (from._has_bit(6)) {
+      set_source_line_base(from.source_line_base());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StackFrame::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StackFrame::CopyFrom(const StackFrame& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StackFrame::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  return true;
+}
+
+void StackFrame::Swap(StackFrame* other) {
+  if (other != this) {
+    std::swap(instruction_, other->instruction_);
+    std::swap(module_, other->module_);
+    std::swap(function_name_, other->function_name_);
+    std::swap(function_base_, other->function_base_);
+    std::swap(source_file_name_, other->source_file_name_);
+    std::swap(source_line_, other->source_line_);
+    std::swap(source_line_base_, other->source_line_base_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StackFrame::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StackFrame_descriptor_;
+  metadata.reflection = StackFrame_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string CodeModule::_default_code_file_;
+const ::std::string CodeModule::_default_code_identifier_;
+const ::std::string CodeModule::_default_debug_file_;
+const ::std::string CodeModule::_default_debug_identifier_;
+const ::std::string CodeModule::_default_version_;
+#ifndef _MSC_VER
+const int CodeModule::kBaseAddressFieldNumber;
+const int CodeModule::kSizeFieldNumber;
+const int CodeModule::kCodeFileFieldNumber;
+const int CodeModule::kCodeIdentifierFieldNumber;
+const int CodeModule::kDebugFileFieldNumber;
+const int CodeModule::kDebugIdentifierFieldNumber;
+const int CodeModule::kVersionFieldNumber;
+#endif  // !_MSC_VER
+
+CodeModule::CodeModule()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void CodeModule::InitAsDefaultInstance() {
+}
+
+CodeModule::CodeModule(const CodeModule& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CodeModule::SharedCtor() {
+  _cached_size_ = 0;
+  base_address_ = GOOGLE_LONGLONG(0);
+  size_ = GOOGLE_LONGLONG(0);
+  code_file_ = const_cast< ::std::string*>(&_default_code_file_);
+  code_identifier_ = const_cast< ::std::string*>(&_default_code_identifier_);
+  debug_file_ = const_cast< ::std::string*>(&_default_debug_file_);
+  debug_identifier_ = const_cast< ::std::string*>(&_default_debug_identifier_);
+  version_ = const_cast< ::std::string*>(&_default_version_);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CodeModule::~CodeModule() {
+  SharedDtor();
+}
+
+void CodeModule::SharedDtor() {
+  if (code_file_ != &_default_code_file_) {
+    delete code_file_;
+  }
+  if (code_identifier_ != &_default_code_identifier_) {
+    delete code_identifier_;
+  }
+  if (debug_file_ != &_default_debug_file_) {
+    delete debug_file_;
+  }
+  if (debug_identifier_ != &_default_debug_identifier_) {
+    delete debug_identifier_;
+  }
+  if (version_ != &_default_version_) {
+    delete version_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void CodeModule::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CodeModule::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CodeModule_descriptor_;
+}
+
+const CodeModule& CodeModule::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto();  return *default_instance_;
+}
+
+CodeModule* CodeModule::default_instance_ = NULL;
+
+CodeModule* CodeModule::New() const {
+  return new CodeModule;
+}
+
+void CodeModule::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    base_address_ = GOOGLE_LONGLONG(0);
+    size_ = GOOGLE_LONGLONG(0);
+    if (_has_bit(2)) {
+      if (code_file_ != &_default_code_file_) {
+        code_file_->clear();
+      }
+    }
+    if (_has_bit(3)) {
+      if (code_identifier_ != &_default_code_identifier_) {
+        code_identifier_->clear();
+      }
+    }
+    if (_has_bit(4)) {
+      if (debug_file_ != &_default_debug_file_) {
+        debug_file_->clear();
+      }
+    }
+    if (_has_bit(5)) {
+      if (debug_identifier_ != &_default_debug_identifier_) {
+        debug_identifier_->clear();
+      }
+    }
+    if (_has_bit(6)) {
+      if (version_ != &_default_version_) {
+        version_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CodeModule::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 base_address = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &base_address_)));
+          _set_bit(0);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_size;
+        break;
+      }
+      
+      // optional int64 size = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &size_)));
+          _set_bit(1);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_code_file;
+        break;
+      }
+      
+      // optional string code_file = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_code_file:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_code_file()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->code_file().data(), this->code_file().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_code_identifier;
+        break;
+      }
+      
+      // optional string code_identifier = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_code_identifier:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_code_identifier()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->code_identifier().data(), this->code_identifier().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_debug_file;
+        break;
+      }
+      
+      // optional string debug_file = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_debug_file:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_debug_file()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->debug_file().data(), this->debug_file().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_debug_identifier;
+        break;
+      }
+      
+      // optional string debug_identifier = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_debug_identifier:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_debug_identifier()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->debug_identifier().data(), this->debug_identifier().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(58)) goto parse_version;
+        break;
+      }
+      
+      // optional string version = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->version().data(), this->version().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void CodeModule::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional int64 base_address = 1;
+  if (_has_bit(0)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->base_address(), output);
+  }
+  
+  // optional int64 size = 2;
+  if (_has_bit(1)) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->size(), output);
+  }
+  
+  // optional string code_file = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->code_file().data(), this->code_file().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->code_file(), output);
+  }
+  
+  // optional string code_identifier = 4;
+  if (_has_bit(3)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->code_identifier().data(), this->code_identifier().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->code_identifier(), output);
+  }
+  
+  // optional string debug_file = 5;
+  if (_has_bit(4)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->debug_file().data(), this->debug_file().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      5, this->debug_file(), output);
+  }
+  
+  // optional string debug_identifier = 6;
+  if (_has_bit(5)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->debug_identifier().data(), this->debug_identifier().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->debug_identifier(), output);
+  }
+  
+  // optional string version = 7;
+  if (_has_bit(6)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      7, this->version(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CodeModule::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional int64 base_address = 1;
+  if (_has_bit(0)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->base_address(), target);
+  }
+  
+  // optional int64 size = 2;
+  if (_has_bit(1)) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->size(), target);
+  }
+  
+  // optional string code_file = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->code_file().data(), this->code_file().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->code_file(), target);
+  }
+  
+  // optional string code_identifier = 4;
+  if (_has_bit(3)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->code_identifier().data(), this->code_identifier().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->code_identifier(), target);
+  }
+  
+  // optional string debug_file = 5;
+  if (_has_bit(4)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->debug_file().data(), this->debug_file().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->debug_file(), target);
+  }
+  
+  // optional string debug_identifier = 6;
+  if (_has_bit(5)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->debug_identifier().data(), this->debug_identifier().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->debug_identifier(), target);
+  }
+  
+  // optional string version = 7;
+  if (_has_bit(6)) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->version(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int CodeModule::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 base_address = 1;
+    if (has_base_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->base_address());
+    }
+    
+    // optional int64 size = 2;
+    if (has_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->size());
+    }
+    
+    // optional string code_file = 3;
+    if (has_code_file()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->code_file());
+    }
+    
+    // optional string code_identifier = 4;
+    if (has_code_identifier()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->code_identifier());
+    }
+    
+    // optional string debug_file = 5;
+    if (has_debug_file()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->debug_file());
+    }
+    
+    // optional string debug_identifier = 6;
+    if (has_debug_identifier()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->debug_identifier());
+    }
+    
+    // optional string version = 7;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CodeModule::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CodeModule* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CodeModule*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CodeModule::MergeFrom(const CodeModule& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from._has_bit(0)) {
+      set_base_address(from.base_address());
+    }
+    if (from._has_bit(1)) {
+      set_size(from.size());
+    }
+    if (from._has_bit(2)) {
+      set_code_file(from.code_file());
+    }
+    if (from._has_bit(3)) {
+      set_code_identifier(from.code_identifier());
+    }
+    if (from._has_bit(4)) {
+      set_debug_file(from.debug_file());
+    }
+    if (from._has_bit(5)) {
+      set_debug_identifier(from.debug_identifier());
+    }
+    if (from._has_bit(6)) {
+      set_version(from.version());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CodeModule::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CodeModule::CopyFrom(const CodeModule& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CodeModule::IsInitialized() const {
+  
+  return true;
+}
+
+void CodeModule::Swap(CodeModule* other) {
+  if (other != this) {
+    std::swap(base_address_, other->base_address_);
+    std::swap(size_, other->size_);
+    std::swap(code_file_, other->code_file_);
+    std::swap(code_identifier_, other->code_identifier_);
+    std::swap(debug_file_, other->debug_file_);
+    std::swap(debug_identifier_, other->debug_identifier_);
+    std::swap(version_, other->version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CodeModule::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CodeModule_descriptor_;
+  metadata.reflection = CodeModule_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/processor/proto/process_state.pb.h b/src/processor/proto/process_state.pb.h
new file mode 100644
index 00000000..d4b30261
--- /dev/null
+++ b/src/processor/proto/process_state.pb.h
@@ -0,0 +1,1644 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: process_state.proto
+
+#ifndef PROTOBUF_process_5fstate_2eproto__INCLUDED
+#define PROTOBUF_process_5fstate_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_message_reflection.h>
+// @@protoc_insertion_point(includes)
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_process_5fstate_2eproto();
+void protobuf_AssignDesc_process_5fstate_2eproto();
+void protobuf_ShutdownFile_process_5fstate_2eproto();
+
+class ProcessStateProto;
+class ProcessStateProto_Crash;
+class ProcessStateProto_Thread;
+class StackFrame;
+class CodeModule;
+
+// ===================================================================
+
+class ProcessStateProto_Crash : public ::google::protobuf::Message {
+ public:
+  ProcessStateProto_Crash();
+  virtual ~ProcessStateProto_Crash();
+  
+  ProcessStateProto_Crash(const ProcessStateProto_Crash& from);
+  
+  inline ProcessStateProto_Crash& operator=(const ProcessStateProto_Crash& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProcessStateProto_Crash& default_instance();
+  
+  void Swap(ProcessStateProto_Crash* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ProcessStateProto_Crash* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProcessStateProto_Crash& from);
+  void MergeFrom(const ProcessStateProto_Crash& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required string reason = 1;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 1;
+  inline const ::std::string& reason() const;
+  inline void set_reason(const ::std::string& value);
+  inline void set_reason(const char* value);
+  inline void set_reason(const char* value, size_t size);
+  inline ::std::string* mutable_reason();
+  
+  // required int64 address = 2;
+  inline bool has_address() const;
+  inline void clear_address();
+  static const int kAddressFieldNumber = 2;
+  inline ::google::protobuf::int64 address() const;
+  inline void set_address(::google::protobuf::int64 value);
+  
+  // @@protoc_insertion_point(class_scope:ProcessStateProto.Crash)
+ private:
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  mutable int _cached_size_;
+  
+  ::std::string* reason_;
+  static const ::std::string _default_reason_;
+  ::google::protobuf::int64 address_;
+  friend void  protobuf_AddDesc_process_5fstate_2eproto();
+  friend void protobuf_AssignDesc_process_5fstate_2eproto();
+  friend void protobuf_ShutdownFile_process_5fstate_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
+  inline bool _has_bit(int index) const {
+    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
+  }
+  inline void _set_bit(int index) {
+    _has_bits_[index / 32] |= (1u << (index % 32));
+  }
+  inline void _clear_bit(int index) {
+    _has_bits_[index / 32] &= ~(1u << (index % 32));
+  }
+  
+  void InitAsDefaultInstance();
+  static ProcessStateProto_Crash* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ProcessStateProto_Thread : public ::google::protobuf::Message {
+ public:
+  ProcessStateProto_Thread();
+  virtual ~ProcessStateProto_Thread();
+  
+  ProcessStateProto_Thread(const ProcessStateProto_Thread& from);
+  
+  inline ProcessStateProto_Thread& operator=(const ProcessStateProto_Thread& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProcessStateProto_Thread& default_instance();
+  
+  void Swap(ProcessStateProto_Thread* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ProcessStateProto_Thread* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProcessStateProto_Thread& from);
+  void MergeFrom(const ProcessStateProto_Thread& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // repeated .StackFrame frames = 1;
+  inline int frames_size() const;
+  inline void clear_frames();
+  static const int kFramesFieldNumber = 1;
+  inline const ::StackFrame& frames(int index) const;
+  inline ::StackFrame* mutable_frames(int index);
+  inline ::StackFrame* add_frames();
+  inline const ::google::protobuf::RepeatedPtrField< ::StackFrame >&
+      frames() const;
+  inline ::google::protobuf::RepeatedPtrField< ::StackFrame >*
+      mutable_frames();
+  
+  // @@protoc_insertion_point(class_scope:ProcessStateProto.Thread)
+ private:
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  mutable int _cached_size_;
+  
+  ::google::protobuf::RepeatedPtrField< ::StackFrame > frames_;
+  friend void  protobuf_AddDesc_process_5fstate_2eproto();
+  friend void protobuf_AssignDesc_process_5fstate_2eproto();
+  friend void protobuf_ShutdownFile_process_5fstate_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+  
+  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
+  inline bool _has_bit(int index) const {
+    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
+  }
+  inline void _set_bit(int index) {
+    _has_bits_[index / 32] |= (1u << (index % 32));
+  }
+  inline void _clear_bit(int index) {
+    _has_bits_[index / 32] &= ~(1u << (index % 32));
+  }
+  
+  void InitAsDefaultInstance();
+  static ProcessStateProto_Thread* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ProcessStateProto : public ::google::protobuf::Message {
+ public:
+  ProcessStateProto();
+  virtual ~ProcessStateProto();
+  
+  ProcessStateProto(const ProcessStateProto& from);
+  
+  inline ProcessStateProto& operator=(const ProcessStateProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProcessStateProto& default_instance();
+  
+  void Swap(ProcessStateProto* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ProcessStateProto* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProcessStateProto& from);
+  void MergeFrom(const ProcessStateProto& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  typedef ProcessStateProto_Crash Crash;
+  typedef ProcessStateProto_Thread Thread;
+  
+  // accessors -------------------------------------------------------
+  
+  // optional int64 time_date_stamp = 1;
+  inline bool has_time_date_stamp() const;
+  inline void clear_time_date_stamp();
+  static const int kTimeDateStampFieldNumber = 1;
+  inline ::google::protobuf::int64 time_date_stamp() const;
+  inline void set_time_date_stamp(::google::protobuf::int64 value);
+  
+  // optional .ProcessStateProto.Crash crash = 2;
+  inline bool has_crash() const;
+  inline void clear_crash();
+  static const int kCrashFieldNumber = 2;
+  inline const ::ProcessStateProto_Crash& crash() const;
+  inline ::ProcessStateProto_Crash* mutable_crash();
+  
+  // optional string assertion = 3;
+  inline bool has_assertion() const;
+  inline void clear_assertion();
+  static const int kAssertionFieldNumber = 3;
+  inline const ::std::string& assertion() const;
+  inline void set_assertion(const ::std::string& value);
+  inline void set_assertion(const char* value);
+  inline void set_assertion(const char* value, size_t size);
+  inline ::std::string* mutable_assertion();
+  
+  // optional int32 requesting_thread = 4;
+  inline bool has_requesting_thread() const;
+  inline void clear_requesting_thread();
+  static const int kRequestingThreadFieldNumber = 4;
+  inline ::google::protobuf::int32 requesting_thread() const;
+  inline void set_requesting_thread(::google::protobuf::int32 value);
+  
+  // repeated .ProcessStateProto.Thread threads = 5;
+  inline int threads_size() const;
+  inline void clear_threads();
+  static const int kThreadsFieldNumber = 5;
+  inline const ::ProcessStateProto_Thread& threads(int index) const;
+  inline ::ProcessStateProto_Thread* mutable_threads(int index);
+  inline ::ProcessStateProto_Thread* add_threads();
+  inline const ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >&
+      threads() const;
+  inline ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >*
+      mutable_threads();
+  
+  // repeated .CodeModule modules = 6;
+  inline int modules_size() const;
+  inline void clear_modules();
+  static const int kModulesFieldNumber = 6;
+  inline const ::CodeModule& modules(int index) const;
+  inline ::CodeModule* mutable_modules(int index);
+  inline ::CodeModule* add_modules();
+  inline const ::google::protobuf::RepeatedPtrField< ::CodeModule >&
+      modules() const;
+  inline ::google::protobuf::RepeatedPtrField< ::CodeModule >*
+      mutable_modules();
+  
+  // optional string os = 7;
+  inline bool has_os() const;
+  inline void clear_os();
+  static const int kOsFieldNumber = 7;
+  inline const ::std::string& os() const;
+  inline void set_os(const ::std::string& value);
+  inline void set_os(const char* value);
+  inline void set_os(const char* value, size_t size);
+  inline ::std::string* mutable_os();
+  
+  // optional string os_short = 8;
+  inline bool has_os_short() const;
+  inline void clear_os_short();
+  static const int kOsShortFieldNumber = 8;
+  inline const ::std::string& os_short() const;
+  inline void set_os_short(const ::std::string& value);
+  inline void set_os_short(const char* value);
+  inline void set_os_short(const char* value, size_t size);
+  inline ::std::string* mutable_os_short();
+  
+  // optional string os_version = 9;
+  inline bool has_os_version() const;
+  inline void clear_os_version();
+  static const int kOsVersionFieldNumber = 9;
+  inline const ::std::string& os_version() const;
+  inline void set_os_version(const ::std::string& value);
+  inline void set_os_version(const char* value);
+  inline void set_os_version(const char* value, size_t size);
+  inline ::std::string* mutable_os_version();
+  
+  // optional string cpu = 10;
+  inline bool has_cpu() const;
+  inline void clear_cpu();
+  static const int kCpuFieldNumber = 10;
+  inline const ::std::string& cpu() const;
+  inline void set_cpu(const ::std::string& value);
+  inline void set_cpu(const char* value);
+  inline void set_cpu(const char* value, size_t size);
+  inline ::std::string* mutable_cpu();
+  
+  // optional string cpu_info = 11;
+  inline bool has_cpu_info() const;
+  inline void clear_cpu_info();
+  static const int kCpuInfoFieldNumber = 11;
+  inline const ::std::string& cpu_info() const;
+  inline void set_cpu_info(const ::std::string& value);
+  inline void set_cpu_info(const char* value);
+  inline void set_cpu_info(const char* value, size_t size);
+  inline ::std::string* mutable_cpu_info();
+  
+  // optional int32 cpu_count = 12;
+  inline bool has_cpu_count() const;
+  inline void clear_cpu_count();
+  static const int kCpuCountFieldNumber = 12;
+  inline ::google::protobuf::int32 cpu_count() const;
+  inline void set_cpu_count(::google::protobuf::int32 value);
+  
+  // @@protoc_insertion_point(class_scope:ProcessStateProto)
+ private:
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  mutable int _cached_size_;
+  
+  ::google::protobuf::int64 time_date_stamp_;
+  ::ProcessStateProto_Crash* crash_;
+  ::std::string* assertion_;
+  static const ::std::string _default_assertion_;
+  ::google::protobuf::int32 requesting_thread_;
+  ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread > threads_;
+  ::google::protobuf::RepeatedPtrField< ::CodeModule > modules_;
+  ::std::string* os_;
+  static const ::std::string _default_os_;
+  ::std::string* os_short_;
+  static const ::std::string _default_os_short_;
+  ::std::string* os_version_;
+  static const ::std::string _default_os_version_;
+  ::std::string* cpu_;
+  static const ::std::string _default_cpu_;
+  ::std::string* cpu_info_;
+  static const ::std::string _default_cpu_info_;
+  ::google::protobuf::int32 cpu_count_;
+  friend void  protobuf_AddDesc_process_5fstate_2eproto();
+  friend void protobuf_AssignDesc_process_5fstate_2eproto();
+  friend void protobuf_ShutdownFile_process_5fstate_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];
+  
+  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
+  inline bool _has_bit(int index) const {
+    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
+  }
+  inline void _set_bit(int index) {
+    _has_bits_[index / 32] |= (1u << (index % 32));
+  }
+  inline void _clear_bit(int index) {
+    _has_bits_[index / 32] &= ~(1u << (index % 32));
+  }
+  
+  void InitAsDefaultInstance();
+  static ProcessStateProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class StackFrame : public ::google::protobuf::Message {
+ public:
+  StackFrame();
+  virtual ~StackFrame();
+  
+  StackFrame(const StackFrame& from);
+  
+  inline StackFrame& operator=(const StackFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StackFrame& default_instance();
+  
+  void Swap(StackFrame* other);
+  
+  // implements Message ----------------------------------------------
+  
+  StackFrame* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StackFrame& from);
+  void MergeFrom(const StackFrame& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required int64 instruction = 1;
+  inline bool has_instruction() const;
+  inline void clear_instruction();
+  static const int kInstructionFieldNumber = 1;
+  inline ::google::protobuf::int64 instruction() const;
+  inline void set_instruction(::google::protobuf::int64 value);
+  
+  // optional .CodeModule module = 2;
+  inline bool has_module() const;
+  inline void clear_module();
+  static const int kModuleFieldNumber = 2;
+  inline const ::CodeModule& module() const;
+  inline ::CodeModule* mutable_module();
+  
+  // optional string function_name = 3;
+  inline bool has_function_name() const;
+  inline void clear_function_name();
+  static const int kFunctionNameFieldNumber = 3;
+  inline const ::std::string& function_name() const;
+  inline void set_function_name(const ::std::string& value);
+  inline void set_function_name(const char* value);
+  inline void set_function_name(const char* value, size_t size);
+  inline ::std::string* mutable_function_name();
+  
+  // optional int64 function_base = 4;
+  inline bool has_function_base() const;
+  inline void clear_function_base();
+  static const int kFunctionBaseFieldNumber = 4;
+  inline ::google::protobuf::int64 function_base() const;
+  inline void set_function_base(::google::protobuf::int64 value);
+  
+  // optional string source_file_name = 5;
+  inline bool has_source_file_name() const;
+  inline void clear_source_file_name();
+  static const int kSourceFileNameFieldNumber = 5;
+  inline const ::std::string& source_file_name() const;
+  inline void set_source_file_name(const ::std::string& value);
+  inline void set_source_file_name(const char* value);
+  inline void set_source_file_name(const char* value, size_t size);
+  inline ::std::string* mutable_source_file_name();
+  
+  // optional int32 source_line = 6;
+  inline bool has_source_line() const;
+  inline void clear_source_line();
+  static const int kSourceLineFieldNumber = 6;
+  inline ::google::protobuf::int32 source_line() const;
+  inline void set_source_line(::google::protobuf::int32 value);
+  
+  // optional int64 source_line_base = 7;
+  inline bool has_source_line_base() const;
+  inline void clear_source_line_base();
+  static const int kSourceLineBaseFieldNumber = 7;
+  inline ::google::protobuf::int64 source_line_base() const;
+  inline void set_source_line_base(::google::protobuf::int64 value);
+  
+  // @@protoc_insertion_point(class_scope:StackFrame)
+ private:
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  mutable int _cached_size_;
+  
+  ::google::protobuf::int64 instruction_;
+  ::CodeModule* module_;
+  ::std::string* function_name_;
+  static const ::std::string _default_function_name_;
+  ::google::protobuf::int64 function_base_;
+  ::std::string* source_file_name_;
+  static const ::std::string _default_source_file_name_;
+  ::google::protobuf::int32 source_line_;
+  ::google::protobuf::int64 source_line_base_;
+  friend void  protobuf_AddDesc_process_5fstate_2eproto();
+  friend void protobuf_AssignDesc_process_5fstate_2eproto();
+  friend void protobuf_ShutdownFile_process_5fstate_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+  
+  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
+  inline bool _has_bit(int index) const {
+    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
+  }
+  inline void _set_bit(int index) {
+    _has_bits_[index / 32] |= (1u << (index % 32));
+  }
+  inline void _clear_bit(int index) {
+    _has_bits_[index / 32] &= ~(1u << (index % 32));
+  }
+  
+  void InitAsDefaultInstance();
+  static StackFrame* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CodeModule : public ::google::protobuf::Message {
+ public:
+  CodeModule();
+  virtual ~CodeModule();
+  
+  CodeModule(const CodeModule& from);
+  
+  inline CodeModule& operator=(const CodeModule& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CodeModule& default_instance();
+  
+  void Swap(CodeModule* other);
+  
+  // implements Message ----------------------------------------------
+  
+  CodeModule* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CodeModule& from);
+  void MergeFrom(const CodeModule& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // optional int64 base_address = 1;
+  inline bool has_base_address() const;
+  inline void clear_base_address();
+  static const int kBaseAddressFieldNumber = 1;
+  inline ::google::protobuf::int64 base_address() const;
+  inline void set_base_address(::google::protobuf::int64 value);
+  
+  // optional int64 size = 2;
+  inline bool has_size() const;
+  inline void clear_size();
+  static const int kSizeFieldNumber = 2;
+  inline ::google::protobuf::int64 size() const;
+  inline void set_size(::google::protobuf::int64 value);
+  
+  // optional string code_file = 3;
+  inline bool has_code_file() const;
+  inline void clear_code_file();
+  static const int kCodeFileFieldNumber = 3;
+  inline const ::std::string& code_file() const;
+  inline void set_code_file(const ::std::string& value);
+  inline void set_code_file(const char* value);
+  inline void set_code_file(const char* value, size_t size);
+  inline ::std::string* mutable_code_file();
+  
+  // optional string code_identifier = 4;
+  inline bool has_code_identifier() const;
+  inline void clear_code_identifier();
+  static const int kCodeIdentifierFieldNumber = 4;
+  inline const ::std::string& code_identifier() const;
+  inline void set_code_identifier(const ::std::string& value);
+  inline void set_code_identifier(const char* value);
+  inline void set_code_identifier(const char* value, size_t size);
+  inline ::std::string* mutable_code_identifier();
+  
+  // optional string debug_file = 5;
+  inline bool has_debug_file() const;
+  inline void clear_debug_file();
+  static const int kDebugFileFieldNumber = 5;
+  inline const ::std::string& debug_file() const;
+  inline void set_debug_file(const ::std::string& value);
+  inline void set_debug_file(const char* value);
+  inline void set_debug_file(const char* value, size_t size);
+  inline ::std::string* mutable_debug_file();
+  
+  // optional string debug_identifier = 6;
+  inline bool has_debug_identifier() const;
+  inline void clear_debug_identifier();
+  static const int kDebugIdentifierFieldNumber = 6;
+  inline const ::std::string& debug_identifier() const;
+  inline void set_debug_identifier(const ::std::string& value);
+  inline void set_debug_identifier(const char* value);
+  inline void set_debug_identifier(const char* value, size_t size);
+  inline ::std::string* mutable_debug_identifier();
+  
+  // optional string version = 7;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 7;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  
+  // @@protoc_insertion_point(class_scope:CodeModule)
+ private:
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  mutable int _cached_size_;
+  
+  ::google::protobuf::int64 base_address_;
+  ::google::protobuf::int64 size_;
+  ::std::string* code_file_;
+  static const ::std::string _default_code_file_;
+  ::std::string* code_identifier_;
+  static const ::std::string _default_code_identifier_;
+  ::std::string* debug_file_;
+  static const ::std::string _default_debug_file_;
+  ::std::string* debug_identifier_;
+  static const ::std::string _default_debug_identifier_;
+  ::std::string* version_;
+  static const ::std::string _default_version_;
+  friend void  protobuf_AddDesc_process_5fstate_2eproto();
+  friend void protobuf_AssignDesc_process_5fstate_2eproto();
+  friend void protobuf_ShutdownFile_process_5fstate_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+  
+  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
+  inline bool _has_bit(int index) const {
+    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
+  }
+  inline void _set_bit(int index) {
+    _has_bits_[index / 32] |= (1u << (index % 32));
+  }
+  inline void _clear_bit(int index) {
+    _has_bits_[index / 32] &= ~(1u << (index % 32));
+  }
+  
+  void InitAsDefaultInstance();
+  static CodeModule* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// ProcessStateProto_Crash
+
+// required string reason = 1;
+inline bool ProcessStateProto_Crash::has_reason() const {
+  return _has_bit(0);
+}
+inline void ProcessStateProto_Crash::clear_reason() {
+  if (reason_ != &_default_reason_) {
+    reason_->clear();
+  }
+  _clear_bit(0);
+}
+inline const ::std::string& ProcessStateProto_Crash::reason() const {
+  return *reason_;
+}
+inline void ProcessStateProto_Crash::set_reason(const ::std::string& value) {
+  _set_bit(0);
+  if (reason_ == &_default_reason_) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+}
+inline void ProcessStateProto_Crash::set_reason(const char* value) {
+  _set_bit(0);
+  if (reason_ == &_default_reason_) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+}
+inline void ProcessStateProto_Crash::set_reason(const char* value, size_t size) {
+  _set_bit(0);
+  if (reason_ == &_default_reason_) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto_Crash::mutable_reason() {
+  _set_bit(0);
+  if (reason_ == &_default_reason_) {
+    reason_ = new ::std::string;
+  }
+  return reason_;
+}
+
+// required int64 address = 2;
+inline bool ProcessStateProto_Crash::has_address() const {
+  return _has_bit(1);
+}
+inline void ProcessStateProto_Crash::clear_address() {
+  address_ = GOOGLE_LONGLONG(0);
+  _clear_bit(1);
+}
+inline ::google::protobuf::int64 ProcessStateProto_Crash::address() const {
+  return address_;
+}
+inline void ProcessStateProto_Crash::set_address(::google::protobuf::int64 value) {
+  _set_bit(1);
+  address_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ProcessStateProto_Thread
+
+// repeated .StackFrame frames = 1;
+inline int ProcessStateProto_Thread::frames_size() const {
+  return frames_.size();
+}
+inline void ProcessStateProto_Thread::clear_frames() {
+  frames_.Clear();
+}
+inline const ::StackFrame& ProcessStateProto_Thread::frames(int index) const {
+  return frames_.Get(index);
+}
+inline ::StackFrame* ProcessStateProto_Thread::mutable_frames(int index) {
+  return frames_.Mutable(index);
+}
+inline ::StackFrame* ProcessStateProto_Thread::add_frames() {
+  return frames_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::StackFrame >&
+ProcessStateProto_Thread::frames() const {
+  return frames_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::StackFrame >*
+ProcessStateProto_Thread::mutable_frames() {
+  return &frames_;
+}
+
+// -------------------------------------------------------------------
+
+// ProcessStateProto
+
+// optional int64 time_date_stamp = 1;
+inline bool ProcessStateProto::has_time_date_stamp() const {
+  return _has_bit(0);
+}
+inline void ProcessStateProto::clear_time_date_stamp() {
+  time_date_stamp_ = GOOGLE_LONGLONG(0);
+  _clear_bit(0);
+}
+inline ::google::protobuf::int64 ProcessStateProto::time_date_stamp() const {
+  return time_date_stamp_;
+}
+inline void ProcessStateProto::set_time_date_stamp(::google::protobuf::int64 value) {
+  _set_bit(0);
+  time_date_stamp_ = value;
+}
+
+// optional .ProcessStateProto.Crash crash = 2;
+inline bool ProcessStateProto::has_crash() const {
+  return _has_bit(1);
+}
+inline void ProcessStateProto::clear_crash() {
+  if (crash_ != NULL) crash_->::ProcessStateProto_Crash::Clear();
+  _clear_bit(1);
+}
+inline const ::ProcessStateProto_Crash& ProcessStateProto::crash() const {
+  return crash_ != NULL ? *crash_ : *default_instance_->crash_;
+}
+inline ::ProcessStateProto_Crash* ProcessStateProto::mutable_crash() {
+  _set_bit(1);
+  if (crash_ == NULL) crash_ = new ::ProcessStateProto_Crash;
+  return crash_;
+}
+
+// optional string assertion = 3;
+inline bool ProcessStateProto::has_assertion() const {
+  return _has_bit(2);
+}
+inline void ProcessStateProto::clear_assertion() {
+  if (assertion_ != &_default_assertion_) {
+    assertion_->clear();
+  }
+  _clear_bit(2);
+}
+inline const ::std::string& ProcessStateProto::assertion() const {
+  return *assertion_;
+}
+inline void ProcessStateProto::set_assertion(const ::std::string& value) {
+  _set_bit(2);
+  if (assertion_ == &_default_assertion_) {
+    assertion_ = new ::std::string;
+  }
+  assertion_->assign(value);
+}
+inline void ProcessStateProto::set_assertion(const char* value) {
+  _set_bit(2);
+  if (assertion_ == &_default_assertion_) {
+    assertion_ = new ::std::string;
+  }
+  assertion_->assign(value);
+}
+inline void ProcessStateProto::set_assertion(const char* value, size_t size) {
+  _set_bit(2);
+  if (assertion_ == &_default_assertion_) {
+    assertion_ = new ::std::string;
+  }
+  assertion_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_assertion() {
+  _set_bit(2);
+  if (assertion_ == &_default_assertion_) {
+    assertion_ = new ::std::string;
+  }
+  return assertion_;
+}
+
+// optional int32 requesting_thread = 4;
+inline bool ProcessStateProto::has_requesting_thread() const {
+  return _has_bit(3);
+}
+inline void ProcessStateProto::clear_requesting_thread() {
+  requesting_thread_ = 0;
+  _clear_bit(3);
+}
+inline ::google::protobuf::int32 ProcessStateProto::requesting_thread() const {
+  return requesting_thread_;
+}
+inline void ProcessStateProto::set_requesting_thread(::google::protobuf::int32 value) {
+  _set_bit(3);
+  requesting_thread_ = value;
+}
+
+// repeated .ProcessStateProto.Thread threads = 5;
+inline int ProcessStateProto::threads_size() const {
+  return threads_.size();
+}
+inline void ProcessStateProto::clear_threads() {
+  threads_.Clear();
+}
+inline const ::ProcessStateProto_Thread& ProcessStateProto::threads(int index) const {
+  return threads_.Get(index);
+}
+inline ::ProcessStateProto_Thread* ProcessStateProto::mutable_threads(int index) {
+  return threads_.Mutable(index);
+}
+inline ::ProcessStateProto_Thread* ProcessStateProto::add_threads() {
+  return threads_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >&
+ProcessStateProto::threads() const {
+  return threads_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >*
+ProcessStateProto::mutable_threads() {
+  return &threads_;
+}
+
+// repeated .CodeModule modules = 6;
+inline int ProcessStateProto::modules_size() const {
+  return modules_.size();
+}
+inline void ProcessStateProto::clear_modules() {
+  modules_.Clear();
+}
+inline const ::CodeModule& ProcessStateProto::modules(int index) const {
+  return modules_.Get(index);
+}
+inline ::CodeModule* ProcessStateProto::mutable_modules(int index) {
+  return modules_.Mutable(index);
+}
+inline ::CodeModule* ProcessStateProto::add_modules() {
+  return modules_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::CodeModule >&
+ProcessStateProto::modules() const {
+  return modules_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::CodeModule >*
+ProcessStateProto::mutable_modules() {
+  return &modules_;
+}
+
+// optional string os = 7;
+inline bool ProcessStateProto::has_os() const {
+  return _has_bit(6);
+}
+inline void ProcessStateProto::clear_os() {
+  if (os_ != &_default_os_) {
+    os_->clear();
+  }
+  _clear_bit(6);
+}
+inline const ::std::string& ProcessStateProto::os() const {
+  return *os_;
+}
+inline void ProcessStateProto::set_os(const ::std::string& value) {
+  _set_bit(6);
+  if (os_ == &_default_os_) {
+    os_ = new ::std::string;
+  }
+  os_->assign(value);
+}
+inline void ProcessStateProto::set_os(const char* value) {
+  _set_bit(6);
+  if (os_ == &_default_os_) {
+    os_ = new ::std::string;
+  }
+  os_->assign(value);
+}
+inline void ProcessStateProto::set_os(const char* value, size_t size) {
+  _set_bit(6);
+  if (os_ == &_default_os_) {
+    os_ = new ::std::string;
+  }
+  os_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_os() {
+  _set_bit(6);
+  if (os_ == &_default_os_) {
+    os_ = new ::std::string;
+  }
+  return os_;
+}
+
+// optional string os_short = 8;
+inline bool ProcessStateProto::has_os_short() const {
+  return _has_bit(7);
+}
+inline void ProcessStateProto::clear_os_short() {
+  if (os_short_ != &_default_os_short_) {
+    os_short_->clear();
+  }
+  _clear_bit(7);
+}
+inline const ::std::string& ProcessStateProto::os_short() const {
+  return *os_short_;
+}
+inline void ProcessStateProto::set_os_short(const ::std::string& value) {
+  _set_bit(7);
+  if (os_short_ == &_default_os_short_) {
+    os_short_ = new ::std::string;
+  }
+  os_short_->assign(value);
+}
+inline void ProcessStateProto::set_os_short(const char* value) {
+  _set_bit(7);
+  if (os_short_ == &_default_os_short_) {
+    os_short_ = new ::std::string;
+  }
+  os_short_->assign(value);
+}
+inline void ProcessStateProto::set_os_short(const char* value, size_t size) {
+  _set_bit(7);
+  if (os_short_ == &_default_os_short_) {
+    os_short_ = new ::std::string;
+  }
+  os_short_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_os_short() {
+  _set_bit(7);
+  if (os_short_ == &_default_os_short_) {
+    os_short_ = new ::std::string;
+  }
+  return os_short_;
+}
+
+// optional string os_version = 9;
+inline bool ProcessStateProto::has_os_version() const {
+  return _has_bit(8);
+}
+inline void ProcessStateProto::clear_os_version() {
+  if (os_version_ != &_default_os_version_) {
+    os_version_->clear();
+  }
+  _clear_bit(8);
+}
+inline const ::std::string& ProcessStateProto::os_version() const {
+  return *os_version_;
+}
+inline void ProcessStateProto::set_os_version(const ::std::string& value) {
+  _set_bit(8);
+  if (os_version_ == &_default_os_version_) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(value);
+}
+inline void ProcessStateProto::set_os_version(const char* value) {
+  _set_bit(8);
+  if (os_version_ == &_default_os_version_) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(value);
+}
+inline void ProcessStateProto::set_os_version(const char* value, size_t size) {
+  _set_bit(8);
+  if (os_version_ == &_default_os_version_) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_os_version() {
+  _set_bit(8);
+  if (os_version_ == &_default_os_version_) {
+    os_version_ = new ::std::string;
+  }
+  return os_version_;
+}
+
+// optional string cpu = 10;
+inline bool ProcessStateProto::has_cpu() const {
+  return _has_bit(9);
+}
+inline void ProcessStateProto::clear_cpu() {
+  if (cpu_ != &_default_cpu_) {
+    cpu_->clear();
+  }
+  _clear_bit(9);
+}
+inline const ::std::string& ProcessStateProto::cpu() const {
+  return *cpu_;
+}
+inline void ProcessStateProto::set_cpu(const ::std::string& value) {
+  _set_bit(9);
+  if (cpu_ == &_default_cpu_) {
+    cpu_ = new ::std::string;
+  }
+  cpu_->assign(value);
+}
+inline void ProcessStateProto::set_cpu(const char* value) {
+  _set_bit(9);
+  if (cpu_ == &_default_cpu_) {
+    cpu_ = new ::std::string;
+  }
+  cpu_->assign(value);
+}
+inline void ProcessStateProto::set_cpu(const char* value, size_t size) {
+  _set_bit(9);
+  if (cpu_ == &_default_cpu_) {
+    cpu_ = new ::std::string;
+  }
+  cpu_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_cpu() {
+  _set_bit(9);
+  if (cpu_ == &_default_cpu_) {
+    cpu_ = new ::std::string;
+  }
+  return cpu_;
+}
+
+// optional string cpu_info = 11;
+inline bool ProcessStateProto::has_cpu_info() const {
+  return _has_bit(10);
+}
+inline void ProcessStateProto::clear_cpu_info() {
+  if (cpu_info_ != &_default_cpu_info_) {
+    cpu_info_->clear();
+  }
+  _clear_bit(10);
+}
+inline const ::std::string& ProcessStateProto::cpu_info() const {
+  return *cpu_info_;
+}
+inline void ProcessStateProto::set_cpu_info(const ::std::string& value) {
+  _set_bit(10);
+  if (cpu_info_ == &_default_cpu_info_) {
+    cpu_info_ = new ::std::string;
+  }
+  cpu_info_->assign(value);
+}
+inline void ProcessStateProto::set_cpu_info(const char* value) {
+  _set_bit(10);
+  if (cpu_info_ == &_default_cpu_info_) {
+    cpu_info_ = new ::std::string;
+  }
+  cpu_info_->assign(value);
+}
+inline void ProcessStateProto::set_cpu_info(const char* value, size_t size) {
+  _set_bit(10);
+  if (cpu_info_ == &_default_cpu_info_) {
+    cpu_info_ = new ::std::string;
+  }
+  cpu_info_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ProcessStateProto::mutable_cpu_info() {
+  _set_bit(10);
+  if (cpu_info_ == &_default_cpu_info_) {
+    cpu_info_ = new ::std::string;
+  }
+  return cpu_info_;
+}
+
+// optional int32 cpu_count = 12;
+inline bool ProcessStateProto::has_cpu_count() const {
+  return _has_bit(11);
+}
+inline void ProcessStateProto::clear_cpu_count() {
+  cpu_count_ = 0;
+  _clear_bit(11);
+}
+inline ::google::protobuf::int32 ProcessStateProto::cpu_count() const {
+  return cpu_count_;
+}
+inline void ProcessStateProto::set_cpu_count(::google::protobuf::int32 value) {
+  _set_bit(11);
+  cpu_count_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// StackFrame
+
+// required int64 instruction = 1;
+inline bool StackFrame::has_instruction() const {
+  return _has_bit(0);
+}
+inline void StackFrame::clear_instruction() {
+  instruction_ = GOOGLE_LONGLONG(0);
+  _clear_bit(0);
+}
+inline ::google::protobuf::int64 StackFrame::instruction() const {
+  return instruction_;
+}
+inline void StackFrame::set_instruction(::google::protobuf::int64 value) {
+  _set_bit(0);
+  instruction_ = value;
+}
+
+// optional .CodeModule module = 2;
+inline bool StackFrame::has_module() const {
+  return _has_bit(1);
+}
+inline void StackFrame::clear_module() {
+  if (module_ != NULL) module_->::CodeModule::Clear();
+  _clear_bit(1);
+}
+inline const ::CodeModule& StackFrame::module() const {
+  return module_ != NULL ? *module_ : *default_instance_->module_;
+}
+inline ::CodeModule* StackFrame::mutable_module() {
+  _set_bit(1);
+  if (module_ == NULL) module_ = new ::CodeModule;
+  return module_;
+}
+
+// optional string function_name = 3;
+inline bool StackFrame::has_function_name() const {
+  return _has_bit(2);
+}
+inline void StackFrame::clear_function_name() {
+  if (function_name_ != &_default_function_name_) {
+    function_name_->clear();
+  }
+  _clear_bit(2);
+}
+inline const ::std::string& StackFrame::function_name() const {
+  return *function_name_;
+}
+inline void StackFrame::set_function_name(const ::std::string& value) {
+  _set_bit(2);
+  if (function_name_ == &_default_function_name_) {
+    function_name_ = new ::std::string;
+  }
+  function_name_->assign(value);
+}
+inline void StackFrame::set_function_name(const char* value) {
+  _set_bit(2);
+  if (function_name_ == &_default_function_name_) {
+    function_name_ = new ::std::string;
+  }
+  function_name_->assign(value);
+}
+inline void StackFrame::set_function_name(const char* value, size_t size) {
+  _set_bit(2);
+  if (function_name_ == &_default_function_name_) {
+    function_name_ = new ::std::string;
+  }
+  function_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* StackFrame::mutable_function_name() {
+  _set_bit(2);
+  if (function_name_ == &_default_function_name_) {
+    function_name_ = new ::std::string;
+  }
+  return function_name_;
+}
+
+// optional int64 function_base = 4;
+inline bool StackFrame::has_function_base() const {
+  return _has_bit(3);
+}
+inline void StackFrame::clear_function_base() {
+  function_base_ = GOOGLE_LONGLONG(0);
+  _clear_bit(3);
+}
+inline ::google::protobuf::int64 StackFrame::function_base() const {
+  return function_base_;
+}
+inline void StackFrame::set_function_base(::google::protobuf::int64 value) {
+  _set_bit(3);
+  function_base_ = value;
+}
+
+// optional string source_file_name = 5;
+inline bool StackFrame::has_source_file_name() const {
+  return _has_bit(4);
+}
+inline void StackFrame::clear_source_file_name() {
+  if (source_file_name_ != &_default_source_file_name_) {
+    source_file_name_->clear();
+  }
+  _clear_bit(4);
+}
+inline const ::std::string& StackFrame::source_file_name() const {
+  return *source_file_name_;
+}
+inline void StackFrame::set_source_file_name(const ::std::string& value) {
+  _set_bit(4);
+  if (source_file_name_ == &_default_source_file_name_) {
+    source_file_name_ = new ::std::string;
+  }
+  source_file_name_->assign(value);
+}
+inline void StackFrame::set_source_file_name(const char* value) {
+  _set_bit(4);
+  if (source_file_name_ == &_default_source_file_name_) {
+    source_file_name_ = new ::std::string;
+  }
+  source_file_name_->assign(value);
+}
+inline void StackFrame::set_source_file_name(const char* value, size_t size) {
+  _set_bit(4);
+  if (source_file_name_ == &_default_source_file_name_) {
+    source_file_name_ = new ::std::string;
+  }
+  source_file_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* StackFrame::mutable_source_file_name() {
+  _set_bit(4);
+  if (source_file_name_ == &_default_source_file_name_) {
+    source_file_name_ = new ::std::string;
+  }
+  return source_file_name_;
+}
+
+// optional int32 source_line = 6;
+inline bool StackFrame::has_source_line() const {
+  return _has_bit(5);
+}
+inline void StackFrame::clear_source_line() {
+  source_line_ = 0;
+  _clear_bit(5);
+}
+inline ::google::protobuf::int32 StackFrame::source_line() const {
+  return source_line_;
+}
+inline void StackFrame::set_source_line(::google::protobuf::int32 value) {
+  _set_bit(5);
+  source_line_ = value;
+}
+
+// optional int64 source_line_base = 7;
+inline bool StackFrame::has_source_line_base() const {
+  return _has_bit(6);
+}
+inline void StackFrame::clear_source_line_base() {
+  source_line_base_ = GOOGLE_LONGLONG(0);
+  _clear_bit(6);
+}
+inline ::google::protobuf::int64 StackFrame::source_line_base() const {
+  return source_line_base_;
+}
+inline void StackFrame::set_source_line_base(::google::protobuf::int64 value) {
+  _set_bit(6);
+  source_line_base_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CodeModule
+
+// optional int64 base_address = 1;
+inline bool CodeModule::has_base_address() const {
+  return _has_bit(0);
+}
+inline void CodeModule::clear_base_address() {
+  base_address_ = GOOGLE_LONGLONG(0);
+  _clear_bit(0);
+}
+inline ::google::protobuf::int64 CodeModule::base_address() const {
+  return base_address_;
+}
+inline void CodeModule::set_base_address(::google::protobuf::int64 value) {
+  _set_bit(0);
+  base_address_ = value;
+}
+
+// optional int64 size = 2;
+inline bool CodeModule::has_size() const {
+  return _has_bit(1);
+}
+inline void CodeModule::clear_size() {
+  size_ = GOOGLE_LONGLONG(0);
+  _clear_bit(1);
+}
+inline ::google::protobuf::int64 CodeModule::size() const {
+  return size_;
+}
+inline void CodeModule::set_size(::google::protobuf::int64 value) {
+  _set_bit(1);
+  size_ = value;
+}
+
+// optional string code_file = 3;
+inline bool CodeModule::has_code_file() const {
+  return _has_bit(2);
+}
+inline void CodeModule::clear_code_file() {
+  if (code_file_ != &_default_code_file_) {
+    code_file_->clear();
+  }
+  _clear_bit(2);
+}
+inline const ::std::string& CodeModule::code_file() const {
+  return *code_file_;
+}
+inline void CodeModule::set_code_file(const ::std::string& value) {
+  _set_bit(2);
+  if (code_file_ == &_default_code_file_) {
+    code_file_ = new ::std::string;
+  }
+  code_file_->assign(value);
+}
+inline void CodeModule::set_code_file(const char* value) {
+  _set_bit(2);
+  if (code_file_ == &_default_code_file_) {
+    code_file_ = new ::std::string;
+  }
+  code_file_->assign(value);
+}
+inline void CodeModule::set_code_file(const char* value, size_t size) {
+  _set_bit(2);
+  if (code_file_ == &_default_code_file_) {
+    code_file_ = new ::std::string;
+  }
+  code_file_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CodeModule::mutable_code_file() {
+  _set_bit(2);
+  if (code_file_ == &_default_code_file_) {
+    code_file_ = new ::std::string;
+  }
+  return code_file_;
+}
+
+// optional string code_identifier = 4;
+inline bool CodeModule::has_code_identifier() const {
+  return _has_bit(3);
+}
+inline void CodeModule::clear_code_identifier() {
+  if (code_identifier_ != &_default_code_identifier_) {
+    code_identifier_->clear();
+  }
+  _clear_bit(3);
+}
+inline const ::std::string& CodeModule::code_identifier() const {
+  return *code_identifier_;
+}
+inline void CodeModule::set_code_identifier(const ::std::string& value) {
+  _set_bit(3);
+  if (code_identifier_ == &_default_code_identifier_) {
+    code_identifier_ = new ::std::string;
+  }
+  code_identifier_->assign(value);
+}
+inline void CodeModule::set_code_identifier(const char* value) {
+  _set_bit(3);
+  if (code_identifier_ == &_default_code_identifier_) {
+    code_identifier_ = new ::std::string;
+  }
+  code_identifier_->assign(value);
+}
+inline void CodeModule::set_code_identifier(const char* value, size_t size) {
+  _set_bit(3);
+  if (code_identifier_ == &_default_code_identifier_) {
+    code_identifier_ = new ::std::string;
+  }
+  code_identifier_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CodeModule::mutable_code_identifier() {
+  _set_bit(3);
+  if (code_identifier_ == &_default_code_identifier_) {
+    code_identifier_ = new ::std::string;
+  }
+  return code_identifier_;
+}
+
+// optional string debug_file = 5;
+inline bool CodeModule::has_debug_file() const {
+  return _has_bit(4);
+}
+inline void CodeModule::clear_debug_file() {
+  if (debug_file_ != &_default_debug_file_) {
+    debug_file_->clear();
+  }
+  _clear_bit(4);
+}
+inline const ::std::string& CodeModule::debug_file() const {
+  return *debug_file_;
+}
+inline void CodeModule::set_debug_file(const ::std::string& value) {
+  _set_bit(4);
+  if (debug_file_ == &_default_debug_file_) {
+    debug_file_ = new ::std::string;
+  }
+  debug_file_->assign(value);
+}
+inline void CodeModule::set_debug_file(const char* value) {
+  _set_bit(4);
+  if (debug_file_ == &_default_debug_file_) {
+    debug_file_ = new ::std::string;
+  }
+  debug_file_->assign(value);
+}
+inline void CodeModule::set_debug_file(const char* value, size_t size) {
+  _set_bit(4);
+  if (debug_file_ == &_default_debug_file_) {
+    debug_file_ = new ::std::string;
+  }
+  debug_file_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CodeModule::mutable_debug_file() {
+  _set_bit(4);
+  if (debug_file_ == &_default_debug_file_) {
+    debug_file_ = new ::std::string;
+  }
+  return debug_file_;
+}
+
+// optional string debug_identifier = 6;
+inline bool CodeModule::has_debug_identifier() const {
+  return _has_bit(5);
+}
+inline void CodeModule::clear_debug_identifier() {
+  if (debug_identifier_ != &_default_debug_identifier_) {
+    debug_identifier_->clear();
+  }
+  _clear_bit(5);
+}
+inline const ::std::string& CodeModule::debug_identifier() const {
+  return *debug_identifier_;
+}
+inline void CodeModule::set_debug_identifier(const ::std::string& value) {
+  _set_bit(5);
+  if (debug_identifier_ == &_default_debug_identifier_) {
+    debug_identifier_ = new ::std::string;
+  }
+  debug_identifier_->assign(value);
+}
+inline void CodeModule::set_debug_identifier(const char* value) {
+  _set_bit(5);
+  if (debug_identifier_ == &_default_debug_identifier_) {
+    debug_identifier_ = new ::std::string;
+  }
+  debug_identifier_->assign(value);
+}
+inline void CodeModule::set_debug_identifier(const char* value, size_t size) {
+  _set_bit(5);
+  if (debug_identifier_ == &_default_debug_identifier_) {
+    debug_identifier_ = new ::std::string;
+  }
+  debug_identifier_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CodeModule::mutable_debug_identifier() {
+  _set_bit(5);
+  if (debug_identifier_ == &_default_debug_identifier_) {
+    debug_identifier_ = new ::std::string;
+  }
+  return debug_identifier_;
+}
+
+// optional string version = 7;
+inline bool CodeModule::has_version() const {
+  return _has_bit(6);
+}
+inline void CodeModule::clear_version() {
+  if (version_ != &_default_version_) {
+    version_->clear();
+  }
+  _clear_bit(6);
+}
+inline const ::std::string& CodeModule::version() const {
+  return *version_;
+}
+inline void CodeModule::set_version(const ::std::string& value) {
+  _set_bit(6);
+  if (version_ == &_default_version_) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+}
+inline void CodeModule::set_version(const char* value) {
+  _set_bit(6);
+  if (version_ == &_default_version_) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+}
+inline void CodeModule::set_version(const char* value, size_t size) {
+  _set_bit(6);
+  if (version_ == &_default_version_) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CodeModule::mutable_version() {
+  _set_bit(6);
+  if (version_ == &_default_version_) {
+    version_ = new ::std::string;
+  }
+  return version_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_process_5fstate_2eproto__INCLUDED
diff --git a/src/processor/proto/process_state.proto b/src/processor/proto/process_state.proto
new file mode 100644
index 00000000..209919c2
--- /dev/null
+++ b/src/processor/proto/process_state.proto
@@ -0,0 +1,204 @@
+// Copyright (c) 2010, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// process_state_proto.proto: A client proto representation of a process,
+// in a fully-digested state.
+//
+// Derived from earlier struct and class based models of a client-side
+// processed minidump found under src/google_breakpad/processor.  The
+// file process_state.h  holds the top level representation of this model,
+// supported by additional classes.  We've added a proto representation
+// to ease serialization and parsing for server-side storage of crash
+// reports processed on the client.
+//
+// Author: Jess Gray
+
+
+// A proto representation of a process, in a fully-digested state.
+// See src/google_breakpad/processor/process_state.h
+message ProcessStateProto {
+  // Next value: 13
+
+  // The time-date stamp of the original minidump (time_t format)
+  optional int64 time_date_stamp = 1;
+
+  message Crash {
+    // The type of crash.  OS- and possibly CPU- specific.  For example,
+    // "EXCEPTION_ACCESS_VIOLATION" (Windows), "EXC_BAD_ACCESS /
+    // KERN_INVALID_ADDRESS" (Mac OS X), "SIGSEGV" (other Unix).
+    required string reason = 1;
+
+    // If crash_reason implicates memory, the memory address that caused the
+    // crash.  For data access errors, this will be the data address that
+    // caused the fault.  For code errors, this will be the address of the
+    // instruction that caused the fault.
+    required int64 address = 2;
+  }
+  optional Crash crash = 2;
+
+
+  // If there was an assertion that was hit, a textual representation
+  // of that assertion, possibly including the file and line at which
+  // it occurred.
+  optional string assertion = 3;
+
+  // The index of the thread that requested a dump be written in the
+  // threads vector.  If a dump was produced as a result of a crash, this
+  // will point to the thread that crashed.  If the dump was produced as
+  // by user code without crashing, and the dump contains extended Breakpad
+  // information, this will point to the thread that requested the dump.
+  optional int32 requesting_thread = 4;
+
+  message Thread {
+    // Stack for the given thread
+    repeated StackFrame frames = 1;
+  }
+
+  // Stacks for each thread (except possibly the exception handler
+  // thread) at the time of the crash.
+  repeated Thread threads = 5;
+
+  // The modules that were loaded into the process represented by the
+  // ProcessState.
+  repeated CodeModule modules = 6;
+
+  // System Info: OS and CPU
+
+  // A string identifying the operating system, such as "Windows NT",
+  // "Mac OS X", or "Linux".  If the information is present in the dump but
+  // its value is unknown, this field will contain a numeric value.  If
+  // the information is not present in the dump, this field will be empty.
+  optional string os = 7;
+
+   // A short form of the os string, using lowercase letters and no spaces,
+  // suitable for use in a filesystem.  Possible values are "windows",
+  // "mac", and "linux".  Empty if the information is not present in the dump
+  // or if the OS given by the dump is unknown.  The values stored in this
+  // field should match those used by MinidumpSystemInfo::GetOS.
+  optional string os_short = 8;
+
+  // A string identifying the version of the operating system, such as
+  // "5.1.2600 Service Pack 2" or "10.4.8 8L2127".  If the dump does not
+  // contain this information, this field will be empty.
+  optional string os_version = 9;
+
+  // A string identifying the basic CPU family, such as "x86" or "ppc".
+  // If this information is present in the dump but its value is unknown,
+  // this field will contain a numeric value.  If the information is not
+  // present in the dump, this field will be empty.  The values stored in
+  // this field should match those used by MinidumpSystemInfo::GetCPU.
+  optional string cpu = 10;
+
+  // A string further identifying the specific CPU, such as
+  // "GenuineIntel level 6 model 13 stepping 8".  If the information is not
+  // present in the dump, or additional identifying information is not
+  // defined for the CPU family, this field will be empty.
+  optional string cpu_info = 11;
+
+  // The number of processors in the system.  Will be greater than one for
+  // multi-core systems.
+  optional int32 cpu_count = 12;
+
+  // Leave the ability to add the raw minidump to this representation
+}
+
+
+// Represents a single frame in a stack  
+// See src/google_breakpad/processor/code_module.h
+message StackFrame {
+  // Next value: 8
+
+  // The program counter location as an absolute virtual address.  For the
+  // innermost called frame in a stack, this will be an exact program counter
+  // or instruction pointer value.  For all other frames, this will be within
+  // the instruction that caused execution to branch to a called function,
+  // but may not necessarily point to the exact beginning of that instruction.
+  required int64 instruction = 1;
+
+  // The module in which the instruction resides.
+  optional CodeModule module = 2;
+
+  // The function name, may be omitted if debug symbols are not available.
+  optional string function_name = 3;
+
+  // The start address of the function, may be omitted if debug symbols
+  // are not available.
+  optional int64 function_base = 4;
+
+  // The source file name, may be omitted if debug symbols are not available.
+  optional string source_file_name = 5;
+
+  // The (1-based) source line number, may be omitted if debug symbols are
+  // not available.
+  optional int32 source_line = 6;
+
+  // The start address of the source line, may be omitted if debug symbols
+  // are not available.
+  optional int64 source_line_base = 7;
+}
+
+
+// Carries information about code modules that are loaded into a process.
+// See src/google_breakpad/processor/code_module.h
+message CodeModule {
+  // Next value: 8
+
+  // The base address of this code module as it was loaded by the process.
+  optional int64 base_address = 1;
+
+  // The size of the code module.
+  optional int64 size = 2;
+
+  // The path or file name that the code module was loaded from.
+  optional string code_file = 3;
+
+  // An identifying string used to discriminate between multiple versions and
+  // builds of the same code module.  This may contain a uuid, timestamp,
+  // version number, or any combination of this or other information, in an
+  // implementation-defined format.
+  optional string code_identifier = 4;
+
+  // The filename containing debugging information associated with the code
+  // module.  If debugging information is stored in a file separate from the
+  // code module itself (as is the case when .pdb or .dSYM files are used),
+  // this will be different from code_file.  If debugging information is
+  // stored in the code module itself (possibly prior to stripping), this
+  // will be the same as code_file.
+  optional string debug_file = 5;
+
+  // An identifying string similar to code_identifier, but identifies a
+  // specific version and build of the associated debug file.  This may be
+  // the same as code_identifier when the debug_file and code_file are
+  // identical or when the same identifier is used to identify distinct
+  // debug and code files.
+  optional string debug_identifier = 6;
+
+  // A human-readable representation of the code module's version.
+  optional string version = 7;
+}