// 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 google_breakpad {

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\022\017google_breakpad\"\302"
    "\003\n\021ProcessStateProto\022\027\n\017time_date_stamp\030"
    "\001 \001(\003\0227\n\005crash\030\002 \001(\0132(.google_breakpad.P"
    "rocessStateProto.Crash\022\021\n\tassertion\030\003 \001("
    "\t\022\031\n\021requesting_thread\030\004 \001(\005\022:\n\007threads\030"
    "\005 \003(\0132).google_breakpad.ProcessStateProt"
    "o.Thread\022,\n\007modules\030\006 \003(\0132\033.google_break"
    "pad.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_count\030\014 \001(\005\032(\n\005Cr"
    "ash\022\016\n\006reason\030\001 \002(\t\022\017\n\007address\030\002 \002(\003\0325\n\006"
    "Thread\022+\n\006frames\030\001 \003(\0132\033.google_breakpad"
    ".StackFrame\"\305\001\n\nStackFrame\022\023\n\013instructio"
    "n\030\001 \002(\003\022+\n\006module\030\002 \001(\0132\033.google_breakpa"
    "d.CodeModule\022\025\n\rfunction_name\030\003 \001(\t\022\025\n\rf"
    "unction_base\030\004 \001(\003\022\030\n\020source_file_name\030\005"
    " \001(\t\022\023\n\013source_line\030\006 \001(\005\022\030\n\020source_line"
    "_base\030\007 \001(\003\"\233\001\n\nCodeModule\022\024\n\014base_addre"
    "ss\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_identifier\030\004 \001(\t\022\022\n\ndebug_file"
    "\030\005 \001(\t\022\030\n\020debug_identifier\030\006 \001(\t\022\017\n\007vers"
    "ion\030\007 \001(\t", 849);
  ::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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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< ::google_breakpad::ProcessStateProto_Crash*>(&::google_breakpad::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_->::google_breakpad::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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.ProcessStateProto.Thread threads = 5;
  for (int i = 0; i < this->threads_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->threads(i), output);
  }
  
  // repeated .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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()->::google_breakpad::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< ::google_breakpad::CodeModule*>(&::google_breakpad::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_->::google_breakpad::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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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 .google_breakpad.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()->::google_breakpad::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)

}  // namespace google_breakpad

// @@protoc_insertion_point(global_scope)