source: git/external/ProMC/ProMCHeader.pb.cc@ 4a67ae4

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

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

#include <algorithm>

#include <google/protobuf/stubs/common.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/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace promc {

namespace {

const ::google::protobuf::Descriptor* ProMCHeader_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProMCHeader_reflection_ = NULL;
const ::google::protobuf::Descriptor* ProMCHeader_ParticleData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProMCHeader_ParticleData_reflection_ = NULL;
const ::google::protobuf::Descriptor* ProMCHeader_MetaInt_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProMCHeader_MetaInt_reflection_ = NULL;
const ::google::protobuf::Descriptor* ProMCHeader_MetaFloat_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProMCHeader_MetaFloat_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_ProMCHeader_2eproto() {
  protobuf_AddDesc_ProMCHeader_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "ProMCHeader.proto");
  GOOGLE_CHECK(file != NULL);
  ProMCHeader_descriptor_ = file->message_type(0);
  static const int ProMCHeader_offsets_[24] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, id1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, id2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, pdf_id1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, pdf_id2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, x1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, x2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, scalepdf_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, pdf1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, pdf2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, ecm_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, s_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, code_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, cross_section_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, cross_section_error_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, momentumunit_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, lengthunit_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, namemomentumunit_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, namelengthunit_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, weight_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, requested_events_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, particledata_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, metaint_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, metafloat_),
  };
  ProMCHeader_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProMCHeader_descriptor_,
      ProMCHeader::default_instance_,
      ProMCHeader_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProMCHeader));
  ProMCHeader_ParticleData_descriptor_ = ProMCHeader_descriptor_->nested_type(0);
  static const int ProMCHeader_ParticleData_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, mass_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, width_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, lifetime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, charge_),
  };
  ProMCHeader_ParticleData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProMCHeader_ParticleData_descriptor_,
      ProMCHeader_ParticleData::default_instance_,
      ProMCHeader_ParticleData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_ParticleData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProMCHeader_ParticleData));
  ProMCHeader_MetaInt_descriptor_ = ProMCHeader_descriptor_->nested_type(1);
  static const int ProMCHeader_MetaInt_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaInt, key_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaInt, value_),
  };
  ProMCHeader_MetaInt_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProMCHeader_MetaInt_descriptor_,
      ProMCHeader_MetaInt::default_instance_,
      ProMCHeader_MetaInt_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaInt, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaInt, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProMCHeader_MetaInt));
  ProMCHeader_MetaFloat_descriptor_ = ProMCHeader_descriptor_->nested_type(2);
  static const int ProMCHeader_MetaFloat_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaFloat, key_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaFloat, value_),
  };
  ProMCHeader_MetaFloat_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProMCHeader_MetaFloat_descriptor_,
      ProMCHeader_MetaFloat::default_instance_,
      ProMCHeader_MetaFloat_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaFloat, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProMCHeader_MetaFloat, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProMCHeader_MetaFloat));
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_ProMCHeader_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProMCHeader_descriptor_, &ProMCHeader::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProMCHeader_ParticleData_descriptor_, &ProMCHeader_ParticleData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProMCHeader_MetaInt_descriptor_, &ProMCHeader_MetaInt::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProMCHeader_MetaFloat_descriptor_, &ProMCHeader_MetaFloat::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_ProMCHeader_2eproto() {
  delete ProMCHeader::default_instance_;
  delete ProMCHeader_reflection_;
  delete ProMCHeader_ParticleData::default_instance_;
  delete ProMCHeader_ParticleData_reflection_;
  delete ProMCHeader_MetaInt::default_instance_;
  delete ProMCHeader_MetaInt_reflection_;
  delete ProMCHeader_MetaFloat::default_instance_;
  delete ProMCHeader_MetaFloat_reflection_;
}

void protobuf_AddDesc_ProMCHeader_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\021ProMCHeader.proto\022\005promc\"\313\005\n\013ProMCHead"
    "er\022\013\n\003id1\030\001 \001(\005\022\013\n\003id2\030\002 \001(\005\022\017\n\007pdf_id1\030"
    "\003 \001(\005\022\017\n\007pdf_id2\030\004 \001(\005\022\n\n\002x1\030\005 \001(\001\022\n\n\002x2"
    "\030\006 \001(\001\022\020\n\010scalepdf\030\007 \001(\001\022\014\n\004pdf1\030\010 \001(\005\022\014"
    "\n\004pdf2\030\t \001(\005\022\013\n\003eCM\030\n \001(\001\022\t\n\001s\030\013 \001(\001\022\014\n\004"
    "name\030\014 \001(\t\022\014\n\004code\030\r \001(\005\022\025\n\rcross_sectio"
    "n\030\016 \001(\001\022\033\n\023cross_section_error\030\017 \001(\001\022\024\n\014"
    "MomentumUnit\030\020 \001(\005\022\022\n\nLengthUnit\030\021 \001(\005\022\030"
    "\n\020NameMomentumUnit\030\022 \001(\t\022\026\n\016NameLengthUn"
    "it\030\023 \001(\t\022\016\n\006weight\030\024 \001(\001\022\030\n\020requested_ev"
    "ents\030\025 \001(\001\0225\n\014particleData\030\036 \003(\0132\037.promc"
    ".ProMCHeader.ParticleData\022+\n\007metaInt\030\037 \003"
    "(\0132\032.promc.ProMCHeader.MetaInt\022/\n\tmetaFl"
    "oat\030  \003(\0132\034.promc.ProMCHeader.MetaFloat\032"
    "g\n\014ParticleData\022\n\n\002id\030\001 \002(\021\022\014\n\004mass\030\002 \002("
    "\001\022\014\n\004name\030\003 \002(\t\022\r\n\005width\030\004 \001(\002\022\020\n\010lifeti"
    "me\030\005 \001(\002\022\016\n\006charge\030\006 \001(\021\032%\n\007MetaInt\022\013\n\003k"
    "ey\030\001 \002(\t\022\r\n\005value\030\002 \002(\022\032\'\n\tMetaFloat\022\013\n\003"
    "key\030\001 \002(\t\022\r\n\005value\030\002 \002(\001B\033\n\010promc.ioB\017Pr"
    "oMCHeaderFile", 773);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "ProMCHeader.proto", &protobuf_RegisterTypes);
  ProMCHeader::default_instance_ = new ProMCHeader();
  ProMCHeader_ParticleData::default_instance_ = new ProMCHeader_ParticleData();
  ProMCHeader_MetaInt::default_instance_ = new ProMCHeader_MetaInt();
  ProMCHeader_MetaFloat::default_instance_ = new ProMCHeader_MetaFloat();
  ProMCHeader::default_instance_->InitAsDefaultInstance();
  ProMCHeader_ParticleData::default_instance_->InitAsDefaultInstance();
  ProMCHeader_MetaInt::default_instance_->InitAsDefaultInstance();
  ProMCHeader_MetaFloat::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ProMCHeader_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_ProMCHeader_2eproto {
  StaticDescriptorInitializer_ProMCHeader_2eproto() {
    protobuf_AddDesc_ProMCHeader_2eproto();
  }
} static_descriptor_initializer_ProMCHeader_2eproto_;

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

#ifndef _MSC_VER
const int ProMCHeader_ParticleData::kIdFieldNumber;
const int ProMCHeader_ParticleData::kMassFieldNumber;
const int ProMCHeader_ParticleData::kNameFieldNumber;
const int ProMCHeader_ParticleData::kWidthFieldNumber;
const int ProMCHeader_ParticleData::kLifetimeFieldNumber;
const int ProMCHeader_ParticleData::kChargeFieldNumber;
#endif  // !_MSC_VER

ProMCHeader_ParticleData::ProMCHeader_ParticleData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ProMCHeader_ParticleData::InitAsDefaultInstance() {
}

ProMCHeader_ParticleData::ProMCHeader_ParticleData(const ProMCHeader_ParticleData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ProMCHeader_ParticleData::SharedCtor() {
  _cached_size_ = 0;
  id_ = 0;
  mass_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  width_ = 0;
  lifetime_ = 0;
  charge_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProMCHeader_ParticleData::~ProMCHeader_ParticleData() {
  SharedDtor();
}

void ProMCHeader_ParticleData::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void ProMCHeader_ParticleData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProMCHeader_ParticleData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProMCHeader_ParticleData_descriptor_;
}

const ProMCHeader_ParticleData& ProMCHeader_ParticleData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ProMCHeader_2eproto();
  return *default_instance_;
}

ProMCHeader_ParticleData* ProMCHeader_ParticleData::default_instance_ = NULL;

ProMCHeader_ParticleData* ProMCHeader_ParticleData::New() const {
  return new ProMCHeader_ParticleData;
}

void ProMCHeader_ParticleData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    id_ = 0;
    mass_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    width_ = 0;
    lifetime_ = 0;
    charge_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ProMCHeader_ParticleData::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 sint32 id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &id_)));
          set_has_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_mass;
        break;
      }

      // required double mass = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_mass:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &mass_)));
          set_has_mass();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

      // required string name = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_width;
        break;
      }

      // optional float width = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_width:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &width_)));
          set_has_width();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_lifetime;
        break;
      }

      // optional float lifetime = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_lifetime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &lifetime_)));
          set_has_lifetime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_charge;
        break;
      }

      // optional sint32 charge = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_charge:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &charge_)));
          set_has_charge();
        } 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 ProMCHeader_ParticleData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required sint32 id = 1;
  if (has_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt32(1, this->id(), output);
  }

  // required double mass = 2;
  if (has_mass()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->mass(), output);
  }

  // required string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->name(), output);
  }

  // optional float width = 4;
  if (has_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->width(), output);
  }

  // optional float lifetime = 5;
  if (has_lifetime()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->lifetime(), output);
  }

  // optional sint32 charge = 6;
  if (has_charge()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt32(6, this->charge(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ProMCHeader_ParticleData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required sint32 id = 1;
  if (has_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(1, this->id(), target);
  }

  // required double mass = 2;
  if (has_mass()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->mass(), target);
  }

  // required string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->name(), target);
  }

  // optional float width = 4;
  if (has_width()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->width(), target);
  }

  // optional float lifetime = 5;
  if (has_lifetime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->lifetime(), target);
  }

  // optional sint32 charge = 6;
  if (has_charge()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(6, this->charge(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ProMCHeader_ParticleData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required sint32 id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->id());
    }

    // required double mass = 2;
    if (has_mass()) {
      total_size += 1 + 8;
    }

    // required string name = 3;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional float width = 4;
    if (has_width()) {
      total_size += 1 + 4;
    }

    // optional float lifetime = 5;
    if (has_lifetime()) {
      total_size += 1 + 4;
    }

    // optional sint32 charge = 6;
    if (has_charge()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->charge());
    }

  }
  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 ProMCHeader_ParticleData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProMCHeader_ParticleData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProMCHeader_ParticleData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProMCHeader_ParticleData::MergeFrom(const ProMCHeader_ParticleData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_id()) {
      set_id(from.id());
    }
    if (from.has_mass()) {
      set_mass(from.mass());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_width()) {
      set_width(from.width());
    }
    if (from.has_lifetime()) {
      set_lifetime(from.lifetime());
    }
    if (from.has_charge()) {
      set_charge(from.charge());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProMCHeader_ParticleData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ProMCHeader_ParticleData::CopyFrom(const ProMCHeader_ParticleData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ProMCHeader_ParticleData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void ProMCHeader_ParticleData::Swap(ProMCHeader_ParticleData* other) {
  if (other != this) {
    std::swap(id_, other->id_);
    std::swap(mass_, other->mass_);
    std::swap(name_, other->name_);
    std::swap(width_, other->width_);
    std::swap(lifetime_, other->lifetime_);
    std::swap(charge_, other->charge_);
    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 ProMCHeader_ParticleData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProMCHeader_ParticleData_descriptor_;
  metadata.reflection = ProMCHeader_ParticleData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ProMCHeader_MetaInt::kKeyFieldNumber;
const int ProMCHeader_MetaInt::kValueFieldNumber;
#endif  // !_MSC_VER

ProMCHeader_MetaInt::ProMCHeader_MetaInt()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ProMCHeader_MetaInt::InitAsDefaultInstance() {
}

ProMCHeader_MetaInt::ProMCHeader_MetaInt(const ProMCHeader_MetaInt& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ProMCHeader_MetaInt::SharedCtor() {
  _cached_size_ = 0;
  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProMCHeader_MetaInt::~ProMCHeader_MetaInt() {
  SharedDtor();
}

void ProMCHeader_MetaInt::SharedDtor() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (this != default_instance_) {
  }
}

void ProMCHeader_MetaInt::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProMCHeader_MetaInt::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProMCHeader_MetaInt_descriptor_;
}

const ProMCHeader_MetaInt& ProMCHeader_MetaInt::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ProMCHeader_2eproto();
  return *default_instance_;
}

ProMCHeader_MetaInt* ProMCHeader_MetaInt::default_instance_ = NULL;

ProMCHeader_MetaInt* ProMCHeader_MetaInt::New() const {
  return new ProMCHeader_MetaInt;
}

void ProMCHeader_MetaInt::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_key()) {
      if (key_ != &::google::protobuf::internal::kEmptyString) {
        key_->clear();
      }
    }
    value_ = GOOGLE_LONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ProMCHeader_MetaInt::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 key = 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_key()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->key().data(), this->key().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_value;
        break;
      }

      // required sint64 value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
                 input, &value_)));
          set_has_value();
        } 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 ProMCHeader_MetaInt::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->key(), output);
  }

  // required sint64 value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt64(2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ProMCHeader_MetaInt::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->key(), target);
  }

  // required sint64 value = 2;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ProMCHeader_MetaInt::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key());
    }

    // required sint64 value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt64Size(
          this->value());
    }

  }
  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 ProMCHeader_MetaInt::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProMCHeader_MetaInt* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProMCHeader_MetaInt*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProMCHeader_MetaInt::MergeFrom(const ProMCHeader_MetaInt& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_key()) {
      set_key(from.key());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProMCHeader_MetaInt::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ProMCHeader_MetaInt::CopyFrom(const ProMCHeader_MetaInt& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ProMCHeader_MetaInt::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ProMCHeader_MetaInt::Swap(ProMCHeader_MetaInt* other) {
  if (other != this) {
    std::swap(key_, other->key_);
    std::swap(value_, other->value_);
    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 ProMCHeader_MetaInt::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProMCHeader_MetaInt_descriptor_;
  metadata.reflection = ProMCHeader_MetaInt_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ProMCHeader_MetaFloat::kKeyFieldNumber;
const int ProMCHeader_MetaFloat::kValueFieldNumber;
#endif  // !_MSC_VER

ProMCHeader_MetaFloat::ProMCHeader_MetaFloat()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ProMCHeader_MetaFloat::InitAsDefaultInstance() {
}

ProMCHeader_MetaFloat::ProMCHeader_MetaFloat(const ProMCHeader_MetaFloat& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ProMCHeader_MetaFloat::SharedCtor() {
  _cached_size_ = 0;
  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProMCHeader_MetaFloat::~ProMCHeader_MetaFloat() {
  SharedDtor();
}

void ProMCHeader_MetaFloat::SharedDtor() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (this != default_instance_) {
  }
}

void ProMCHeader_MetaFloat::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProMCHeader_MetaFloat::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProMCHeader_MetaFloat_descriptor_;
}

const ProMCHeader_MetaFloat& ProMCHeader_MetaFloat::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ProMCHeader_2eproto();
  return *default_instance_;
}

ProMCHeader_MetaFloat* ProMCHeader_MetaFloat::default_instance_ = NULL;

ProMCHeader_MetaFloat* ProMCHeader_MetaFloat::New() const {
  return new ProMCHeader_MetaFloat;
}

void ProMCHeader_MetaFloat::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_key()) {
      if (key_ != &::google::protobuf::internal::kEmptyString) {
        key_->clear();
      }
    }
    value_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ProMCHeader_MetaFloat::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 key = 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_key()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->key().data(), this->key().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_value;
        break;
      }

      // required double value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_)));
          set_has_value();
        } 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 ProMCHeader_MetaFloat::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->key(), output);
  }

  // required double value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ProMCHeader_MetaFloat::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->key(), target);
  }

  // required double value = 2;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ProMCHeader_MetaFloat::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key());
    }

    // required double value = 2;
    if (has_value()) {
      total_size += 1 + 8;
    }

  }
  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 ProMCHeader_MetaFloat::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProMCHeader_MetaFloat* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProMCHeader_MetaFloat*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProMCHeader_MetaFloat::MergeFrom(const ProMCHeader_MetaFloat& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_key()) {
      set_key(from.key());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProMCHeader_MetaFloat::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ProMCHeader_MetaFloat::CopyFrom(const ProMCHeader_MetaFloat& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ProMCHeader_MetaFloat::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ProMCHeader_MetaFloat::Swap(ProMCHeader_MetaFloat* other) {
  if (other != this) {
    std::swap(key_, other->key_);
    std::swap(value_, other->value_);
    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 ProMCHeader_MetaFloat::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProMCHeader_MetaFloat_descriptor_;
  metadata.reflection = ProMCHeader_MetaFloat_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ProMCHeader::kId1FieldNumber;
const int ProMCHeader::kId2FieldNumber;
const int ProMCHeader::kPdfId1FieldNumber;
const int ProMCHeader::kPdfId2FieldNumber;
const int ProMCHeader::kX1FieldNumber;
const int ProMCHeader::kX2FieldNumber;
const int ProMCHeader::kScalepdfFieldNumber;
const int ProMCHeader::kPdf1FieldNumber;
const int ProMCHeader::kPdf2FieldNumber;
const int ProMCHeader::kECMFieldNumber;
const int ProMCHeader::kSFieldNumber;
const int ProMCHeader::kNameFieldNumber;
const int ProMCHeader::kCodeFieldNumber;
const int ProMCHeader::kCrossSectionFieldNumber;
const int ProMCHeader::kCrossSectionErrorFieldNumber;
const int ProMCHeader::kMomentumUnitFieldNumber;
const int ProMCHeader::kLengthUnitFieldNumber;
const int ProMCHeader::kNameMomentumUnitFieldNumber;
const int ProMCHeader::kNameLengthUnitFieldNumber;
const int ProMCHeader::kWeightFieldNumber;
const int ProMCHeader::kRequestedEventsFieldNumber;
const int ProMCHeader::kParticleDataFieldNumber;
const int ProMCHeader::kMetaIntFieldNumber;
const int ProMCHeader::kMetaFloatFieldNumber;
#endif  // !_MSC_VER

ProMCHeader::ProMCHeader()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ProMCHeader::InitAsDefaultInstance() {
}

ProMCHeader::ProMCHeader(const ProMCHeader& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ProMCHeader::SharedCtor() {
  _cached_size_ = 0;
  id1_ = 0;
  id2_ = 0;
  pdf_id1_ = 0;
  pdf_id2_ = 0;
  x1_ = 0;
  x2_ = 0;
  scalepdf_ = 0;
  pdf1_ = 0;
  pdf2_ = 0;
  ecm_ = 0;
  s_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  code_ = 0;
  cross_section_ = 0;
  cross_section_error_ = 0;
  momentumunit_ = 0;
  lengthunit_ = 0;
  namemomentumunit_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  namelengthunit_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  weight_ = 0;
  requested_events_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProMCHeader::~ProMCHeader() {
  SharedDtor();
}

void ProMCHeader::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (namemomentumunit_ != &::google::protobuf::internal::kEmptyString) {
    delete namemomentumunit_;
  }
  if (namelengthunit_ != &::google::protobuf::internal::kEmptyString) {
    delete namelengthunit_;
  }
  if (this != default_instance_) {
  }
}

void ProMCHeader::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProMCHeader::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProMCHeader_descriptor_;
}

const ProMCHeader& ProMCHeader::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ProMCHeader_2eproto();
  return *default_instance_;
}

ProMCHeader* ProMCHeader::default_instance_ = NULL;

ProMCHeader* ProMCHeader::New() const {
  return new ProMCHeader;
}

void ProMCHeader::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    id1_ = 0;
    id2_ = 0;
    pdf_id1_ = 0;
    pdf_id2_ = 0;
    x1_ = 0;
    x2_ = 0;
    scalepdf_ = 0;
    pdf1_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    pdf2_ = 0;
    ecm_ = 0;
    s_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    code_ = 0;
    cross_section_ = 0;
    cross_section_error_ = 0;
    momentumunit_ = 0;
  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    lengthunit_ = 0;
    if (has_namemomentumunit()) {
      if (namemomentumunit_ != &::google::protobuf::internal::kEmptyString) {
        namemomentumunit_->clear();
      }
    }
    if (has_namelengthunit()) {
      if (namelengthunit_ != &::google::protobuf::internal::kEmptyString) {
        namelengthunit_->clear();
      }
    }
    weight_ = 0;
    requested_events_ = 0;
  }
  particledata_.Clear();
  metaint_.Clear();
  metafloat_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ProMCHeader::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 int32 id1 = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &id1_)));
          set_has_id1();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_id2;
        break;
      }

      // optional int32 id2 = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_id2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &id2_)));
          set_has_id2();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_pdf_id1;
        break;
      }

      // optional int32 pdf_id1 = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pdf_id1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pdf_id1_)));
          set_has_pdf_id1();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_pdf_id2;
        break;
      }

      // optional int32 pdf_id2 = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pdf_id2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pdf_id2_)));
          set_has_pdf_id2();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(41)) goto parse_x1;
        break;
      }

      // optional double x1 = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_x1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &x1_)));
          set_has_x1();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(49)) goto parse_x2;
        break;
      }

      // optional double x2 = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_x2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &x2_)));
          set_has_x2();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(57)) goto parse_scalepdf;
        break;
      }

      // optional double scalepdf = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_scalepdf:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &scalepdf_)));
          set_has_scalepdf();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_pdf1;
        break;
      }

      // optional int32 pdf1 = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pdf1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pdf1_)));
          set_has_pdf1();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_pdf2;
        break;
      }

      // optional int32 pdf2 = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pdf2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pdf2_)));
          set_has_pdf2();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(81)) goto parse_eCM;
        break;
      }

      // optional double eCM = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_eCM:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &ecm_)));
          set_has_ecm();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(89)) goto parse_s;
        break;
      }

      // optional double s = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_s:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &s_)));
          set_has_s();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(98)) goto parse_name;
        break;
      }

      // optional string name = 12;
      case 12: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(104)) goto parse_code;
        break;
      }

      // optional int32 code = 13;
      case 13: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_code:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &code_)));
          set_has_code();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(113)) goto parse_cross_section;
        break;
      }

      // optional double cross_section = 14;
      case 14: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_cross_section:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &cross_section_)));
          set_has_cross_section();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(121)) goto parse_cross_section_error;
        break;
      }

      // optional double cross_section_error = 15;
      case 15: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_cross_section_error:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &cross_section_error_)));
          set_has_cross_section_error();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(128)) goto parse_MomentumUnit;
        break;
      }

      // optional int32 MomentumUnit = 16;
      case 16: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_MomentumUnit:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &momentumunit_)));
          set_has_momentumunit();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(136)) goto parse_LengthUnit;
        break;
      }

      // optional int32 LengthUnit = 17;
      case 17: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_LengthUnit:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &lengthunit_)));
          set_has_lengthunit();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(146)) goto parse_NameMomentumUnit;
        break;
      }

      // optional string NameMomentumUnit = 18;
      case 18: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_NameMomentumUnit:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_namemomentumunit()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->namemomentumunit().data(), this->namemomentumunit().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(154)) goto parse_NameLengthUnit;
        break;
      }

      // optional string NameLengthUnit = 19;
      case 19: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_NameLengthUnit:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_namelengthunit()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->namelengthunit().data(), this->namelengthunit().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(161)) goto parse_weight;
        break;
      }

      // optional double weight = 20;
      case 20: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_weight:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &weight_)));
          set_has_weight();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(169)) goto parse_requested_events;
        break;
      }

      // optional double requested_events = 21;
      case 21: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_requested_events:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &requested_events_)));
          set_has_requested_events();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(242)) goto parse_particleData;
        break;
      }

      // repeated .promc.ProMCHeader.ParticleData particleData = 30;
      case 30: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_particleData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_particledata()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(242)) goto parse_particleData;
        if (input->ExpectTag(250)) goto parse_metaInt;
        break;
      }

      // repeated .promc.ProMCHeader.MetaInt metaInt = 31;
      case 31: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_metaInt:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_metaint()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(250)) goto parse_metaInt;
        if (input->ExpectTag(258)) goto parse_metaFloat;
        break;
      }

      // repeated .promc.ProMCHeader.MetaFloat metaFloat = 32;
      case 32: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_metaFloat:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_metafloat()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(258)) goto parse_metaFloat;
        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 ProMCHeader::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 id1 = 1;
  if (has_id1()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id1(), output);
  }

  // optional int32 id2 = 2;
  if (has_id2()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->id2(), output);
  }

  // optional int32 pdf_id1 = 3;
  if (has_pdf_id1()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->pdf_id1(), output);
  }

  // optional int32 pdf_id2 = 4;
  if (has_pdf_id2()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->pdf_id2(), output);
  }

  // optional double x1 = 5;
  if (has_x1()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(5, this->x1(), output);
  }

  // optional double x2 = 6;
  if (has_x2()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(6, this->x2(), output);
  }

  // optional double scalepdf = 7;
  if (has_scalepdf()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(7, this->scalepdf(), output);
  }

  // optional int32 pdf1 = 8;
  if (has_pdf1()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->pdf1(), output);
  }

  // optional int32 pdf2 = 9;
  if (has_pdf2()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->pdf2(), output);
  }

  // optional double eCM = 10;
  if (has_ecm()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(10, this->ecm(), output);
  }

  // optional double s = 11;
  if (has_s()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(11, this->s(), output);
  }

  // optional string name = 12;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      12, this->name(), output);
  }

  // optional int32 code = 13;
  if (has_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->code(), output);
  }

  // optional double cross_section = 14;
  if (has_cross_section()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(14, this->cross_section(), output);
  }

  // optional double cross_section_error = 15;
  if (has_cross_section_error()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(15, this->cross_section_error(), output);
  }

  // optional int32 MomentumUnit = 16;
  if (has_momentumunit()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(16, this->momentumunit(), output);
  }

  // optional int32 LengthUnit = 17;
  if (has_lengthunit()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->lengthunit(), output);
  }

  // optional string NameMomentumUnit = 18;
  if (has_namemomentumunit()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->namemomentumunit().data(), this->namemomentumunit().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      18, this->namemomentumunit(), output);
  }

  // optional string NameLengthUnit = 19;
  if (has_namelengthunit()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->namelengthunit().data(), this->namelengthunit().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      19, this->namelengthunit(), output);
  }

  // optional double weight = 20;
  if (has_weight()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(20, this->weight(), output);
  }

  // optional double requested_events = 21;
  if (has_requested_events()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(21, this->requested_events(), output);
  }

  // repeated .promc.ProMCHeader.ParticleData particleData = 30;
  for (int i = 0; i < this->particledata_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      30, this->particledata(i), output);
  }

  // repeated .promc.ProMCHeader.MetaInt metaInt = 31;
  for (int i = 0; i < this->metaint_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      31, this->metaint(i), output);
  }

  // repeated .promc.ProMCHeader.MetaFloat metaFloat = 32;
  for (int i = 0; i < this->metafloat_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      32, this->metafloat(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ProMCHeader::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 id1 = 1;
  if (has_id1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->id1(), target);
  }

  // optional int32 id2 = 2;
  if (has_id2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->id2(), target);
  }

  // optional int32 pdf_id1 = 3;
  if (has_pdf_id1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->pdf_id1(), target);
  }

  // optional int32 pdf_id2 = 4;
  if (has_pdf_id2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->pdf_id2(), target);
  }

  // optional double x1 = 5;
  if (has_x1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(5, this->x1(), target);
  }

  // optional double x2 = 6;
  if (has_x2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(6, this->x2(), target);
  }

  // optional double scalepdf = 7;
  if (has_scalepdf()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(7, this->scalepdf(), target);
  }

  // optional int32 pdf1 = 8;
  if (has_pdf1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->pdf1(), target);
  }

  // optional int32 pdf2 = 9;
  if (has_pdf2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->pdf2(), target);
  }

  // optional double eCM = 10;
  if (has_ecm()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(10, this->ecm(), target);
  }

  // optional double s = 11;
  if (has_s()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(11, this->s(), target);
  }

  // optional string name = 12;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        12, this->name(), target);
  }

  // optional int32 code = 13;
  if (has_code()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->code(), target);
  }

  // optional double cross_section = 14;
  if (has_cross_section()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(14, this->cross_section(), target);
  }

  // optional double cross_section_error = 15;
  if (has_cross_section_error()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(15, this->cross_section_error(), target);
  }

  // optional int32 MomentumUnit = 16;
  if (has_momentumunit()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(16, this->momentumunit(), target);
  }

  // optional int32 LengthUnit = 17;
  if (has_lengthunit()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(17, this->lengthunit(), target);
  }

  // optional string NameMomentumUnit = 18;
  if (has_namemomentumunit()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->namemomentumunit().data(), this->namemomentumunit().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        18, this->namemomentumunit(), target);
  }

  // optional string NameLengthUnit = 19;
  if (has_namelengthunit()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->namelengthunit().data(), this->namelengthunit().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        19, this->namelengthunit(), target);
  }

  // optional double weight = 20;
  if (has_weight()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(20, this->weight(), target);
  }

  // optional double requested_events = 21;
  if (has_requested_events()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(21, this->requested_events(), target);
  }

  // repeated .promc.ProMCHeader.ParticleData particleData = 30;
  for (int i = 0; i < this->particledata_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        30, this->particledata(i), target);
  }

  // repeated .promc.ProMCHeader.MetaInt metaInt = 31;
  for (int i = 0; i < this->metaint_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        31, this->metaint(i), target);
  }

  // repeated .promc.ProMCHeader.MetaFloat metaFloat = 32;
  for (int i = 0; i < this->metafloat_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        32, this->metafloat(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ProMCHeader::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 id1 = 1;
    if (has_id1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->id1());
    }

    // optional int32 id2 = 2;
    if (has_id2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->id2());
    }

    // optional int32 pdf_id1 = 3;
    if (has_pdf_id1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->pdf_id1());
    }

    // optional int32 pdf_id2 = 4;
    if (has_pdf_id2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->pdf_id2());
    }

    // optional double x1 = 5;
    if (has_x1()) {
      total_size += 1 + 8;
    }

    // optional double x2 = 6;
    if (has_x2()) {
      total_size += 1 + 8;
    }

    // optional double scalepdf = 7;
    if (has_scalepdf()) {
      total_size += 1 + 8;
    }

    // optional int32 pdf1 = 8;
    if (has_pdf1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->pdf1());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 pdf2 = 9;
    if (has_pdf2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->pdf2());
    }

    // optional double eCM = 10;
    if (has_ecm()) {
      total_size += 1 + 8;
    }

    // optional double s = 11;
    if (has_s()) {
      total_size += 1 + 8;
    }

    // optional string name = 12;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional int32 code = 13;
    if (has_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->code());
    }

    // optional double cross_section = 14;
    if (has_cross_section()) {
      total_size += 1 + 8;
    }

    // optional double cross_section_error = 15;
    if (has_cross_section_error()) {
      total_size += 1 + 8;
    }

    // optional int32 MomentumUnit = 16;
    if (has_momentumunit()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->momentumunit());
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional int32 LengthUnit = 17;
    if (has_lengthunit()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->lengthunit());
    }

    // optional string NameMomentumUnit = 18;
    if (has_namemomentumunit()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->namemomentumunit());
    }

    // optional string NameLengthUnit = 19;
    if (has_namelengthunit()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->namelengthunit());
    }

    // optional double weight = 20;
    if (has_weight()) {
      total_size += 2 + 8;
    }

    // optional double requested_events = 21;
    if (has_requested_events()) {
      total_size += 2 + 8;
    }

  }
  // repeated .promc.ProMCHeader.ParticleData particleData = 30;
  total_size += 2 * this->particledata_size();
  for (int i = 0; i < this->particledata_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->particledata(i));
  }

  // repeated .promc.ProMCHeader.MetaInt metaInt = 31;
  total_size += 2 * this->metaint_size();
  for (int i = 0; i < this->metaint_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->metaint(i));
  }

  // repeated .promc.ProMCHeader.MetaFloat metaFloat = 32;
  total_size += 2 * this->metafloat_size();
  for (int i = 0; i < this->metafloat_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->metafloat(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 ProMCHeader::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProMCHeader* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProMCHeader*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProMCHeader::MergeFrom(const ProMCHeader& from) {
  GOOGLE_CHECK_NE(&from, this);
  particledata_.MergeFrom(from.particledata_);
  metaint_.MergeFrom(from.metaint_);
  metafloat_.MergeFrom(from.metafloat_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_id1()) {
      set_id1(from.id1());
    }
    if (from.has_id2()) {
      set_id2(from.id2());
    }
    if (from.has_pdf_id1()) {
      set_pdf_id1(from.pdf_id1());
    }
    if (from.has_pdf_id2()) {
      set_pdf_id2(from.pdf_id2());
    }
    if (from.has_x1()) {
      set_x1(from.x1());
    }
    if (from.has_x2()) {
      set_x2(from.x2());
    }
    if (from.has_scalepdf()) {
      set_scalepdf(from.scalepdf());
    }
    if (from.has_pdf1()) {
      set_pdf1(from.pdf1());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_pdf2()) {
      set_pdf2(from.pdf2());
    }
    if (from.has_ecm()) {
      set_ecm(from.ecm());
    }
    if (from.has_s()) {
      set_s(from.s());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_code()) {
      set_code(from.code());
    }
    if (from.has_cross_section()) {
      set_cross_section(from.cross_section());
    }
    if (from.has_cross_section_error()) {
      set_cross_section_error(from.cross_section_error());
    }
    if (from.has_momentumunit()) {
      set_momentumunit(from.momentumunit());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_lengthunit()) {
      set_lengthunit(from.lengthunit());
    }
    if (from.has_namemomentumunit()) {
      set_namemomentumunit(from.namemomentumunit());
    }
    if (from.has_namelengthunit()) {
      set_namelengthunit(from.namelengthunit());
    }
    if (from.has_weight()) {
      set_weight(from.weight());
    }
    if (from.has_requested_events()) {
      set_requested_events(from.requested_events());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProMCHeader::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ProMCHeader::CopyFrom(const ProMCHeader& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ProMCHeader::IsInitialized() const {

  for (int i = 0; i < particledata_size(); i++) {
    if (!this->particledata(i).IsInitialized()) return false;
  }
  for (int i = 0; i < metaint_size(); i++) {
    if (!this->metaint(i).IsInitialized()) return false;
  }
  for (int i = 0; i < metafloat_size(); i++) {
    if (!this->metafloat(i).IsInitialized()) return false;
  }
  return true;
}

void ProMCHeader::Swap(ProMCHeader* other) {
  if (other != this) {
    std::swap(id1_, other->id1_);
    std::swap(id2_, other->id2_);
    std::swap(pdf_id1_, other->pdf_id1_);
    std::swap(pdf_id2_, other->pdf_id2_);
    std::swap(x1_, other->x1_);
    std::swap(x2_, other->x2_);
    std::swap(scalepdf_, other->scalepdf_);
    std::swap(pdf1_, other->pdf1_);
    std::swap(pdf2_, other->pdf2_);
    std::swap(ecm_, other->ecm_);
    std::swap(s_, other->s_);
    std::swap(name_, other->name_);
    std::swap(code_, other->code_);
    std::swap(cross_section_, other->cross_section_);
    std::swap(cross_section_error_, other->cross_section_error_);
    std::swap(momentumunit_, other->momentumunit_);
    std::swap(lengthunit_, other->lengthunit_);
    std::swap(namemomentumunit_, other->namemomentumunit_);
    std::swap(namelengthunit_, other->namelengthunit_);
    std::swap(weight_, other->weight_);
    std::swap(requested_events_, other->requested_events_);
    particledata_.Swap(&other->particledata_);
    metaint_.Swap(&other->metaint_);
    metafloat_.Swap(&other->metafloat_);
    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 ProMCHeader::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProMCHeader_descriptor_;
  metadata.reflection = ProMCHeader_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace promc

// @@protoc_insertion_point(global_scope)