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;
}