McEventDict_dict.cpp

Go to the documentation of this file.

// Generated at Thu Nov 27 15:18:56 2003. Do not modify it
 
#ifdef _WIN32
#pragma warning ( disable : 4786 )
#endif
#define private public
#define protected public
#include "../GeneratorObject/McEventDict.h"
#undef private
#undef protected
#include "ReflectionBuilder/ReflectionBuilder.h"
#include <typeinfo>
using namespace seal::reflect;
 
//------Dictionary for class HepMcParticleLink -------------------------------
class HepMcParticleLink_dict { 
  public:
  HepMcParticleLink_dict();
  static void* constructor_2570( void* );
  static void* constructor_2571( void*, const std::vector<void*>& );
  static void* constructor_2572( void*, const std::vector<void*>& );
  static void* constructor_2573( void*, const std::vector<void*>& );
  static void* constructor_2574( void*, const std::vector<void*>& );
};
static HepMcParticleLink_dict instance_8;
 
HepMcParticleLink_dict::HepMcParticleLink_dict() {
  ClassBuilder _c_("HepMcParticleLink", "", typeid(HepMcParticleLink), sizeof(HepMcParticleLink),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
  _c_.addField("m_particle", "HepMC::GenParticle*", "", (int)(&((HepMcParticleLink*)64)->m_particle)-64, PRIVATE | TRANSIENT );
  _c_.addField("m_extBarcode", "HepMcParticleLink::ExtendedBarCode", "", (int)(&((HepMcParticleLink*)64)->m_extBarcode)-64, PRIVATE );
  _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", constructor_2570, PUBLIC);
  _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "unsigned int; unsigned int=", constructor_2571, PUBLIC);
  _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMC::GenParticle*; unsigned int=", constructor_2572, PUBLIC);
  _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMcParticleLink&", constructor_2573, PUBLIC);
  _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMC::GenParticle*; HepMC::GenEvent*", constructor_2574, PUBLIC);
  _c_.build();
}
 
void* HepMcParticleLink_dict::constructor_2570( void* mem) {
  return new(mem) HepMcParticleLink();
}
 
void* HepMcParticleLink_dict::constructor_2571( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) HepMcParticleLink(*(unsigned int*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMcParticleLink(*(unsigned int*)arg[0],
                                    *(unsigned int*)arg[1]);
  }
  return 0;
}
 
void* HepMcParticleLink_dict::constructor_2572( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0],
                                    *(unsigned int*)arg[1]);
  }
  return 0;
}
 
void* HepMcParticleLink_dict::constructor_2573( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMcParticleLink(*(const HepMcParticleLink*)arg[0]);
}
 
void* HepMcParticleLink_dict::constructor_2574( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0],
                                    (const HepMC::GenEvent*)arg[1]);
}
 
//------Dictionary for class McEventCollection -------------------------------
class McEventCollection_dict { 
  public:
  McEventCollection_dict();
  static int tobase_2585(void*);
  static void* constructor_2586( void*, const std::vector<void*>& );
  static void* constructor_2587( void* );
  static void  destructor( void* o ) { ((McEventCollection*)o)->~McEventCollection(); }
};
static McEventCollection_dict instance_16;
 
McEventCollection_dict::McEventCollection_dict() {
  ClassBuilder _c_("McEventCollection", "", typeid(McEventCollection), sizeof(McEventCollection),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addSuperClass("DataVector<HepMC::GenEvent>", 0, tobase_2585);
  _c_.addMethod("McEventCollection", "", "McEventCollection", "McEventCollection&", constructor_2586, PUBLIC);
  _c_.addMethod("McEventCollection", "", "McEventCollection", constructor_2587, PUBLIC);
  _c_.addMethod("~McEventCollection", "", destructor, PUBLIC | VIRTUAL);
  _c_.addProperty("ClassID", (char*)"6DE62B45-7C72-4539-92F2-3A8E739A4AC3");
  _c_.build();
}
 
int McEventCollection_dict::tobase_2585( void* o ) {
  return (int)(DataVector<HepMC::GenEvent>*)(McEventCollection*)o - (int)(McEventCollection*)o;
}
 
void* McEventCollection_dict::constructor_2586( void* mem, const std::vector<void*>& arg) {
  return new(mem) McEventCollection(*(const McEventCollection*)arg[0]);
}
 
void* McEventCollection_dict::constructor_2587( void* mem) {
  return new(mem) McEventCollection();
}
 
//------Dictionary for class HepLorentzVector -------------------------------
class HepLorentzVector_dict { 
  public:
  HepLorentzVector_dict();
  static void* constructor_3161( void*, const std::vector<void*>& );
  static void* constructor_3162( void*, const std::vector<void*>& );
  static void* constructor_3163( void*, const std::vector<void*>& );
  static void* constructor_3164( void* );
  static void* constructor_3165( void*, const std::vector<void*>& );
  static void* constructor_3166( void*, const std::vector<void*>& );
  static void* constructor_3167( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepLorentzVector*)o)->~HepLorentzVector(); }
  static void* constructor_3256( void*, const std::vector<void*>& );
  static void* constructor_3258( void*, const std::vector<void*>& );
  static void* constructor_3261( void*, const std::vector<void*>& );
  static void* constructor_3263( void*, const std::vector<void*>& );
};
static HepLorentzVector_dict instance_241;
 
HepLorentzVector_dict::HepLorentzVector_dict() {
  ClassBuilder _c_("HepLorentzVector", "", typeid(HepLorentzVector), sizeof(HepLorentzVector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
  _c_.addField("pp", "Hep3Vector", "", (int)(&((HepLorentzVector*)64)->pp)-64, PRIVATE );
  _c_.addField("ee", "double", "", (int)(&((HepLorentzVector*)64)->ee)-64, PRIVATE );
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double; double", constructor_3161, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double", constructor_3162, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double", constructor_3163, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", constructor_3164, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Hep3Vector&; double", constructor_3165, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; Hep3Vector&", constructor_3166, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "HepLorentzVector&", constructor_3167, PUBLIC);
  _c_.addMethod("~HepLorentzVector", "", destructor, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double; Tcomponent", constructor_3256, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Tcomponent; double; double; double", constructor_3258, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Tcomponent", constructor_3261, PUBLIC);
  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Hep3Vector&", constructor_3263, PUBLIC);
  _c_.build();
}
 
void* HepLorentzVector_dict::constructor_3161( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(double*)arg[0],
                                   *(double*)arg[1],
                                   *(double*)arg[2],
                                   *(double*)arg[3]);
}
 
void* HepLorentzVector_dict::constructor_3162( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(double*)arg[0],
                                   *(double*)arg[1],
                                   *(double*)arg[2]);
}
 
void* HepLorentzVector_dict::constructor_3163( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(double*)arg[0]);
}
 
void* HepLorentzVector_dict::constructor_3164( void* mem) {
  return new(mem) HepLorentzVector();
}
 
void* HepLorentzVector_dict::constructor_3165( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(const Hep3Vector*)arg[0],
                                   *(double*)arg[1]);
}
 
void* HepLorentzVector_dict::constructor_3166( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(double*)arg[0],
                                   *(const Hep3Vector*)arg[1]);
}
 
void* HepLorentzVector_dict::constructor_3167( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(const HepLorentzVector*)arg[0]);
}
 
void* HepLorentzVector_dict::constructor_3256( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(double*)arg[0],
                                   *(double*)arg[1],
                                   *(double*)arg[2],
                                   *(Tcomponent*)arg[3]);
}
 
void* HepLorentzVector_dict::constructor_3258( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(Tcomponent*)arg[0],
                                   *(double*)arg[1],
                                   *(double*)arg[2],
                                   *(double*)arg[3]);
}
 
void* HepLorentzVector_dict::constructor_3261( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(Tcomponent*)arg[0]);
}
 
void* HepLorentzVector_dict::constructor_3263( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepLorentzVector(*(const Hep3Vector*)arg[0]);
}
 
//------Dictionary for class Hep3Vector -------------------------------
class Hep3Vector_dict { 
  public:
  Hep3Vector_dict();
  static void* constructor_3332( void*, const std::vector<void*>& );
  static void* constructor_3333( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((Hep3Vector*)o)->~Hep3Vector(); }
  static void* constructor_x0( void* );
};
static Hep3Vector_dict instance_271;
 
Hep3Vector_dict::Hep3Vector_dict() {
  ClassBuilder _c_("Hep3Vector", "", typeid(Hep3Vector), sizeof(Hep3Vector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
  _c_.addField("dx", "double", "", (int)(&((Hep3Vector*)64)->dx)-64, PROTECTED );
  _c_.addField("dy", "double", "", (int)(&((Hep3Vector*)64)->dy)-64, PROTECTED );
  _c_.addField("dz", "double", "", (int)(&((Hep3Vector*)64)->dz)-64, PROTECTED );
  _c_.addMethod("Hep3Vector", "", "Hep3Vector", "double=; double=; double=", constructor_3332, PUBLIC);
  _c_.addMethod("Hep3Vector", "", "Hep3Vector", "Hep3Vector&", constructor_3333, PUBLIC);
  _c_.addMethod("~Hep3Vector", "", destructor, PUBLIC);
  _c_.addMethod("Hep3Vector", "", "Hep3Vector", constructor_x0, PUBLIC);
  _c_.build();
}
 
void* Hep3Vector_dict::constructor_3332( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) Hep3Vector();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) Hep3Vector(*(double*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) Hep3Vector(*(double*)arg[0],
                             *(double*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) Hep3Vector(*(double*)arg[0],
                             *(double*)arg[1],
                             *(double*)arg[2]);
  }
  return 0;
}
 
void* Hep3Vector_dict::constructor_3333( void* mem, const std::vector<void*>& arg) {
  return new(mem) Hep3Vector(*(const Hep3Vector*)arg[0]);
}
 
void* Hep3Vector_dict::constructor_x0( void* mem) {
  return new(mem) Hep3Vector();
}
 
//------Dictionary for class basic_string<char,std::char_traits<char>,std::allocator<char> > -------------------------------
class std__basic_string_char__dict { 
  public:
  std__basic_string_char__dict();
  static void* constructor_5273( void* );
  static void* constructor_5274( void*, const std::vector<void*>& );
  static void* constructor_5275( void*, const std::vector<void*>& );
  static void* constructor_5276( void*, const std::vector<void*>& );
  static void* constructor_5277( void*, const std::vector<void*>& );
  static void* constructor_5278( void*, const std::vector<void*>& );
  static void* constructor_5279( void*, const std::vector<void*>& );
  static void* constructor_5280( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((std::basic_string<char>*)o)->~basic_string(); }
};
static std__basic_string_char__dict instance_2526;
 
std__basic_string_char__dict::std__basic_string_char__dict() {
  ClassBuilder _c_("std::basic_string<char>", "", typeid(std::basic_string<char>), sizeof(std::basic_string<char>),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
  _c_.addField("_M_dataplus", "std::basic_string<char>::_Alloc_hider", "", (int)(&((std::basic_string<char>*)64)->_M_dataplus)-64, PRIVATE );
  _c_.addMethod("basic_string", "", "std::basic_string<char>", constructor_5273, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::allocator<char>&", constructor_5274, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&", constructor_5275, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&; unsigned int; unsigned int=", constructor_5276, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&; unsigned int; unsigned int; std::allocator<char>&", constructor_5277, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "char*; unsigned int; std::allocator<char>&=", constructor_5278, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "char*; std::allocator<char>&=", constructor_5279, PUBLIC);
  _c_.addMethod("basic_string", "", "std::basic_string<char>", "unsigned int; char; std::allocator<char>&=", constructor_5280, PUBLIC);
  _c_.addMethod("~basic_string", "", destructor, PUBLIC);
  _c_.build();
}
 
void* std__basic_string_char__dict::constructor_5273( void* mem) {
  return new(mem) std::basic_string<char>();
}
 
void* std__basic_string_char__dict::constructor_5274( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::basic_string<char>(*(const std::allocator<char>*)arg[0]);
}
 
void* std__basic_string_char__dict::constructor_5275( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0]);
}
 
void* std__basic_string_char__dict::constructor_5276( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
                                          *(unsigned int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
                                          *(unsigned int*)arg[1],
                                          *(unsigned int*)arg[2]);
  }
  return 0;
}
 
void* std__basic_string_char__dict::constructor_5277( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
                                          *(unsigned int*)arg[1],
                                          *(unsigned int*)arg[2],
                                          *(const std::allocator<char>*)arg[3]);
}
 
void* std__basic_string_char__dict::constructor_5278( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::basic_string<char>((const char*)arg[0],
                                          *(unsigned int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::basic_string<char>((const char*)arg[0],
                                          *(unsigned int*)arg[1],
                                          *(const std::allocator<char>*)arg[2]);
  }
  return 0;
}
 
void* std__basic_string_char__dict::constructor_5279( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) std::basic_string<char>((const char*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) std::basic_string<char>((const char*)arg[0],
                                          *(const std::allocator<char>*)arg[1]);
  }
  return 0;
}
 
void* std__basic_string_char__dict::constructor_5280( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::basic_string<char>(*(unsigned int*)arg[0],
                                          *(char*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::basic_string<char>(*(unsigned int*)arg[0],
                                          *(char*)arg[1],
                                          *(const std::allocator<char>*)arg[2]);
  }
  return 0;
}
 
//------Dictionary for class ExtendedBarCode -------------------------------
class HepMcParticleLink__ExtendedBarCode_dict { 
  public:
  HepMcParticleLink__ExtendedBarCode_dict();
  static void* constructor_5408( void* );
  static void* constructor_5409( void*, const std::vector<void*>& );
  static void* constructor_5410( void*, const std::vector<void*>& );
};
static HepMcParticleLink__ExtendedBarCode_dict instance_2569;
 
HepMcParticleLink__ExtendedBarCode_dict::HepMcParticleLink__ExtendedBarCode_dict() {
  ClassBuilder _c_("HepMcParticleLink::ExtendedBarCode", "", typeid(HepMcParticleLink::ExtendedBarCode), sizeof(HepMcParticleLink::ExtendedBarCode),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PRIVATE);
  _c_.addField("m_extBC", "unsigned int", "", (int)(&((HepMcParticleLink::ExtendedBarCode*)64)->m_extBC)-64, PRIVATE );
  _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", constructor_5408, PUBLIC);
  _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", "unsigned int; unsigned int", constructor_5409, PUBLIC);
  _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", "HepMcParticleLink::ExtendedBarCode&", constructor_5410, PUBLIC);
  _c_.build();
}
 
void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5408( void* mem) {
  return new(mem) HepMcParticleLink::ExtendedBarCode();
}
 
void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5409( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMcParticleLink::ExtendedBarCode(*(unsigned int*)arg[0],
                                                     *(unsigned int*)arg[1]);
}
 
void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5410( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMcParticleLink::ExtendedBarCode(*(const HepMcParticleLink::ExtendedBarCode*)arg[0]);
}
 
//------Dictionary for class DataVector<HepMC::GenEvent> -------------------------------
class DataVector_HepMC__GenEvent__dict { 
  public:
  DataVector_HepMC__GenEvent__dict();
  static void* constructor_5444( void*, const std::vector<void*>& );
  static void* constructor_5445( void*, const std::vector<void*>& );
  static void* constructor_5446( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((DataVector<HepMC::GenEvent>*)o)->~DataVector(); }
  static void* constructor_x1( void* );
};
static DataVector_HepMC__GenEvent__dict instance_2585;
 
DataVector_HepMC__GenEvent__dict::DataVector_HepMC__GenEvent__dict() {
  ClassBuilder _c_("DataVector<HepMC::GenEvent>", "", typeid(DataVector<HepMC::GenEvent>), sizeof(DataVector<HepMC::GenEvent>),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_ownPolicy", "int", "", (int)(&((DataVector<HepMC::GenEvent>*)64)->m_ownPolicy)-64, PRIVATE );
  _c_.addField("m_pCont", "std::vector<HepMC::GenEvent*>", "", (int)(&((DataVector<HepMC::GenEvent>*)64)->m_pCont)-64, PRIVATE );
  _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "int=", constructor_5444, PUBLIC);
  _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "unsigned int; int=", constructor_5445, PUBLIC);
  _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "DataVector<HepMC::GenEvent>&", constructor_5446, PUBLIC);
  _c_.addMethod("~DataVector", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", constructor_x1, PUBLIC);
  _c_.build();
}
 
void* DataVector_HepMC__GenEvent__dict::constructor_5444( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) DataVector<HepMC::GenEvent>();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) DataVector<HepMC::GenEvent>(*(SG::OwnershipPolicy*)arg[0]);
  }
  return 0;
}
 
void* DataVector_HepMC__GenEvent__dict::constructor_5445( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) DataVector<HepMC::GenEvent>(*(unsigned int*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) DataVector<HepMC::GenEvent>(*(unsigned int*)arg[0],
                                              *(SG::OwnershipPolicy*)arg[1]);
  }
  return 0;
}
 
void* DataVector_HepMC__GenEvent__dict::constructor_5446( void* mem, const std::vector<void*>& arg) {
  return new(mem) DataVector<HepMC::GenEvent>(*(const DataVector<HepMC::GenEvent>*)arg[0]);
}
 
void* DataVector_HepMC__GenEvent__dict::constructor_x1( void* mem) {
  return new(mem) DataVector<HepMC::GenEvent>();
}
 
//------Dictionary for class Polarization -------------------------------
class HepMC__Polarization_dict { 
  public:
  HepMC__Polarization_dict();
  static void* constructor_5535( void*, const std::vector<void*>& );
  static void* constructor_5536( void*, const std::vector<void*>& );
  static void* constructor_5537( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::Polarization*)o)->~Polarization(); }
  static void* constructor_x2( void* );
};
static HepMC__Polarization_dict instance_2595;
 
HepMC__Polarization_dict::HepMC__Polarization_dict() {
  ClassBuilder _c_("HepMC::Polarization", "", typeid(HepMC::Polarization), sizeof(HepMC::Polarization),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_theta", "double", "", (int)(&((HepMC::Polarization*)64)->m_theta)-64, PRIVATE );
  _c_.addField("m_phi", "double", "", (int)(&((HepMC::Polarization*)64)->m_phi)-64, PRIVATE );
  _c_.addMethod("Polarization", "", "HepMC::Polarization", "double=; double=", constructor_5535, PUBLIC);
  _c_.addMethod("Polarization", "", "HepMC::Polarization", "HepMC::Polarization&", constructor_5536, PUBLIC);
  _c_.addMethod("Polarization", "", "HepMC::Polarization", "HepNormal3D&", constructor_5537, PUBLIC);
  _c_.addMethod("~Polarization", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("Polarization", "", "HepMC::Polarization", constructor_x2, PUBLIC);
  _c_.build();
}
 
void* HepMC__Polarization_dict::constructor_5535( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) HepMC::Polarization();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) HepMC::Polarization(*(double*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMC::Polarization(*(double*)arg[0],
                                      *(double*)arg[1]);
  }
  return 0;
}
 
void* HepMC__Polarization_dict::constructor_5536( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::Polarization(*(const HepMC::Polarization*)arg[0]);
}
 
void* HepMC__Polarization_dict::constructor_5537( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::Polarization(*(const HepNormal3D*)arg[0]);
}
 
void* HepMC__Polarization_dict::constructor_x2( void* mem) {
  return new(mem) HepMC::Polarization();
}
 
//------Dictionary for class Flow -------------------------------
class HepMC__Flow_dict { 
  public:
  HepMC__Flow_dict();
  static void* constructor_5555( void*, const std::vector<void*>& );
  static void* constructor_5556( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::Flow*)o)->~Flow(); }
  static void* constructor_x3( void* );
};
static HepMC__Flow_dict instance_2596;
 
HepMC__Flow_dict::HepMC__Flow_dict() {
  ClassBuilder _c_("HepMC::Flow", "", typeid(HepMC::Flow), sizeof(HepMC::Flow),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_particle_owner", "HepMC::GenParticle*", "", (int)(&((HepMC::Flow*)64)->m_particle_owner)-64, PRIVATE );
  _c_.addField("m_icode", "std::map<int,int>", "", (int)(&((HepMC::Flow*)64)->m_icode)-64, PRIVATE );
  _c_.addMethod("Flow", "", "HepMC::Flow", "HepMC::GenParticle*=", constructor_5555, PUBLIC);
  _c_.addMethod("Flow", "", "HepMC::Flow", "HepMC::Flow&", constructor_5556, PUBLIC);
  _c_.addMethod("~Flow", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("Flow", "", "HepMC::Flow", constructor_x3, PUBLIC);
  _c_.build();
}
 
void* HepMC__Flow_dict::constructor_5555( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) HepMC::Flow();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) HepMC::Flow((HepMC::GenParticle*)arg[0]);
  }
  return 0;
}
 
void* HepMC__Flow_dict::constructor_5556( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::Flow(*(const HepMC::Flow*)arg[0]);
}
 
void* HepMC__Flow_dict::constructor_x3( void* mem) {
  return new(mem) HepMC::Flow();
}
 
//------Dictionary for class GenVertex -------------------------------
class HepMC__GenVertex_dict { 
  public:
  HepMC__GenVertex_dict();
  static void* constructor_5590( void*, const std::vector<void*>& );
  static void* constructor_5591( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::GenVertex*)o)->~GenVertex(); }
  static void* constructor_x4( void* );
};
static HepMC__GenVertex_dict instance_2597;
 
HepMC__GenVertex_dict::HepMC__GenVertex_dict() {
  ClassBuilder _c_("HepMC::GenVertex", "", typeid(HepMC::GenVertex), sizeof(HepMC::GenVertex),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_position", "HepLorentzVector", "", (int)(&((HepMC::GenVertex*)64)->m_position)-64, PRIVATE );
  _c_.addField("m_particles_in", "std::set<HepMC::GenParticle*>", "", (int)(&((HepMC::GenVertex*)64)->m_particles_in)-64, PRIVATE );
  _c_.addField("m_particles_out", "std::set<HepMC::GenParticle*>", "", (int)(&((HepMC::GenVertex*)64)->m_particles_out)-64, PRIVATE );
  _c_.addField("m_id", "int", "", (int)(&((HepMC::GenVertex*)64)->m_id)-64, PRIVATE );
  _c_.addField("m_weights", "HepMC::WeightContainer", "", (int)(&((HepMC::GenVertex*)64)->m_weights)-64, PRIVATE );
  _c_.addField("m_event", "HepMC::GenEvent*", "", (int)(&((HepMC::GenVertex*)64)->m_event)-64, PRIVATE );
  _c_.addField("m_barcode", "int", "", (int)(&((HepMC::GenVertex*)64)->m_barcode)-64, PRIVATE );
  _c_.addMethod("GenVertex", "", "HepMC::GenVertex", "HepLorentzVector&=; int=; HepMC::WeightContainer&=", constructor_5590, PUBLIC);
  _c_.addMethod("GenVertex", "", "HepMC::GenVertex", "HepMC::GenVertex&", constructor_5591, PUBLIC);
  _c_.addMethod("~GenVertex", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("GenVertex", "", "HepMC::GenVertex", constructor_x4, PUBLIC);
  _c_.build();
}
 
void* HepMC__GenVertex_dict::constructor_5590( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) HepMC::GenVertex();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0],
                                   *(int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0],
                                   *(int*)arg[1],
                                   *(const HepMC::WeightContainer*)arg[2]);
  }
  return 0;
}
 
void* HepMC__GenVertex_dict::constructor_5591( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::GenVertex(*(const HepMC::GenVertex*)arg[0]);
}
 
void* HepMC__GenVertex_dict::constructor_x4( void* mem) {
  return new(mem) HepMC::GenVertex();
}
 
//------Dictionary for class GenEvent -------------------------------
class HepMC__GenEvent_dict { 
  public:
  HepMC__GenEvent_dict();
  static void* constructor_5641( void*, const std::vector<void*>& );
  static void* constructor_5642( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::GenEvent*)o)->~GenEvent(); }
  static void* constructor_x5( void* );
};
static HepMC__GenEvent_dict instance_2589;
 
HepMC__GenEvent_dict::HepMC__GenEvent_dict() {
  ClassBuilder _c_("HepMC::GenEvent", "", typeid(HepMC::GenEvent), sizeof(HepMC::GenEvent),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_signal_process_id", "int", "", (int)(&((HepMC::GenEvent*)64)->m_signal_process_id)-64, PRIVATE );
  _c_.addField("m_event_number", "int", "", (int)(&((HepMC::GenEvent*)64)->m_event_number)-64, PRIVATE );
  _c_.addField("m_event_scale", "double", "", (int)(&((HepMC::GenEvent*)64)->m_event_scale)-64, PRIVATE );
  _c_.addField("m_alphaQCD", "double", "", (int)(&((HepMC::GenEvent*)64)->m_alphaQCD)-64, PRIVATE );
  _c_.addField("m_alphaQED", "double", "", (int)(&((HepMC::GenEvent*)64)->m_alphaQED)-64, PRIVATE );
  _c_.addField("m_signal_process_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenEvent*)64)->m_signal_process_vertex)-64, PRIVATE );
  _c_.addField("m_weights", "HepMC::WeightContainer", "", (int)(&((HepMC::GenEvent*)64)->m_weights)-64, PRIVATE );
  _c_.addField("m_random_states", "std::vector<long int>", "", (int)(&((HepMC::GenEvent*)64)->m_random_states)-64, PRIVATE );
  _c_.addField("m_vertex_barcodes", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "", (int)(&((HepMC::GenEvent*)64)->m_vertex_barcodes)-64, PRIVATE );
  _c_.addField("m_particle_barcodes", "std::map<int,HepMC::GenParticle*>", "", (int)(&((HepMC::GenEvent*)64)->m_particle_barcodes)-64, PRIVATE );
  _c_.addMethod("GenEvent", "", "HepMC::GenEvent", "int=; int=; HepMC::GenVertex*=; HepMC::WeightContainer&=; std::vector<long int>&=", constructor_5641, PUBLIC);
  _c_.addMethod("GenEvent", "", "HepMC::GenEvent", "HepMC::GenEvent&", constructor_5642, PUBLIC);
  _c_.addMethod("~GenEvent", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("GenEvent", "", "HepMC::GenEvent", constructor_x5, PUBLIC);
  _c_.build();
}
 
void* HepMC__GenEvent_dict::constructor_5641( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) HepMC::GenEvent();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) HepMC::GenEvent(*(int*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMC::GenEvent(*(int*)arg[0],
                                  *(int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) HepMC::GenEvent(*(int*)arg[0],
                                  *(int*)arg[1],
                                  (HepMC::GenVertex*)arg[2]);
  }
  else if ( arg.size() == 4 ) { 
    return new(mem) HepMC::GenEvent(*(int*)arg[0],
                                  *(int*)arg[1],
                                  (HepMC::GenVertex*)arg[2],
                                  *(const HepMC::WeightContainer*)arg[3]);
  }
  else if ( arg.size() == 5 ) { 
    return new(mem) HepMC::GenEvent(*(int*)arg[0],
                                  *(int*)arg[1],
                                  (HepMC::GenVertex*)arg[2],
                                  *(const HepMC::WeightContainer*)arg[3],
                                  *(const std::vector<long int>*)arg[4]);
  }
  return 0;
}
 
void* HepMC__GenEvent_dict::constructor_5642( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::GenEvent(*(const HepMC::GenEvent*)arg[0]);
}
 
void* HepMC__GenEvent_dict::constructor_x5( void* mem) {
  return new(mem) HepMC::GenEvent();
}
 
//------Dictionary for class GenParticle -------------------------------
class HepMC__GenParticle_dict { 
  public:
  HepMC__GenParticle_dict();
  static void* constructor_5693( void* );
  static void* constructor_5694( void*, const std::vector<void*>& );
  static void* constructor_5695( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::GenParticle*)o)->~GenParticle(); }
};
static HepMC__GenParticle_dict instance_2594;
 
HepMC__GenParticle_dict::HepMC__GenParticle_dict() {
  ClassBuilder _c_("HepMC::GenParticle", "", typeid(HepMC::GenParticle), sizeof(HepMC::GenParticle),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_momentum", "HepLorentzVector", "", (int)(&((HepMC::GenParticle*)64)->m_momentum)-64, PRIVATE );
  _c_.addField("m_pdg_id", "int", "", (int)(&((HepMC::GenParticle*)64)->m_pdg_id)-64, PRIVATE );
  _c_.addField("m_status", "int", "", (int)(&((HepMC::GenParticle*)64)->m_status)-64, PRIVATE );
  _c_.addField("m_flow", "HepMC::Flow", "", (int)(&((HepMC::GenParticle*)64)->m_flow)-64, PRIVATE );
  _c_.addField("m_polarization", "HepMC::Polarization", "", (int)(&((HepMC::GenParticle*)64)->m_polarization)-64, PRIVATE );
  _c_.addField("m_production_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenParticle*)64)->m_production_vertex)-64, PRIVATE );
  _c_.addField("m_end_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenParticle*)64)->m_end_vertex)-64, PRIVATE );
  _c_.addField("m_barcode", "int", "", (int)(&((HepMC::GenParticle*)64)->m_barcode)-64, PRIVATE );
  _c_.addMethod("GenParticle", "", "HepMC::GenParticle", constructor_5693, PUBLIC);
  _c_.addMethod("GenParticle", "", "HepMC::GenParticle", "HepLorentzVector&; int; int=; HepMC::Flow&=; HepMC::Polarization&=", constructor_5694, PUBLIC);
  _c_.addMethod("GenParticle", "", "HepMC::GenParticle", "HepMC::GenParticle&", constructor_5695, PUBLIC);
  _c_.addMethod("~GenParticle", "", destructor, PUBLIC | VIRTUAL);
  _c_.build();
}
 
void* HepMC__GenParticle_dict::constructor_5693( void* mem) {
  return new(mem) HepMC::GenParticle();
}
 
void* HepMC__GenParticle_dict::constructor_5694( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
                                     *(int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
                                     *(int*)arg[1],
                                     *(int*)arg[2]);
  }
  else if ( arg.size() == 4 ) { 
    return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
                                     *(int*)arg[1],
                                     *(int*)arg[2],
                                     *(const HepMC::Flow*)arg[3]);
  }
  else if ( arg.size() == 5 ) { 
    return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
                                     *(int*)arg[1],
                                     *(int*)arg[2],
                                     *(const HepMC::Flow*)arg[3],
                                     *(const HepMC::Polarization*)arg[4]);
  }
  return 0;
}
 
void* HepMC__GenParticle_dict::constructor_5695( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::GenParticle(*(const HepMC::GenParticle*)arg[0]);
}
 
//------Dictionary for class WeightContainer -------------------------------
class HepMC__WeightContainer_dict { 
  public:
  HepMC__WeightContainer_dict();
  static void* constructor_5726( void*, const std::vector<void*>& );
  static void* constructor_5727( void*, const std::vector<void*>& );
  static void* constructor_5728( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((HepMC::WeightContainer*)o)->~WeightContainer(); }
  static void* constructor_x6( void* );
};
static HepMC__WeightContainer_dict instance_3617;
 
HepMC__WeightContainer_dict::HepMC__WeightContainer_dict() {
  ClassBuilder _c_("HepMC::WeightContainer", "", typeid(HepMC::WeightContainer), sizeof(HepMC::WeightContainer),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
  _c_.addField("m_weights", "std::vector<double>", "", (int)(&((HepMC::WeightContainer*)64)->m_weights)-64, PRIVATE );
  _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "unsigned int=; double&=", constructor_5726, PUBLIC);
  _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "std::vector<double>&", constructor_5727, PUBLIC);
  _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "HepMC::WeightContainer&", constructor_5728, PUBLIC);
  _c_.addMethod("~WeightContainer", "", destructor, PUBLIC | VIRTUAL);
  _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", constructor_x6, PUBLIC);
  _c_.build();
}
 
void* HepMC__WeightContainer_dict::constructor_5726( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) HepMC::WeightContainer();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) HepMC::WeightContainer(*(unsigned int*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) HepMC::WeightContainer(*(unsigned int*)arg[0],
                                         *(const double*)arg[1]);
  }
  return 0;
}
 
void* HepMC__WeightContainer_dict::constructor_5727( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::WeightContainer(*(const std::vector<double>*)arg[0]);
}
 
void* HepMC__WeightContainer_dict::constructor_5728( void* mem, const std::vector<void*>& arg) {
  return new(mem) HepMC::WeightContainer(*(const HepMC::WeightContainer*)arg[0]);
}
 
void* HepMC__WeightContainer_dict::constructor_x6( void* mem) {
  return new(mem) HepMC::WeightContainer();
}
 
//------Dictionary for class vector<HepMC::GenEvent*,std::allocator<HepMC::GenEvent*> > -------------------------------
class std__vector_HepMC__GenEventp__dict { 
  public:
  std__vector_HepMC__GenEventp__dict();
  static int tobase_6652(void*);
  static void* constructor_6687( void*, const std::vector<void*>& );
  static void* constructor_6688( void*, const std::vector<void*>& );
  static void* constructor_6689( void*, const std::vector<void*>& );
  static void* constructor_6690( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((std::vector<HepMC::GenEvent*>*)o)->~vector(); }
  static void* constructor_x7( void* );
  static void* method_x8( void*, const std::vector<void*>& ); 
  static void* method_x9( void*, const std::vector<void*>& ); 
};
static std__vector_HepMC__GenEventp__dict instance_5421;
 
std__vector_HepMC__GenEventp__dict::std__vector_HepMC__GenEventp__dict() {
  ClassBuilder _c_("std::vector<HepMC::GenEvent*>", "", typeid(std::vector<HepMC::GenEvent*>), sizeof(std::vector<HepMC::GenEvent*>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
  _c_.addSuperClass("std::_Vector_base<HepMC::GenEvent*,std::allocator<HepMC::GenEvent*> >", 0, tobase_6652);
  _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "std::allocator<HepMC::GenEvent*>&=", constructor_6687, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "unsigned int; HepMC::GenEvent*&; std::allocator<HepMC::GenEvent*>&=", constructor_6688, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "unsigned int", constructor_6689, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "std::vector<HepMC::GenEvent*>&", constructor_6690, PUBLIC);
  _c_.addMethod("~vector", "", destructor, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", constructor_x7, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x8);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x9);
  _c_.build();
}
 
int std__vector_HepMC__GenEventp__dict::tobase_6652( void* o ) {
  return (int)(std::_Vector_base<HepMC::GenEvent*,std::allocator<HepMC::GenEvent*> >*)(std::vector<HepMC::GenEvent*>*)o - (int)(std::vector<HepMC::GenEvent*>*)o;
}
 
void* std__vector_HepMC__GenEventp__dict::constructor_6687( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) std::vector<HepMC::GenEvent*>();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) std::vector<HepMC::GenEvent*>(*(const std::allocator<HepMC::GenEvent*>*)arg[0]);
  }
  return 0;
}
 
void* std__vector_HepMC__GenEventp__dict::constructor_6688( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0],
                                                *(HepMC::GenEvent* const*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0],
                                                *(HepMC::GenEvent* const*)arg[1],
                                                *(const std::allocator<HepMC::GenEvent*>*)arg[2]);
  }
  return 0;
}
 
void* std__vector_HepMC__GenEventp__dict::constructor_6689( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0]);
}
 
void* std__vector_HepMC__GenEventp__dict::constructor_6690( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<HepMC::GenEvent*>(*(const std::vector<HepMC::GenEvent*>*)arg[0]);
}
 
void* std__vector_HepMC__GenEventp__dict::constructor_x7( void* mem) {
  return new(mem) std::vector<HepMC::GenEvent*>();
}
 
void* std__vector_HepMC__GenEventp__dict::method_x8( void* o, const std::vector<void*>& args)
{
  std::vector<HepMC::GenEvent*>* v = (std::vector<HepMC::GenEvent*>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  for(std::vector<HepMC::GenEvent*>::iterator i = v->begin(); i != v->end(); i++) {
    ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
  }
  return 0;
}
 
void* std__vector_HepMC__GenEventp__dict::method_x9( void* o, const std::vector<void*>& args)
{
  std::vector<HepMC::GenEvent*>* v = (std::vector<HepMC::GenEvent*>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::vector<HepMC::GenEvent*>::value_type o = 0; // fill with new HepMC::GenEvent;
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
      v->push_back(o);
    }
  ;
}  return 0;
}
 
//------Dictionary for class map<int,int,std::less<int>,std::allocator<std::pair<const int, int> > > -------------------------------
class std__map_int_int__dict { 
  public:
  std__map_int_int__dict();
  static void  destructor( void* o ) { ((std::map<int,int>*)o)->~map(); }
  static void* constructor_7188( void* );
  static void* constructor_7189( void*, const std::vector<void*>& );
  static void* constructor_7190( void*, const std::vector<void*>& );
  static void* method_x10( void*, const std::vector<void*>& ); 
  static void* method_x11( void*, const std::vector<void*>& ); 
};
static std__map_int_int__dict instance_5963;
 
std__map_int_int__dict::std__map_int_int__dict() {
  ClassBuilder _c_("std::map<int,int>", "", typeid(std::map<int,int>), sizeof(std::map<int,int>),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
  _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,int>,std::_Select1st<std::pair<const int,int> >,std::less<int>,std::allocator<std::pair<const int,int> > >", "", (int)(&((std::map<int,int>*)64)->_M_t)-64, PRIVATE );
  _c_.addMethod("~map", "", destructor, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,int>", constructor_7188, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,int>", "std::less<int>&; std::allocator<std::pair<const int,int> >&=", constructor_7189, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,int>", "std::map<int,int>&", constructor_7190, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x10);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x11);
  _c_.build();
}
 
void* std__map_int_int__dict::constructor_7188( void* mem) {
  return new(mem) std::map<int,int>();
}
 
void* std__map_int_int__dict::constructor_7189( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) std::map<int,int>(*(const std::less<int>*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) std::map<int,int>(*(const std::less<int>*)arg[0],
                                    *(const std::allocator<std::pair<const int,int> >*)arg[1]);
  }
  return 0;
}
 
void* std__map_int_int__dict::constructor_7190( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::map<int,int>(*(const std::map<int,int>*)arg[0]);
}
 
void* std__map_int_int__dict::method_x10( void* o, const std::vector<void*>& args)
{
  std::map<int,int>* v = (std::map<int,int>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  if ( n > 0 ) {
    for(std::map<int,int>::iterator i = v->begin(); i != v->end(); i++) {
    std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
    }
  }
  return 0; 
}
 
void* std__map_int_int__dict::method_x11( void* o, const std::vector<void*>& args)
{
  std::map<int,int>* v = (std::map<int,int>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::pair<std::map<int,int>::key_type, std::map<int,int>::value_type::second_type> t;
      std::pair<void*, void*> pt(&t.first, &t.second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
      v->insert(t);
    }
  }
  return 0;
}
 
//------Dictionary for class set<HepMC::GenParticle*,std::less<HepMC::GenParticle*>,std::allocator<HepMC::GenParticle*> > -------------------------------
class std__set_HepMC__GenParticlep__dict { 
  public:
  std__set_HepMC__GenParticlep__dict();
  static void  destructor( void* o ) { ((std::set<HepMC::GenParticle*>*)o)->~set(); }
  static void* constructor_7245( void* );
  static void* constructor_7246( void*, const std::vector<void*>& );
  static void* constructor_7247( void*, const std::vector<void*>& );
  static void* method_x12( void*, const std::vector<void*>& ); 
  static void* method_x13( void*, const std::vector<void*>& ); 
};
static std__set_HepMC__GenParticlep__dict instance_6737;
 
std__set_HepMC__GenParticlep__dict::std__set_HepMC__GenParticlep__dict() {
  ClassBuilder _c_("std::set<HepMC::GenParticle*>", "", typeid(std::set<HepMC::GenParticle*>), sizeof(std::set<HepMC::GenParticle*>),std::vector<const std::type_info*>(), false, SET, 0, PUBLIC);
  _c_.addField("_M_t", "std::_Rb_tree<HepMC::GenParticle*,HepMC::GenParticle*,std::_Identity<HepMC::GenParticle*>,std::less<HepMC::GenParticle*>,std::allocator<HepMC::GenParticle*> >", "", (int)(&((std::set<HepMC::GenParticle*>*)64)->_M_t)-64, PRIVATE );
  _c_.addMethod("~set", "", destructor, PUBLIC);
  _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", constructor_7245, PUBLIC);
  _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", "std::less<HepMC::GenParticle*>&; std::allocator<HepMC::GenParticle*>&=", constructor_7246, PUBLIC);
  _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", "std::set<HepMC::GenParticle*>&", constructor_7247, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x12);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x13);
  _c_.build();
}
 
void* std__set_HepMC__GenParticlep__dict::constructor_7245( void* mem) {
  return new(mem) std::set<HepMC::GenParticle*>();
}
 
void* std__set_HepMC__GenParticlep__dict::constructor_7246( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) std::set<HepMC::GenParticle*>(*(const std::less<HepMC::GenParticle*>*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) std::set<HepMC::GenParticle*>(*(const std::less<HepMC::GenParticle*>*)arg[0],
                                                *(const std::allocator<HepMC::GenParticle*>*)arg[1]);
  }
  return 0;
}
 
void* std__set_HepMC__GenParticlep__dict::constructor_7247( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::set<HepMC::GenParticle*>(*(const std::set<HepMC::GenParticle*>*)arg[0]);
}
 
void* std__set_HepMC__GenParticlep__dict::method_x12( void* o, const std::vector<void*>& args)
{
  std::set<HepMC::GenParticle*>* v = (std::set<HepMC::GenParticle*>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  for(std::set<HepMC::GenParticle*>::iterator i = v->begin(); i != v->end(); i++) {
    ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
  }
  return 0;
}
 
void* std__set_HepMC__GenParticlep__dict::method_x13( void* o, const std::vector<void*>& args)
{
  std::set<HepMC::GenParticle*>* v = (std::set<HepMC::GenParticle*>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::set<HepMC::GenParticle*>::value_type o = 0; // fill with new HepMC::GenParticle;
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
      v->insert(o);
    }
  ;
}  return 0;
}
 
//------Dictionary for class vector<long int,std::allocator<long int> > -------------------------------
class std__vector_longsint__dict { 
  public:
  std__vector_longsint__dict();
  static int tobase_7315(void*);
  static void* constructor_7352( void*, const std::vector<void*>& );
  static void* constructor_7353( void*, const std::vector<void*>& );
  static void* constructor_7354( void*, const std::vector<void*>& );
  static void* constructor_7355( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((std::vector<long int>*)o)->~vector(); }
  static void* constructor_x14( void* );
  static void* method_x15( void*, const std::vector<void*>& ); 
  static void* method_x16( void*, const std::vector<void*>& ); 
};
static std__vector_longsint__dict instance_6816;
 
std__vector_longsint__dict::std__vector_longsint__dict() {
  ClassBuilder _c_("std::vector<long int>", "", typeid(std::vector<long int>), sizeof(std::vector<long int>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
  _c_.addSuperClass("std::_Vector_base<long int,std::allocator<long int> >", 0, tobase_7315);
  _c_.addMethod("vector", "", "std::vector<long int>", "std::allocator<long int>&=", constructor_7352, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<long int>", "unsigned int; long int&; std::allocator<long int>&=", constructor_7353, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<long int>", "unsigned int", constructor_7354, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<long int>", "std::vector<long int>&", constructor_7355, PUBLIC);
  _c_.addMethod("~vector", "", destructor, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<long int>", constructor_x14, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x15);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x16);
  _c_.build();
}
 
int std__vector_longsint__dict::tobase_7315( void* o ) {
  return (int)(std::_Vector_base<long int,std::allocator<long int> >*)(std::vector<long int>*)o - (int)(std::vector<long int>*)o;
}
 
void* std__vector_longsint__dict::constructor_7352( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) std::vector<long int>();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) std::vector<long int>(*(const std::allocator<long int>*)arg[0]);
  }
  return 0;
}
 
void* std__vector_longsint__dict::constructor_7353( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::vector<long int>(*(unsigned int*)arg[0],
                                        *(const long int*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::vector<long int>(*(unsigned int*)arg[0],
                                        *(const long int*)arg[1],
                                        *(const std::allocator<long int>*)arg[2]);
  }
  return 0;
}
 
void* std__vector_longsint__dict::constructor_7354( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<long int>(*(unsigned int*)arg[0]);
}
 
void* std__vector_longsint__dict::constructor_7355( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<long int>(*(const std::vector<long int>*)arg[0]);
}
 
void* std__vector_longsint__dict::constructor_x14( void* mem) {
  return new(mem) std::vector<long int>();
}
 
void* std__vector_longsint__dict::method_x15( void* o, const std::vector<void*>& args)
{
  std::vector<long int>* v = (std::vector<long int>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  for(std::vector<long int>::iterator i = v->begin(); i != v->end(); i++) {
    ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
  }
  return 0;
}
 
void* std__vector_longsint__dict::method_x16( void* o, const std::vector<void*>& args)
{
  std::vector<long int>* v = (std::vector<long int>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::vector<long int>::value_type o;
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
      v->push_back(o);
    }
  ;
}  return 0;
}
 
//------Dictionary for class map<int,HepMC::GenVertex*,std::greater<int>,std::allocator<std::pair<const int, HepMC::GenVertex*> > > -------------------------------
class std__map_int_HepMC__GenVertexp_std__greater_int_s__dict { 
  public:
  std__map_int_HepMC__GenVertexp_std__greater_int_s__dict();
  static void  destructor( void* o ) { ((std::map<int,HepMC::GenVertex*,std::greater<int> >*)o)->~map(); }
  static void* constructor_7402( void* );
  static void* constructor_7403( void*, const std::vector<void*>& );
  static void* constructor_7404( void*, const std::vector<void*>& );
  static void* method_x17( void*, const std::vector<void*>& ); 
  static void* method_x18( void*, const std::vector<void*>& ); 
};
static std__map_int_HepMC__GenVertexp_std__greater_int_s__dict instance_6817;
 
std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::std__map_int_HepMC__GenVertexp_std__greater_int_s__dict() {
  ClassBuilder _c_("std::map<int,HepMC::GenVertex*,std::greater<int> >", "", typeid(std::map<int,HepMC::GenVertex*,std::greater<int> >), sizeof(std::map<int,HepMC::GenVertex*,std::greater<int> >),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
  _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,HepMC::GenVertex*>,std::_Select1st<std::pair<const int,HepMC::GenVertex*> >,std::greater<int>,std::allocator<std::pair<const int,HepMC::GenVertex*> > >", "", (int)(&((std::map<int,HepMC::GenVertex*,std::greater<int> >*)64)->_M_t)-64, PRIVATE );
  _c_.addMethod("~map", "", destructor, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", constructor_7402, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "std::greater<int>&; std::allocator<std::pair<const int,HepMC::GenVertex*> >&=", constructor_7403, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "std::map<int,HepMC::GenVertex*,std::greater<int> >&", constructor_7404, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x17);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x18);
  _c_.build();
}
 
void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7402( void* mem) {
  return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >();
}
 
void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7403( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::greater<int>*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::greater<int>*)arg[0],
                                                                     *(const std::allocator<std::pair<const int,HepMC::GenVertex*> >*)arg[1]);
  }
  return 0;
}
 
void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7404( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::map<int,HepMC::GenVertex*,std::greater<int> >*)arg[0]);
}
 
void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::method_x17( void* o, const std::vector<void*>& args)
{
  std::map<int,HepMC::GenVertex*,std::greater<int> >* v = (std::map<int,HepMC::GenVertex*,std::greater<int> >*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  if ( n > 0 ) {
    for(std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator i = v->begin(); i != v->end(); i++) {
    std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
    }
  }
  return 0; 
}
 
void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::method_x18( void* o, const std::vector<void*>& args)
{
  std::map<int,HepMC::GenVertex*,std::greater<int> >* v = (std::map<int,HepMC::GenVertex*,std::greater<int> >*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::pair<std::map<int,HepMC::GenVertex*,std::greater<int> >::key_type, std::map<int,HepMC::GenVertex*,std::greater<int> >::value_type::second_type> t;
      t.second = 0; // fill with new HepMC::GenVertex;
      std::pair<void*, void*> pt(&t.first, &t.second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
      v->insert(t);
    }
  }
  return 0;
}
 
//------Dictionary for class map<int,HepMC::GenParticle*,std::less<int>,std::allocator<std::pair<const int, HepMC::GenParticle*> > > -------------------------------
class std__map_int_HepMC__GenParticlep__dict { 
  public:
  std__map_int_HepMC__GenParticlep__dict();
  static void  destructor( void* o ) { ((std::map<int,HepMC::GenParticle*>*)o)->~map(); }
  static void* constructor_7461( void* );
  static void* constructor_7462( void*, const std::vector<void*>& );
  static void* constructor_7463( void*, const std::vector<void*>& );
  static void* method_x19( void*, const std::vector<void*>& ); 
  static void* method_x20( void*, const std::vector<void*>& ); 
};
static std__map_int_HepMC__GenParticlep__dict instance_6818;
 
std__map_int_HepMC__GenParticlep__dict::std__map_int_HepMC__GenParticlep__dict() {
  ClassBuilder _c_("std::map<int,HepMC::GenParticle*>", "", typeid(std::map<int,HepMC::GenParticle*>), sizeof(std::map<int,HepMC::GenParticle*>),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
  _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,HepMC::GenParticle*>,std::_Select1st<std::pair<const int,HepMC::GenParticle*> >,std::less<int>,std::allocator<std::pair<const int,HepMC::GenParticle*> > >", "", (int)(&((std::map<int,HepMC::GenParticle*>*)64)->_M_t)-64, PRIVATE );
  _c_.addMethod("~map", "", destructor, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", constructor_7461, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", "std::less<int>&; std::allocator<std::pair<const int,HepMC::GenParticle*> >&=", constructor_7462, PUBLIC);
  _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", "std::map<int,HepMC::GenParticle*>&", constructor_7463, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x19);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x20);
  _c_.build();
}
 
void* std__map_int_HepMC__GenParticlep__dict::constructor_7461( void* mem) {
  return new(mem) std::map<int,HepMC::GenParticle*>();
}
 
void* std__map_int_HepMC__GenParticlep__dict::constructor_7462( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 1 ) {
    return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::less<int>*)arg[0]);
  }
  else if ( arg.size() == 2 ) { 
    return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::less<int>*)arg[0],
                                                    *(const std::allocator<std::pair<const int,HepMC::GenParticle*> >*)arg[1]);
  }
  return 0;
}
 
void* std__map_int_HepMC__GenParticlep__dict::constructor_7463( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::map<int,HepMC::GenParticle*>*)arg[0]);
}
 
void* std__map_int_HepMC__GenParticlep__dict::method_x19( void* o, const std::vector<void*>& args)
{
  std::map<int,HepMC::GenParticle*>* v = (std::map<int,HepMC::GenParticle*>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  if ( n > 0 ) {
    for(std::map<int,HepMC::GenParticle*>::iterator i = v->begin(); i != v->end(); i++) {
    std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
    }
  }
  return 0; 
}
 
void* std__map_int_HepMC__GenParticlep__dict::method_x20( void* o, const std::vector<void*>& args)
{
  std::map<int,HepMC::GenParticle*>* v = (std::map<int,HepMC::GenParticle*>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::pair<std::map<int,HepMC::GenParticle*>::key_type, std::map<int,HepMC::GenParticle*>::value_type::second_type> t;
      t.second = 0; // fill with new HepMC::GenParticle;
      std::pair<void*, void*> pt(&t.first, &t.second);
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
      v->insert(t);
    }
  }
  return 0;
}
 
//------Dictionary for class vector<double,std::allocator<double> > -------------------------------
class std__vector_double__dict { 
  public:
  std__vector_double__dict();
  static int tobase_7511(void*);
  static void* constructor_7548( void*, const std::vector<void*>& );
  static void* constructor_7549( void*, const std::vector<void*>& );
  static void* constructor_7550( void*, const std::vector<void*>& );
  static void* constructor_7551( void*, const std::vector<void*>& );
  static void  destructor( void* o ) { ((std::vector<double>*)o)->~vector(); }
  static void* constructor_x21( void* );
  static void* method_x22( void*, const std::vector<void*>& ); 
  static void* method_x23( void*, const std::vector<void*>& ); 
};
static std__vector_double__dict instance_6870;
 
std__vector_double__dict::std__vector_double__dict() {
  ClassBuilder _c_("std::vector<double>", "", typeid(std::vector<double>), sizeof(std::vector<double>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
  _c_.addSuperClass("std::_Vector_base<double,std::allocator<double> >", 0, tobase_7511);
  _c_.addMethod("vector", "", "std::vector<double>", "std::allocator<double>&=", constructor_7548, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<double>", "unsigned int; double&; std::allocator<double>&=", constructor_7549, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<double>", "unsigned int", constructor_7550, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<double>", "std::vector<double>&", constructor_7551, PUBLIC);
  _c_.addMethod("~vector", "", destructor, PUBLIC);
  _c_.addMethod("vector", "", "std::vector<double>", constructor_x21, PUBLIC);
  _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x22);
  _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x23);
  _c_.build();
}
 
int std__vector_double__dict::tobase_7511( void* o ) {
  return (int)(std::_Vector_base<double,std::allocator<double> >*)(std::vector<double>*)o - (int)(std::vector<double>*)o;
}
 
void* std__vector_double__dict::constructor_7548( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 0 ) {
    return new(mem) std::vector<double>();
  }
  else if ( arg.size() == 1 ) { 
    return new(mem) std::vector<double>(*(const std::allocator<double>*)arg[0]);
  }
  return 0;
}
 
void* std__vector_double__dict::constructor_7549( void* mem, const std::vector<void*>& arg) {
  if ( arg.size() == 2 ) {
    return new(mem) std::vector<double>(*(unsigned int*)arg[0],
                                      *(const double*)arg[1]);
  }
  else if ( arg.size() == 3 ) { 
    return new(mem) std::vector<double>(*(unsigned int*)arg[0],
                                      *(const double*)arg[1],
                                      *(const std::allocator<double>*)arg[2]);
  }
  return 0;
}
 
void* std__vector_double__dict::constructor_7550( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<double>(*(unsigned int*)arg[0]);
}
 
void* std__vector_double__dict::constructor_7551( void* mem, const std::vector<void*>& arg) {
  return new(mem) std::vector<double>(*(const std::vector<double>*)arg[0]);
}
 
void* std__vector_double__dict::constructor_x21( void* mem) {
  return new(mem) std::vector<double>();
}
 
void* std__vector_double__dict::method_x22( void* o, const std::vector<void*>& args)
{
  std::vector<double>* v = (std::vector<double>*)o;
  size_t n = v->size();
  ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
  for(std::vector<double>::iterator i = v->begin(); i != v->end(); i++) {
    ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
  }
  return 0;
}
 
void* std__vector_double__dict::method_x23( void* o, const std::vector<void*>& args)
{
  std::vector<double>* v = (std::vector<double>*)o;
  size_t n = *(size_t*)args[1];
  if (n > 0) {
    for(size_t i = 0; i < n; i++) {
      std::vector<double>::value_type o;
      ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
      v->push_back(o);
    }
  ;
}  return 0;
}